Remove print statement in favor of print() function in docs and examples

<!-- Provide a general summary of your proposed changes in the Title field above -->

### Description
<!-- Describe your changes in detail -->
Remove print statements

### Checklist
<!-- go over following points. check them with an `x` if they do apply, (they turn into clickable checkboxes once the PR is submitted, so no need to do everything at once)

-->

This pull request is:

- [X] A documentation / typographical error fix
	- Good to go, no issue or tests are needed
- [ ] A short code fix
	- please include the issue number, and create an issue if none exists, which
	  must include a complete example of the issue.  one line code fixes without an
	  issue and demonstration will not be accepted.
	- Please include: `Fixes: #<issue number>` in the commit message
	- please include tests.   one line code fixes without tests will not be accepted.
- [ ] A new feature implementation
	- please include the issue number, and create an issue if none exists, which must
	  include a complete example of how the feature would look.
	- Please include: `Fixes: #<issue number>` in the commit message
	- please include tests.

**Have a nice day!**

Closes: #5166
Pull-request: https://github.com/sqlalchemy/sqlalchemy/pull/5166
Pull-request-sha: 04a7394f71298322188f0861b4dfe93e5485839d

Change-Id: Ib90a59fac929661a18748c6e44966fb87e3978c6

19 files changed, 63 insertions, 63 deletions

diff --git a/doc/build/changelog/migration_11.rst b/doc/build/changelog/migration_11.rst
index 43d3dab37..56eca6294 100644
--- a/doc/build/changelog/migration_11.rst
+++ b/doc/build/changelog/migration_11.rst
@@ -1198,13 +1198,13 @@ RANGE and ROWS expressions for window functions::
 
     >>> from sqlalchemy import func
 
-    >>> print func.row_number().over(order_by='x', range_=(-5, 10))
+    >>> print(func.row_number().over(order_by='x', range_=(-5, 10)))
     row_number() OVER (ORDER BY x RANGE BETWEEN :param_1 PRECEDING AND :param_2 FOLLOWING)
 
-    >>> print func.row_number().over(order_by='x', rows=(None, 0))
+    >>> print(func.row_number().over(order_by='x', rows=(None, 0)))
     row_number() OVER (ORDER BY x ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
 
-    >>> print func.row_number().over(order_by='x', range_=(-2, None))
+    >>> print(func.row_number().over(order_by='x', range_=(-2, None)))
     row_number() OVER (ORDER BY x RANGE BETWEEN :param_1 PRECEDING AND UNBOUNDED FOLLOWING)
 
 :paramref:`.expression.over.range_` and :paramref:`.expression.over.rows` are specified as
@@ -1384,19 +1384,19 @@ New operators :meth:`.ColumnOperators.is_distinct_from` and
 :meth:`.ColumnOperators.isnot_distinct_from` allow the IS DISTINCT
 FROM and IS NOT DISTINCT FROM sql operation::
 
-    >>> print column('x').is_distinct_from(None)
+    >>> print(column('x').is_distinct_from(None))
     x IS DISTINCT FROM NULL
 
 Handling is provided for NULL, True and False::
 
-    >>> print column('x').isnot_distinct_from(False)
+    >>> print(column('x').isnot_distinct_from(False))
     x IS NOT DISTINCT FROM false
 
 For SQLite, which doesn't have this operator, "IS" / "IS NOT" is rendered,
 which on SQLite works for NULL unlike other backends::
 
     >>> from sqlalchemy.dialects import sqlite
-    >>> print column('x').is_distinct_from(None).compile(dialect=sqlite.dialect())
+    >>> print(column('x').is_distinct_from(None).compile(dialect=sqlite.dialect()))
     x IS NOT NULL
 
 .. _change_1957:
@@ -2322,7 +2322,7 @@ passed through the literal quoting system::
     >>> from sqlalchemy.schema import MetaData, Table, Column, CreateTable
     >>> from sqlalchemy.types import String
     >>> t = Table('t', MetaData(), Column('x', String(), server_default="hi ' there"))
-    >>> print CreateTable(t)
+    >>> print(CreateTable(t))
 
     CREATE TABLE t (
         x VARCHAR DEFAULT 'hi '' there'
diff --git a/doc/build/core/defaults.rst b/doc/build/core/defaults.rst
index 0f9755649..06963ac43 100644
--- a/doc/build/core/defaults.rst
+++ b/doc/build/core/defaults.rst
@@ -396,7 +396,7 @@ appropriate for the target backend::
 
     >>> my_seq = Sequence('some_sequence')
     >>> stmt = select([my_seq.next_value()])
-    >>> print stmt.compile(dialect=postgresql.dialect())
+    >>> print(stmt.compile(dialect=postgresql.dialect()))
     SELECT nextval('some_sequence') AS next_value_1
 
 .. _sequence_metadata:
diff --git a/doc/build/faq/sqlexpressions.rst b/doc/build/faq/sqlexpressions.rst
index 6a52e747d..0dd5e10df 100644
--- a/doc/build/faq/sqlexpressions.rst
+++ b/doc/build/faq/sqlexpressions.rst
@@ -201,16 +201,16 @@ What if we defaulted the value of :paramref:`.Operators.op.precedence` to 100,
 e.g. the highest?  Then this expression makes more parenthesis, but is
 otherwise OK, that is, these two are equivalent::
 
-    >>> print (column('q') - column('y')).op('+', precedence=100)(column('z'))
+    >>> print((column('q') - column('y')).op('+', precedence=100)(column('z')))
     (q - y) + z
-    >>> print (column('q') - column('y')).op('+')(column('z'))
+    >>> print((column('q') - column('y')).op('+')(column('z')))
     q - y + z
 
 but these two are not::
 
-    >>> print column('q') - column('y').op('+', precedence=100)(column('z'))
+    >>> print(column('q') - column('y').op('+', precedence=100)(column('z')))
     q - y + z
-    >>> print column('q') - column('y').op('+')(column('z'))
+    >>> print(column('q') - column('y').op('+')(column('z')))
     q - (y + z)
 
 For now, it's not clear that as long as we are doing parenthesization based on
diff --git a/examples/dogpile_caching/__init__.py b/examples/dogpile_caching/__init__.py
index 91105dc02..de4a339a7 100644
--- a/examples/dogpile_caching/__init__.py
+++ b/examples/dogpile_caching/__init__.py
@@ -25,7 +25,7 @@ E.g.::
     q = q.options(RelationshipCache(Person.addresses, "default"))
 
     # query
-    print q.all()
+    print(q.all())
 
 To run, both SQLAlchemy and dogpile.cache must be
 installed or on the current PYTHONPATH. The demo will create a local
diff --git a/examples/elementtree/__init__.py b/examples/elementtree/__init__.py
index 82bb87361..b2d90a739 100644
--- a/examples/elementtree/__init__.py
+++ b/examples/elementtree/__init__.py
@@ -17,7 +17,7 @@ E.g.::
     # locate documents with a certain path/attribute structure
     for document in find_document('/somefile/header/field2[@attr=foo]'):
         # dump the XML
-        print document
+        print(document)
 
 .. autosource::
     :files: pickle_type.py, adjacency_list.py, optimized_al.py
diff --git a/examples/graphs/__init__.py b/examples/graphs/__init__.py
index 0f8fe58a7..cd0d1ddd8 100644
--- a/examples/graphs/__init__.py
+++ b/examples/graphs/__init__.py
@@ -6,7 +6,7 @@ and querying for lower- and upper- neighbors are illustrated::
     n2 = Node(2)
     n5 = Node(5)
     n2.add_neighbor(n5)
-    print n2.higher_neighbors()
+    print(n2.higher_neighbors())
 
 .. autosource::
 
diff --git a/examples/postgis/__init__.py b/examples/postgis/__init__.py
index 963a561f3..dcdbfcf57 100644
--- a/examples/postgis/__init__.py
+++ b/examples/postgis/__init__.py
@@ -31,8 +31,8 @@ and simple to use extension points.
 
 E.g.::
 
-    print session.query(Road).filter(
-        Road.road_geom.intersects(r1.road_geom)).all()
+    print(session.query(Road).filter(
+        Road.road_geom.intersects(r1.road_geom)).all())
 
 .. autosource::
 
diff --git a/examples/vertical/__init__.py b/examples/vertical/__init__.py
index 0e09b9a55..b0c00b664 100644
--- a/examples/vertical/__init__.py
+++ b/examples/vertical/__init__.py
@@ -27,7 +27,7 @@ Example::
          filter(Animal.facts.any(
            and_(AnimalFact.key == u'weasel-like',
                 AnimalFact.value == True))))
-    print 'weasel-like animals', q.all()
+    print('weasel-like animals', q.all())
 
 .. autosource::
 
diff --git a/lib/sqlalchemy/dialects/firebird/base.py b/lib/sqlalchemy/dialects/firebird/base.py
index d0711f27c..51bda30a2 100644
--- a/lib/sqlalchemy/dialects/firebird/base.py
+++ b/lib/sqlalchemy/dialects/firebird/base.py
@@ -63,13 +63,13 @@ the SQLAlchemy ``returning()`` method, such as::
     # INSERT..RETURNING
     result = table.insert().returning(table.c.col1, table.c.col2).\
                    values(name='foo')
-    print result.fetchall()
+    print(result.fetchall())
 
     # UPDATE..RETURNING
     raises = empl.update().returning(empl.c.id, empl.c.salary).\
                   where(empl.c.sales>100).\
                   values(dict(salary=empl.c.salary * 1.1))
-    print raises.fetchall()
+    print(raises.fetchall())
 
 
 .. _dialects: http://mc-computing.com/Databases/Firebird/SQL_Dialect.html
diff --git a/lib/sqlalchemy/dialects/firebird/fdb.py b/lib/sqlalchemy/dialects/firebird/fdb.py
index 67d406003..46acd0559 100644
--- a/lib/sqlalchemy/dialects/firebird/fdb.py
+++ b/lib/sqlalchemy/dialects/firebird/fdb.py
@@ -42,7 +42,7 @@ accept every argument that Kinterbasdb does.
 
       conn = engine.connect().execution_options(enable_rowcount=True)
       r = conn.execute(stmt)
-      print r.rowcount
+      print(r.rowcount)
 
 * ``retaining`` - False by default.   Setting this to True will pass the
   ``retaining=True`` keyword argument to the ``.commit()`` and ``.rollback()``
diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py
index b30e77704..0a442f256 100644
--- a/lib/sqlalchemy/dialects/postgresql/base.py
+++ b/lib/sqlalchemy/dialects/postgresql/base.py
@@ -273,17 +273,17 @@ use the :meth:`._UpdateBase.returning` method on a per-statement basis::
     # INSERT..RETURNING
     result = table.insert().returning(table.c.col1, table.c.col2).\
         values(name='foo')
-    print result.fetchall()
+    print(result.fetchall())
 
     # UPDATE..RETURNING
     result = table.update().returning(table.c.col1, table.c.col2).\
         where(table.c.name=='foo').values(name='bar')
-    print result.fetchall()
+    print(result.fetchall())
 
     # DELETE..RETURNING
     result = table.delete().returning(table.c.col1, table.c.col2).\
         where(table.c.name=='foo')
-    print result.fetchall()
+    print(result.fetchall())
 
 .. _postgresql_insert_on_conflict:
 
@@ -567,7 +567,7 @@ syntaxes. It uses SQLAlchemy's hints mechanism::
 
     # SELECT ... FROM ONLY ...
     result = table.select().with_hint(table, 'ONLY', 'postgresql')
-    print result.fetchall()
+    print(result.fetchall())
 
     # UPDATE ONLY ...
     table.update(values=dict(foo='bar')).with_hint('ONLY',
diff --git a/lib/sqlalchemy/ext/compiler.py b/lib/sqlalchemy/ext/compiler.py
index 59c16f803..c27907cdc 100644
--- a/lib/sqlalchemy/ext/compiler.py
+++ b/lib/sqlalchemy/ext/compiler.py
@@ -32,7 +32,7 @@ when the object is compiled to a string::
     from sqlalchemy import select
 
     s = select([MyColumn('x'), MyColumn('y')])
-    print str(s)
+    print(str(s))
 
 Produces::
 
@@ -90,7 +90,7 @@ method which can be used for compilation of embedded attributes::
         )
 
     insert = InsertFromSelect(t1, select([t1]).where(t1.c.x>5))
-    print insert
+    print(insert)
 
 Produces::
 
diff --git a/lib/sqlalchemy/ext/hybrid.py b/lib/sqlalchemy/ext/hybrid.py
index fd06034ee..7c523edbd 100644
--- a/lib/sqlalchemy/ext/hybrid.py
+++ b/lib/sqlalchemy/ext/hybrid.py
@@ -66,10 +66,10 @@ descriptor evaluates the function body given the ``Interval`` class as
 the argument, which when evaluated with SQLAlchemy expression mechanics
 returns a new SQL expression::
 
-    >>> print Interval.length
+    >>> print(Interval.length)
     interval."end" - interval.start
 
-    >>> print Session().query(Interval).filter(Interval.length > 10)
+    >>> print(Session().query(Interval).filter(Interval.length > 10))
     SELECT interval.id AS interval_id, interval.start AS interval_start,
     interval."end" AS interval_end
     FROM interval
@@ -78,7 +78,7 @@ returns a new SQL expression::
 ORM methods such as :meth:`~.Query.filter_by` generally use ``getattr()`` to
 locate attributes, so can also be used with hybrid attributes::
 
-    >>> print Session().query(Interval).filter_by(length=5)
+    >>> print(Session().query(Interval).filter_by(length=5))
     SELECT interval.id AS interval_id, interval.start AS interval_start,
     interval."end" AS interval_end
     FROM interval
@@ -101,14 +101,14 @@ SQL expression-level boolean behavior::
     >>> i1.intersects(Interval(25, 29))
     False
 
-    >>> print Session().query(Interval).filter(Interval.contains(15))
+    >>> print(Session().query(Interval).filter(Interval.contains(15)))
     SELECT interval.id AS interval_id, interval.start AS interval_start,
     interval."end" AS interval_end
     FROM interval
     WHERE interval.start <= :start_1 AND interval."end" > :end_1
 
     >>> ia = aliased(Interval)
-    >>> print Session().query(Interval, ia).filter(Interval.intersects(ia))
+    >>> print(Session().query(Interval, ia).filter(Interval.intersects(ia)))
     SELECT interval.id AS interval_id, interval.start AS interval_start,
     interval."end" AS interval_end, interval_1.id AS interval_1_id,
     interval_1.start AS interval_1_start, interval_1."end" AS interval_1_end
@@ -153,7 +153,7 @@ object for class-level expressions::
     >>> i1.radius
     2
 
-    >>> print Session().query(Interval).filter(Interval.radius > 5)
+    >>> print(Session().query(Interval).filter(Interval.radius > 5))
     SELECT interval.id AS interval_id, interval.start AS interval_start,
         interval."end" AS interval_end
     FROM interval
@@ -325,8 +325,8 @@ However, at the expression level, it's expected that the ``User`` class will
 be used in an appropriate context such that an appropriate join to
 ``SavingsAccount`` will be present::
 
-    >>> print Session().query(User, User.balance).\
-    ...     join(User.accounts).filter(User.balance > 5000)
+    >>> print(Session().query(User, User.balance).
+    ...       join(User.accounts).filter(User.balance > 5000))
     SELECT "user".id AS user_id, "user".name AS user_name,
     account.balance AS account_balance
     FROM "user" JOIN account ON "user".id = account.user_id
@@ -390,7 +390,7 @@ we can adjust our ``SavingsAccount`` example to aggregate the balances for
 The above recipe will give us the ``balance`` column which renders
 a correlated SELECT::
 
-    >>> print s.query(User).filter(User.balance > 400)
+    >>> print(s.query(User).filter(User.balance > 400))
     SELECT "user".id AS user_id, "user".name AS user_name
     FROM "user"
     WHERE (SELECT sum(account.balance) AS sum_1
@@ -443,7 +443,7 @@ named ``word_insensitive``::
 Above, SQL expressions against ``word_insensitive`` will apply the ``LOWER()``
 SQL function to both sides::
 
-    >>> print Session().query(SearchWord).filter_by(word_insensitive="Trucks")
+    >>> print(Session().query(SearchWord).filter_by(word_insensitive="Trucks"))
     SELECT searchword.id AS searchword_id, searchword.word AS searchword_word
     FROM searchword
     WHERE lower(searchword.word) = lower(:lower_1)
@@ -579,7 +579,7 @@ The ``word_insensitive`` attribute now has case-insensitive comparison behavior
 universally, including SQL expression vs. Python expression (note the Python
 value is converted to lower case on the Python side here)::
 
-    >>> print Session().query(SearchWord).filter_by(word_insensitive="Trucks")
+    >>> print(Session().query(SearchWord).filter_by(word_insensitive="Trucks"))
     SELECT searchword.id AS searchword_id, searchword.word AS searchword_word
     FROM searchword
     WHERE lower(searchword.word) = :lower_1
@@ -588,12 +588,12 @@ SQL expression versus SQL expression::
 
     >>> sw1 = aliased(SearchWord)
     >>> sw2 = aliased(SearchWord)
-    >>> print Session().query(
+    >>> print(Session().query(
     ...                    sw1.word_insensitive,
     ...                    sw2.word_insensitive).\
     ...                        filter(
     ...                            sw1.word_insensitive > sw2.word_insensitive
-    ...                        )
+    ...                        ))
     SELECT lower(searchword_1.word) AS lower_1,
     lower(searchword_2.word) AS lower_2
     FROM searchword AS searchword_1, searchword AS searchword_2
@@ -606,7 +606,7 @@ Python only expression::
     True
     >>> ws1.word_insensitive == "XOmEwOrX"
     False
-    >>> print ws1.word_insensitive
+    >>> print(ws1.word_insensitive)
     someword
 
 The Hybrid Value pattern is very useful for any kind of value that may have
diff --git a/lib/sqlalchemy/orm/descriptor_props.py b/lib/sqlalchemy/orm/descriptor_props.py
index e957bee7a..bebf72a9d 100644
--- a/lib/sqlalchemy/orm/descriptor_props.py
+++ b/lib/sqlalchemy/orm/descriptor_props.py
@@ -764,7 +764,7 @@ class ComparableProperty(DescriptorProperty):
         A mapping like the above allows the ``word_insensitive`` attribute
         to render an expression like::
 
-            >>> print SearchWord.word_insensitive == "Trucks"
+            >>> print(SearchWord.word_insensitive == "Trucks")
             lower(search_word.word) = lower(:lower_1)
 
         :param comparator_factory:
diff --git a/lib/sqlalchemy/orm/events.py b/lib/sqlalchemy/orm/events.py
index 1a819777a..f0db1d86f 100644
--- a/lib/sqlalchemy/orm/events.py
+++ b/lib/sqlalchemy/orm/events.py
@@ -134,7 +134,7 @@ class InstanceEvents(event.Events):
         from sqlalchemy import event
 
         def my_load_listener(target, context):
-            print "on load!"
+            print("on load!")
 
         event.listen(SomeClass, 'load', my_load_listener)
 
@@ -1295,7 +1295,7 @@ class SessionEvents(event.Events):
         from sqlalchemy.orm import sessionmaker
 
         def my_before_commit(session):
-            print "before commit!"
+            print("before commit!")
 
         Session = sessionmaker()
 
diff --git a/lib/sqlalchemy/sql/elements.py b/lib/sqlalchemy/sql/elements.py
index a99c6ca35..df690c383 100644
--- a/lib/sqlalchemy/sql/elements.py
+++ b/lib/sqlalchemy/sql/elements.py
@@ -299,9 +299,9 @@ class ClauseElement(
         elements replaced with values taken from the given dictionary::
 
           >>> clause = column('x') + bindparam('foo')
-          >>> print clause.compile().params
+          >>> print(clause.compile().params)
           {'foo':None}
-          >>> print clause.params({'foo':7}).compile().params
+          >>> print(clause.params({'foo':7}).compile().params)
           {'foo':7}
 
         """
@@ -466,7 +466,7 @@ class ClauseElement(
 
                 s = select([t]).where(t.c.x == 5)
 
-                print s.compile(compile_kwargs={"literal_binds": True})
+                print(s.compile(compile_kwargs={"literal_binds": True}))
 
             .. versionadded:: 0.9.0
 
@@ -627,7 +627,7 @@ class ColumnElement(
         >>> from sqlalchemy.sql import column
         >>> column('a') + column('b')
         <sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
-        >>> print column('a') + column('b')
+        >>> print(column('a') + column('b'))
         a + b
 
     .. seealso::
@@ -1947,23 +1947,23 @@ class False_(roles.ConstExprRole, ColumnElement):
         E.g.::
 
             >>> from sqlalchemy import false
-            >>> print select([t.c.x]).where(false())
+            >>> print(select([t.c.x]).where(false()))
             SELECT x FROM t WHERE false
 
         A backend which does not support true/false constants will render as
         an expression against 1 or 0::
 
-            >>> print select([t.c.x]).where(false())
+            >>> print(select([t.c.x]).where(false()))
             SELECT x FROM t WHERE 0 = 1
 
         The :func:`.true` and :func:`.false` constants also feature
         "short circuit" operation within an :func:`.and_` or :func:`.or_`
         conjunction::
 
-            >>> print select([t.c.x]).where(or_(t.c.x > 5, true()))
+            >>> print(select([t.c.x]).where(or_(t.c.x > 5, true())))
             SELECT x FROM t WHERE true
 
-            >>> print select([t.c.x]).where(and_(t.c.x > 5, false()))
+            >>> print(select([t.c.x]).where(and_(t.c.x > 5, false())))
             SELECT x FROM t WHERE false
 
         .. versionchanged:: 0.9 :func:`.true` and :func:`.false` feature
@@ -2012,23 +2012,23 @@ class True_(roles.ConstExprRole, ColumnElement):
         E.g.::
 
             >>> from sqlalchemy import true
-            >>> print select([t.c.x]).where(true())
+            >>> print(select([t.c.x]).where(true()))
             SELECT x FROM t WHERE true
 
         A backend which does not support true/false constants will render as
         an expression against 1 or 0::
 
-            >>> print select([t.c.x]).where(true())
+            >>> print(select([t.c.x]).where(true()))
             SELECT x FROM t WHERE 1 = 1
 
         The :func:`.true` and :func:`.false` constants also feature
         "short circuit" operation within an :func:`.and_` or :func:`.or_`
         conjunction::
 
-            >>> print select([t.c.x]).where(or_(t.c.x > 5, true()))
+            >>> print(select([t.c.x]).where(or_(t.c.x > 5, true())))
             SELECT x FROM t WHERE true
 
-            >>> print select([t.c.x]).where(and_(t.c.x > 5, false()))
+            >>> print(select([t.c.x]).where(and_(t.c.x > 5, false())))
             SELECT x FROM t WHERE false
 
         .. versionchanged:: 0.9 :func:`.true` and :func:`.false` feature
@@ -3315,7 +3315,7 @@ class BinaryExpression(ColumnElement):
         >>> from sqlalchemy.sql import column
         >>> column('a') + column('b')
         <sqlalchemy.sql.expression.BinaryExpression object at 0x101029dd0>
-        >>> print column('a') + column('b')
+        >>> print(column('a') + column('b'))
         a + b
 
     """
diff --git a/lib/sqlalchemy/sql/functions.py b/lib/sqlalchemy/sql/functions.py
index 137b1605a..c1720b4c3 100644
--- a/lib/sqlalchemy/sql/functions.py
+++ b/lib/sqlalchemy/sql/functions.py
@@ -674,7 +674,7 @@ class GenericFunction(util.with_metaclass(_GenericMeta, Function)):
         class as_utc(GenericFunction):
             type = DateTime
 
-        print select([func.as_utc()])
+        print(select([func.as_utc()]))
 
     User-defined generic functions can be organized into
     packages by specifying the "package" attribute when defining
@@ -691,7 +691,7 @@ class GenericFunction(util.with_metaclass(_GenericMeta, Function)):
     The above function would be available from :data:`.func`
     using the package name ``time``::
 
-        print select([func.time.as_utc()])
+        print(select([func.time.as_utc()]))
 
     A final option is to allow the function to be accessed
     from one name in :data:`.func` but to render as a different name.
diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py
index b11e315ea..b8d88e160 100644
--- a/lib/sqlalchemy/sql/selectable.py
+++ b/lib/sqlalchemy/sql/selectable.py
@@ -3913,10 +3913,10 @@ class Select(
             >>> table1 = table('t1', column('a'), column('b'))
             >>> table2 = table('t2', column('a'), column('b'))
             >>> s1 = select([table1.c.a, table2.c.b])
-            >>> print s1
+            >>> print(s1)
             SELECT t1.a, t2.b FROM t1, t2
             >>> s2 = s1.with_only_columns([table2.c.b])
-            >>> print s2
+            >>> print(s2)
             SELECT t2.b FROM t1
 
         The preferred way to maintain a specific FROM clause
@@ -3928,7 +3928,7 @@ class Select(
             ...         select_from(table1.join(table2,
             ...                 table1.c.a==table2.c.a))
             >>> s2 = s1.with_only_columns([table2.c.b])
-            >>> print s2
+            >>> print(s2)
             SELECT t2.b FROM t1 JOIN t2 ON t1.a=t2.a
 
         Care should also be taken to use the correct
diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py
index 52b9fa1a9..22c80cc91 100644
--- a/lib/sqlalchemy/sql/sqltypes.py
+++ b/lib/sqlalchemy/sql/sqltypes.py
@@ -177,7 +177,7 @@ class String(Concatenable, TypeEngine):
           E.g.::
 
             >>> from sqlalchemy import cast, select, String
-            >>> print select([cast('some string', String(collation='utf8'))])
+            >>> print(select([cast('some string', String(collation='utf8'))]))
             SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
 
         :param convert_unicode: When set to ``True``, the