I had to fix a few markup issues in controlflow.rst and modules.rst.
There's a unicode issue on line 448 in introduction.rst that someone else needs to fix.
class or classes, and a method can call the method of a base class with the same
name. Objects can contain an arbitrary amount of private data.
-In C++ terminology, all class members (including the data members) are *public*,
+In C++ terminology, normally class members (including the data members) are
+*public* (except see below :ref:`tut-private`),
and all member functions are *virtual*. There are no special constructors or
destructors. As in Modula-3, there are no shorthands for referencing the
object's members from its methods: the method function is declared with an
x.counter = 1
while x.counter < 10:
x.counter = x.counter * 2
- print x.counter
+ print(x.counter)
del x.counter
The other kind of instance attribute reference is a *method*. A method is a
xf = x.f
while True:
- print xf()
+ print(xf())
will continue to print ``hello world`` until the end of time.
try:
raise c()
except D:
- print "D"
+ print("D")
except C:
- print "C"
+ print("C")
except B:
- print "B"
+ print("B")
Note that if the except clauses were reversed (with ``except B`` first), it
would have printed B, B, B --- the first matching except clause is triggered.
using a :keyword:`for` statement::
for element in [1, 2, 3]:
- print element
+ print(element)
for element in (1, 2, 3):
- print element
+ print(element)
for key in {'one':1, 'two':2}:
- print key
+ print(key)
for char in "123":
- print char
+ print(char)
for line in open("myfile.txt"):
- print line
+ print(line)
This style of access is clear, concise, and convenient. The use of iterators
pervades and unifies Python. Behind the scenes, the :keyword:`for` statement
return self.data[self.index]
>>> for char in Reverse('spam'):
- ... print char
+ ... print(char)
...
m
a
yield data[index]
>>> for char in reverse('golf'):
- ... print char
+ ... print(char)
...
f
l
>>> x = int(input("Please enter an integer: "))
>>> if x < 0:
... x = 0
- ... print 'Negative changed to zero'
+ ... print('Negative changed to zero')
... elif x == 0:
- ... print 'Zero'
+ ... print('Zero')
... elif x == 1:
- ... print 'Single'
+ ... print('Single')
... else:
- ... print 'More'
+ ... print('More')
...
There can be zero or more :keyword:`elif` parts, and the :keyword:`else` part is
.. index::
statement: for
- statement: for
The :keyword:`for` statement in Python differs a bit from what you may be used
to in C or Pascal. Rather than always iterating over an arithmetic progression
>>> # Measure some strings:
... a = ['cat', 'window', 'defenestrate']
>>> for x in a:
- ... print x, len(x)
+ ... print(x, len(x))
...
cat 3
window 6
==========================
If you do need to iterate over a sequence of numbers, the built-in function
-:func:`range` comes in handy. It generates lists containing arithmetic
-progressions::
+:func:`range` comes in handy. It generates arithmetic progressions::
+
+
+ >>> for i in range(5):
+ ... print(i)
+ ...
+ 0
+ 1
+ 2
+ 3
+ 4
+
- >>> range(10)
- [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
The given end point is never part of the generated list; ``range(10)`` generates
-a list of 10 values, the legal indices for items of a sequence of length 10. It
+10 values, the legal indices for items of a sequence of length 10. It
is possible to let the range start at another number, or to specify a different
increment (even negative; sometimes this is called the 'step')::
- >>> range(5, 10)
- [5, 6, 7, 8, 9]
- >>> range(0, 10, 3)
- [0, 3, 6, 9]
- >>> range(-10, -100, -30)
- [-10, -40, -70]
+ range(5, 10)
+ 5 through 9
+
+ range(0, 10, 3)
+ 0, 3, 6, 9
+
+ range(-10, -100, -30)
+ -10, -40, -70
To iterate over the indices of a sequence, combine :func:`range` and :func:`len`
as follows::
>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
- ... print i, a[i]
+ ... print(i, a[i])
...
0 Mary
1 had
3 little
4 lamb
+A strange thing happens if you just print a range::
+
+ >>> print(range(10))
+ range(0, 10)
+
+In many ways the object returned by :func:`range` behaves as if it is a list,
+but in fact it isn't. It is an object which returns the successive items of
+the desired sequence when you iterate over it, but it doesn't really make
+the list, thus saving space.
+
+We say such an object is *iterable*, that is, suitable as a target for
+functions and constructs that expect something from which they can
+obtain successive items until the supply is exhausted. We have seen that
+the :keyword:`for` statement is such an *iterator*. The function :func:`list`
+is another; it creates lists from iterables::
+
+
+ >>> list(range(5))
+ [0, 1, 2, 3, 4]
+
+Later we will see more functions that return iterables and take iterables as argument.
.. _tut-break:
>>> for n in range(2, 10):
... for x in range(2, n):
... if n % x == 0:
- ... print n, 'equals', x, '*', n/x
+ ... print(n, 'equals', x, '*', n/x)
... break
... else:
... # loop fell through without finding a factor
- ... print n, 'is a prime number'
+ ... print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
... """Print a Fibonacci series up to n."""
... a, b = 0, 1
... while b < n:
- ... print b,
+ ... print(b,end=' ')
... a, b = b, a+b
+ ... print()
...
>>> # Now call the function we just defined:
... fib(2000)
``None`` is normally suppressed by the interpreter if it would be the only value
written. You can see it if you really want to::
- >>> print fib(0)
+ >>> print(fib(0))
None
It is simple to write a function that returns a list of the numbers of the
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
- print complaint
+ print(complaint)
This function can be called either like this: ``ask_ok('Do you really want to
quit?')`` or like this: ``ask_ok('OK to overwrite the file?', 2)``.
i = 5
def f(arg=i):
- print arg
+ print(arg)
i = 6
f()
L.append(a)
return L
- print f(1)
- print f(2)
- print f(3)
+ print(f(1))
+ print(f(2))
+ print(f(3))
This will print ::
value``. For instance, the following function::
def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
- print "-- This parrot wouldn't", action,
- print "if you put", voltage, "volts through it."
- print "-- Lovely plumage, the", type
- print "-- It's", state, "!"
+ print("-- This parrot wouldn't", action, end= ' ')
+ print("if you put", voltage, "volts through it.")
+ print("-- Lovely plumage, the", type)
+ print("-- It's", state, "!")
could be called in any of the following ways::
function like this::
def cheeseshop(kind, *arguments, **keywords):
- print "-- Do you have any", kind, '?'
- print "-- I'm sorry, we're all out of", kind
+ print("-- Do you have any", kind, '?')
+ print("-- I'm sorry, we're all out of", kind)
for arg in arguments: print arg
- print '-'*40
+ print('-'*40)
keys = keywords.keys()
keys.sort()
- for kw in keys: print kw, ':', keywords[kw]
+ for kw in keys: print(kw, ':', keywords[kw])
It could be called like this::
def fprintf(file, format, *args):
file.write(format % args)
+
+Normally, these ``variadic`` arguments will be last in the list of formal
+parameters, because they scoop up all remaining input arguments that are
+passed to the function. Any formal parameters which occur after the ``*args``
+parameter are 'keyword-only' arguments, meaning that they can only be used as
+keywords rather than positional arguments.::
+
+ >>> def concat(*args, sep="/"):
+ ... return sep.join(args)
+ ...
+ >>> concat("earth", "mars", "venus")
+ 'earth/mars/venus'
+ >>> concat("earth", "mars", "venus", sep=".")
+ 'earth.mars.venus'
.. _tut-unpacking-arguments:
function call with the ``*``\ -operator to unpack the arguments out of a list
or tuple::
- >>> range(3, 6) # normal call with separate arguments
+ >>> list(range(3, 6)) # normal call with separate arguments
[3, 4, 5]
>>> args = [3, 6]
- >>> range(*args) # call with arguments unpacked from a list
+ >>> list(range(*args)) # call with arguments unpacked from a list
[3, 4, 5]
In the same fashion, dictionaries can deliver keyword arguments with the ``**``\
-operator::
>>> def parrot(voltage, state='a stiff', action='voom'):
- ... print "-- This parrot wouldn't", action,
- ... print "if you put", voltage, "volts through it.",
- ... print "E's", state, "!"
+ ... print("-- This parrot wouldn't", action,end=' ')
+ ... print("if you put", voltage, "volts through it.", end=' ')
+ ... print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
single: documentation strings
single: strings, documentation
-There are emerging conventions about the content and formatting of documentation
-strings.
+Here are some conventions about the content and formatting of documentation
+strings.
The first line should always be a short, concise summary of the object's
purpose. For brevity, it should not explicitly state the object's name or type,
... """
... pass
...
- >>> print my_function.__doc__
+ >>> print(my_function.__doc__)
Do nothing, but document it.
No, really, it doesn't do anything.
This chapter describes some things you've learned about already in more detail,
and adds some new things as well.
+.. _tut-tuples:
+
+Tuples and Sequences
+====================
+
+We saw that lists and strings have many common properties, such as indexing and
+slicing operations. They are two examples of *sequence* data types (see
+:ref:`typesseq`). Since Python is an evolving language, other sequence data
+types may be added. There is also another standard sequence data type: the
+*tuple*.
+
+A tuple consists of a number of values separated by commas, for instance::
+
+ >>> t = 12345, 54321, 'hello!'
+ >>> t[0]
+ 12345
+ >>> t
+ (12345, 54321, 'hello!')
+ >>> # Tuples may be nested:
+ ... u = t, (1, 2, 3, 4, 5)
+ >>> u
+ ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
+
+As you see, on output tuples are always enclosed in parentheses, so that nested
+tuples are interpreted correctly; they may be input with or without surrounding
+parentheses, although often parentheses are necessary anyway (if the tuple is
+part of a larger expression).
+
+Tuples have many uses. For example: (x, y) coordinate pairs, employee records
+from a database, etc. Tuples, like strings, are immutable: it is not possible
+to assign to the individual items of a tuple (you can simulate much of the same
+effect with slicing and concatenation, though). It is also possible to create
+tuples which contain mutable objects, such as lists.
+
+A special problem is the construction of tuples containing 0 or 1 items: the
+syntax has some extra quirks to accommodate these. Empty tuples are constructed
+by an empty pair of parentheses; a tuple with one item is constructed by
+following a value with a comma (it is not sufficient to enclose a single value
+in parentheses). Ugly, but effective. For example::
+
+ >>> empty = ()
+ >>> singleton = 'hello', # <-- note trailing comma
+ >>> len(empty)
+ 0
+ >>> len(singleton)
+ 1
+ >>> singleton
+ ('hello',)
+
+The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple packing*:
+the values ``12345``, ``54321`` and ``'hello!'`` are packed together in a tuple.
+The reverse operation is also possible::
+
+ >>> x, y, z = t
+
+This is called, appropriately enough, *sequence unpacking*. Sequence unpacking
+requires the list of variables on the left to have the same number of elements
+as the length of the sequence. Note that multiple assignment is really just a
+combination of tuple packing and sequence unpacking!
+
+There is a small bit of asymmetry here: packing multiple values always creates
+a tuple, and unpacking works for any sequence.
+
+.. % XXX Add a bit on the difference between tuples and lists.
+
.. _tut-morelists:
An example that uses most of the list methods::
>>> a = [66.25, 333, 333, 1, 1234.5]
- >>> print a.count(333), a.count(66.25), a.count('x')
+ >>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
['Michael', 'Terry', 'Graham']
-.. _tut-functional:
-
-Functional Programming Tools
-----------------------------
-
-There are two built-in functions that are very useful when used with lists:
-:func:`filter` and :func:`map`.
+List Comprehensions
+-------------------
-``filter(function, sequence)`` returns a sequence consisting of those items from
-the sequence for which ``function(item)`` is true. If *sequence* is a
-:class:`string` or :class:`tuple`, the result will be of the same type;
-otherwise, it is always a :class:`list`. For example, to compute some primes::
+List comprehensions provide a concise way to create lists from sequences.
+Common applications are to make lists where each element is the result of
+some operations applied to each member of the sequence, or to create a
+subsequence of those elements that satisfy a certain condition.
- >>> def f(x): return x % 2 != 0 and x % 3 != 0
- ...
- >>> filter(f, range(2, 25))
- [5, 7, 11, 13, 17, 19, 23]
-``map(function, sequence)`` calls ``function(item)`` for each of the sequence's
-items and returns a list of the return values. For example, to compute some
-cubes::
-
- >>> def cube(x): return x*x*x
- ...
- >>> map(cube, range(1, 11))
- [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
+Each list comprehension consists of an expression followed by a :keyword:`for`
+clause, then zero or more :keyword:`for` or :keyword:`if` clauses. The result
+will be a list resulting from evaluating the expression in the context of the
+:keyword:`for` and :keyword:`if` clauses which follow it. If the expression
+would evaluate to a tuple, it must be parenthesized.
-More than one sequence may be passed; the function must then have as many
-arguments as there are sequences and is called with the corresponding item from
-each sequence (or ``None`` if some sequence is shorter than another). For
-example::
+Here we take a list of numbers and return a list of three times each number::
- >>> seq = range(8)
- >>> def add(x, y): return x+y
- ...
- >>> map(add, seq, seq)
- [0, 2, 4, 6, 8, 10, 12, 14]
+ >>> vec = [2, 4, 6]
+ >>> [3*x for x in vec]
+ [6, 12, 18]
-.. versionadded:: 2.3
+Now we get a little fancier::
+ >>> [[x,x**2] for x in vec]
+ [[2, 4], [4, 16], [6, 36]]
-List Comprehensions
--------------------
-
-List comprehensions provide a concise way to create lists without resorting to
-use of :func:`map`, :func:`filter` and/or :keyword:`lambda`. The resulting list
-definition tends often to be clearer than lists built using those constructs.
-Each list comprehension consists of an expression followed by a :keyword:`for`
-clause, then zero or more :keyword:`for` or :keyword:`if` clauses. The result
-will be a list resulting from evaluating the expression in the context of the
-:keyword:`for` and :keyword:`if` clauses which follow it. If the expression
-would evaluate to a tuple, it must be parenthesized. ::
+Here we apply a method call to each item in a sequence::
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
- >>> vec = [2, 4, 6]
- >>> [3*x for x in vec]
- [6, 12, 18]
+
+Using the if-clause we can filter the stream::
+
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
- >>> [[x,x**2] for x in vec]
- [[2, 4], [4, 16], [6, 36]]
+
+Tuples can often be created without their parentheses, but not here::
+
>>> [x, x**2 for x in vec] # error - parens required for tuples
File "<stdin>", line 1, in ?
[x, x**2 for x in vec]
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
+
+Here are some nested for's and other fancy behavior::
+
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
-List comprehensions are much more flexible than :func:`map` and can be applied
-to complex expressions and nested functions::
+List comprehensions can be applied to complex expressions and nested functions::
>>> [str(round(355/113.0, i)) for i in range(1,6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
is assigned to it). We'll find other uses for :keyword:`del` later.
-.. _tut-tuples:
-
-Tuples and Sequences
-====================
-
-We saw that lists and strings have many common properties, such as indexing and
-slicing operations. They are two examples of *sequence* data types (see
-:ref:`typesseq`). Since Python is an evolving language, other sequence data
-types may be added. There is also another standard sequence data type: the
-*tuple*.
-
-A tuple consists of a number of values separated by commas, for instance::
-
- >>> t = 12345, 54321, 'hello!'
- >>> t[0]
- 12345
- >>> t
- (12345, 54321, 'hello!')
- >>> # Tuples may be nested:
- ... u = t, (1, 2, 3, 4, 5)
- >>> u
- ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
-
-As you see, on output tuples are always enclosed in parentheses, so that nested
-tuples are interpreted correctly; they may be input with or without surrounding
-parentheses, although often parentheses are necessary anyway (if the tuple is
-part of a larger expression).
-
-Tuples have many uses. For example: (x, y) coordinate pairs, employee records
-from a database, etc. Tuples, like strings, are immutable: it is not possible
-to assign to the individual items of a tuple (you can simulate much of the same
-effect with slicing and concatenation, though). It is also possible to create
-tuples which contain mutable objects, such as lists.
-
-A special problem is the construction of tuples containing 0 or 1 items: the
-syntax has some extra quirks to accommodate these. Empty tuples are constructed
-by an empty pair of parentheses; a tuple with one item is constructed by
-following a value with a comma (it is not sufficient to enclose a single value
-in parentheses). Ugly, but effective. For example::
-
- >>> empty = ()
- >>> singleton = 'hello', # <-- note trailing comma
- >>> len(empty)
- 0
- >>> len(singleton)
- 1
- >>> singleton
- ('hello',)
-
-The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple packing*:
-the values ``12345``, ``54321`` and ``'hello!'`` are packed together in a tuple.
-The reverse operation is also possible::
-
- >>> x, y, z = t
-
-This is called, appropriately enough, *sequence unpacking*. Sequence unpacking
-requires the list of variables on the left to have the same number of elements
-as the length of the sequence. Note that multiple assignment is really just a
-combination of tuple packing and sequence unpacking!
-
-There is a small bit of asymmetry here: packing multiple values always creates
-a tuple, and unpacking works for any sequence.
-
-.. % XXX Add a bit on the difference between tuples and lists.
-
.. _tut-sets:
eliminating duplicate entries. Set objects also support mathematical operations
like union, intersection, difference, and symmetric difference.
+Curly braces or the :func:`set` function can be use to create sets. Note:
+To create an empty set you have to use set(), not {}; the latter creates
+an empty dictionary, a data structure that we discuss in the next section.
+
Here is a brief demonstration::
- >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
+ >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
+ >>> print(basket)
+ {'orange', 'bananna', 'pear', 'apple'}
+ >>> fruit = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket) # create a set without duplicates
>>> fruit
- set(['orange', 'pear', 'apple', 'banana'])
+ {'orange', 'pear', 'apple', 'banana'}
>>> 'orange' in fruit # fast membership testing
True
>>> 'crabgrass' in fruit
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
- set(['a', 'r', 'b', 'c', 'd'])
+ {'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
- set(['r', 'd', 'b'])
+ {'r', 'd', 'b'}
>>> a | b # letters in either a or b
- set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
+ {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
- set(['a', 'c'])
+ {'a', 'c'}
>>> a ^ b # letters in a or b but not both
- set(['r', 'd', 'b', 'm', 'z', 'l'])
+ {'r', 'd', 'b', 'm', 'z', 'l'}
+
+
.. _tut-dictionaries:
.. _tut-loopidioms:
+.. %
+ Find out the right way to do these DUBOIS
Looping Techniques
==================
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.iteritems():
- ... print k, v
+ ... print(k, v)
...
gallahad the pure
robin the brave
be retrieved at the same time using the :func:`enumerate` function. ::
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
- ... print i, v
+ ... print(i, v)
...
0 tic
1 tac
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
- ... print 'What is your %s? It is %s.' % (q, a)
+ ... print('What is your %s? It is %s.' % (q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
direction and then call the :func:`reversed` function. ::
>>> for i in reversed(range(1,10,2)):
- ... print i
+ ... print(i)
...
9
7
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
- ... print f
+ ... print(f)
...
apple
banana
-.. _tut-errors:
+. _tut-errors:
*********************
Errors and Exceptions
Syntax errors, also known as parsing errors, are perhaps the most common kind of
complaint you get while you are still learning Python::
- >>> while True print 'Hello world'
+ >>> while True print('Hello world')
File "<stdin>", line 1, in ?
- while True print 'Hello world'
+ while True print('Hello world')
^
SyntaxError: invalid syntax
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
- ZeroDivisionError: integer division or modulo by zero
+ ZeroDivisionError: int division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
- TypeError: cannot concatenate 'str' and 'int' objects
+ TypeError: coercing to Unicode: need string or buffer, int found
The last line of the error message indicates what happened. Exceptions come in
different types, and the type is printed as part of the message: the types in
... x = int(input("Please enter a number: "))
... break
... except ValueError:
- ... print "Oops! That was no valid number. Try again..."
+ ... print("Oops! That was no valid number. Try again...")
...
The :keyword:`try` statement works as follows.
s = f.readline()
i = int(s.strip())
except IOError as e:
- (errno, strerror) = e
- print "I/O error(%s): %s" % (e.errno, e.strerror)
+ print("I/O error(%s): %s" % (e.errno, e.strerror))
except ValueError:
- print "Could not convert data to an integer."
+ print("Could not convert data to an integer.")
except:
- print "Unexpected error:", sys.exc_info()[0]
+ print("Unexpected error:", sys.exc_info()[0])
raise
The :keyword:`try` ... :keyword:`except` statement has an optional *else
try:
f = open(arg, 'r')
except IOError:
- print 'cannot open', arg
+ print('cannot open', arg)
else:
- print arg, 'has', len(f.readlines()), 'lines'
+ print(arg, 'has', len(f.readlines()), 'lines')
f.close()
The use of the :keyword:`else` clause is better than adding additional code to
>>> try:
... raise Exception('spam', 'eggs')
... except Exception as inst:
- ... print type(inst) # the exception instance
- ... print inst.args # arguments stored in .args
- ... print inst # __str__ allows args to printed directly
+ ... print(type(inst)) # the exception instance
+ ... print(inst.args) # arguments stored in .args
+ ... print(inst) # __str__ allows args to be printed directly
... x, y = inst # __getitem__ allows args to be unpacked directly
... print 'x =', x
... print 'y =', y
>>> try:
... this_fails()
... except ZeroDivisionError as detail:
- ... print 'Handling run-time error:', detail
+ ... print('Handling run-time error:', detail)
...
Handling run-time error: integer division or modulo by zero
>>> try:
... raise NameError, 'HiThere'
... except NameError:
- ... print 'An exception flew by!'
+ ... print('An exception flew by!')
... raise
...
An exception flew by!
>>> try:
... raise KeyboardInterrupt
... finally:
- ... print 'Goodbye, world!'
+ ... print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
... try:
... result = x / y
... except ZeroDivisionError:
- ... print "division by zero!"
+ ... print("division by zero!")
... else:
- ... print "result is", result
+ ... print("result is", result)
... finally:
- ... print "executing finally clause"
+ ... print("executing finally clause")
...
>>> divide(2, 1)
result is 2
and print its contents to the screen. ::
for line in open("myfile.txt"):
- print line
+ print(line)
The problem with this code is that it leaves the file open for an indeterminate
-amount of time after the code has finished executing. This is not an issue in
-simple scripts, but can be a problem for larger applications. The
-:keyword:`with` statement allows objects like files to be used in a way that
-ensures they are always cleaned up promptly and correctly. ::
+amount of time after this part of the code has finished executing.
+This is not an issue in simple scripts, but can be a problem for larger
+applications. The :keyword:`with` statement allows objects like files to be
+used in a way that ensures they are always cleaned up promptly and correctly. ::
with open("myfile.txt") as f:
for line in f:
- print line
+ print(line)
After the statement is executed, the file *f* is always closed, even if a
-problem was encountered while processing the lines. Other objects which provide
-predefined clean-up actions will indicate this in their documentation.
+problem was encountered while processing the lines. Objects which, like files,
+provide predefined clean-up actions will indicate this in their documentation.
Python's ``%`` format operator: the ``%g``, ``%f`` and ``%e`` format codes
supply flexible and easy ways to round float results for display.
-
+If you are a heavy user of floating point operations you should take a look
+at the Numerical Python package and many other packages for mathematical and
+statistical operations supplied by the SciPy project. See <http://scipy.org>.
+
.. _tut-fp-error:
Representation Error
=========================
So far we've encountered two ways of writing values: *expression statements* and
-the :keyword:`print` statement. (A third way is using the :meth:`write` method
+the :func:`print` function. (A third way is using the :meth:`write` method
of file objects; the standard output file can be referenced as ``sys.stdout``.
See the Library Reference for more information on this.)
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
- >>> print s
+ >>> print(s)
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
- >>> print hellos
+ >>> print(hellos)
'hello, world\n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
Here are two ways to write a table of squares and cubes::
>>> for x in range(1, 11):
- ... print repr(x).rjust(2), repr(x*x).rjust(3),
- ... # Note trailing comma on previous line
- ... print repr(x*x*x).rjust(4)
+ ... print(repr(x).rjust(2), repr(x*x).rjust(3),end=' ')
+ ... # Note use of 'end' on previous line
+ ... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
10 100 1000
>>> for x in range(1,11):
- ... print '%2d %3d %4d' % (x, x*x, x*x*x)
+ ... print('%2d %3d %4d' % (x, x*x, x*x*x))
...
1 1 1
2 4 8
10 100 1000
(Note that in the first example, one space between each column was added by the
-way :keyword:`print` works: it always adds spaces between its arguments.)
+way :func:`print` works: it always adds spaces between its arguments.)
This example demonstrates the :meth:`rjust` method of string objects, which
right-justifies a string in a field of a given width by padding it with spaces
This is particularly useful in combination with the new built-in :func:`vars`
function, which returns a dictionary containing all local variables.
+The :mod:`string` module contains a class Template which offers yet another way
+to substitute values into strings.
.. _tut-files:
::
>>> f=open('/tmp/workfile', 'w')
- >>> print f
+ >>> print(f)
<open file '/tmp/workfile', mode 'w' at 80a0960>
The first argument is a string containing the filename. The second argument is
memory efficient, fast, and leads to simpler code::
>>> for line in f:
- print line,
+ print(line, end='')
This is the first line of the file.
Second line of the file
symbol table. A command to check (or even suggest) matching parentheses,
quotes, etc., would also be useful.
+.. %
+ Do we mention IPython? DUBOIS
.. rubric:: Footnotes
>>> 2+2 # and a comment on the same line as code
4
>>> (50-5*6)/4
- 5
+ 5.0
+ >>> 8/5 # Fractions aren't lost when dividing integers
+ 1.6000000000000001
+
+Note: You might not see exactly the same result; floating point results can
+differ from one machine to another. We will say more later about controlling
+the appearance of floating point output; what we see here is the most
+informative display but not as easy to read as we would get with::
+
+ >>> print(8/5)
+ 1.6
+
+For clarity in this tutorial we will show the simpler floating point output
+unless we are specifically discussing output formatting, and explain later
+why these two ways of displaying floating point data come to be different.
+See :ref:`tut-fp-issues` for a full discussion.
+
+To do integer division and get an integer result,
+discarding any fractional result, there is another operator, ``//``::
+
>>> # Integer division returns the floor:
- ... 7/3
+ ... 7//3
2
- >>> 7/-3
+ >>> 7//-3
-3
The equal sign (``'='``) is used to assign a value to a variable. Afterwards, no
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
+The interpreter prints the result of string operations in the same way as they
+are typed for input: inside quotes, and with quotes and other funny characters
+escaped by backslashes, to show the precise value. The string is enclosed in
+double quotes if the string contains a single quote and no double quotes, else
+it's enclosed in single quotes. Once again, the :func:`print` function
+produces the more readable output.
+
String literals can span multiple lines in several ways. Continuation lines can
be used, with a backslash as the last character on the line indicating that the
next line is a logical continuation of the line::
Note that whitespace at the beginning of the line is\
significant."
- print hello
+ print(hello)
Note that newlines still need to be embedded in the string using ``\n``; the
newline following the trailing backslash is discarded. This example would print
hello = r"This is a rather long string containing\n\
several lines of text much as you would do in C."
- print hello
+ print(hello)
would print::
``'''``. End of lines do not need to be escaped when using triple-quotes, but
they will be included in the string. ::
- print """
+ print("""
Usage: thingy [OPTIONS]
-h Display this usage message
-H hostname Hostname to connect to
- """
+ """)
produces the following output::
-h Display this usage message
-H hostname Hostname to connect to
-The interpreter prints the result of string operations in the same way as they
-are typed for input: inside quotes, and with quotes and other funny characters
-escaped by backslashes, to show the precise value. The string is enclosed in
-double quotes if the string contains a single quote and no double quotes, else
-it's enclosed in single quotes. (The :keyword:`print` statement, described
-later, can be used to write strings without quotes or escapes.)
Strings can be concatenated (glued together) with the ``+`` operator, and
repeated with ``*``::
Strings can be subscripted (indexed); like in C, the first character of a string
has subscript (index) 0. There is no separate character type; a character is
-simply a string of size one. Like in Icon, substrings can be specified with the
+simply a string of size one. As in Icon, substrings can be specified with the
*slice notation*: two indices separated by a colon. ::
>>> word[4]
>>> word[0] = 'x'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
- TypeError: object doesn't support item assignment
+ TypeError: 'str' object doesn't support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
- TypeError: object doesn't support slice assignment
+ TypeError: 'str' object doesn't support slice assignment
However, creating a new string with the combined content is easy and efficient::
.. seealso::
:ref:`typesseq`
- Strings, and the Unicode strings described in the next section, are
- examples of *sequence types*, and support the common operations supported
- by such types.
+ Strings are examples of *sequence types*, and support the common
+ operations supported by such types.
:ref:`string-methods`
- Both strings and Unicode strings support a large number of methods for
+ Strings support a large number of methods for
basic transformations and searching.
:ref:`string-formatting`
- The formatting operations invoked when strings and Unicode strings are the
+ The formatting operations invoked when strings are the
left operand of the ``%`` operator are described in more detail here.
.. _tut-unicodestrings:
-Unicode Strings
----------------
+About Unicode
+-------------
.. sectionauthor:: Marc-Andre Lemburg <mal@lemburg.com>
-Starting with Python 2.0 a new data type for storing text data is available to
-the programmer: the Unicode object. It can be used to store and manipulate
-Unicode data (see http://www.unicode.org/) and integrates well with the existing
-string objects, providing auto-conversions where necessary.
+Starting with Python 3.0 all strings support Unicode.
+(See http://www.unicode.org/)
Unicode has the advantage of providing one ordinal for every character in every
script used in modern and ancient texts. Previously, there were only 256
``i18n`` --- ``'i'`` + 18 characters + ``'n'``) of software. Unicode solves
these problems by defining one code page for all scripts.
-Creating Unicode strings in Python is just as simple as creating normal
-strings::
-
- >>> u'Hello World !'
- u'Hello World !'
-
-The small ``'u'`` in front of the quote indicates that a Unicode string is
-supposed to be created. If you want to include special characters in the string,
+If you want to include special characters in a string,
you can do so by using the Python *Unicode-Escape* encoding. The following
example shows how::
- >>> u'Hello\u0020World !'
- u'Hello World !'
+ >>> 'Hello\u0020World !'
+ 'Hello World !'
The escape sequence ``\u0020`` indicates to insert the Unicode character with
the ordinal value 0x0020 (the space character) at the given position.
convenient that the lower 256 characters of Unicode are the same as the 256
characters of Latin-1.
-For experts, there is also a raw mode just like the one for normal strings. You
-have to prefix the opening quote with 'ur' to have Python use the
-*Raw-Unicode-Escape* encoding. It will only apply the above ``\uXXXX``
-conversion if there is an uneven number of backslashes in front of the small
-'u'. ::
-
- >>> ur'Hello\u0020World !'
- u'Hello World !'
- >>> ur'Hello\\u0020World !'
- u'Hello\\\\u0020World !'
-
-The raw mode is most useful when you have to enter lots of backslashes, as can
-be necessary in regular expressions.
-
Apart from these standard encodings, Python provides a whole set of other ways
of creating Unicode strings on the basis of a known encoding.
-.. index:: builtin: unicode
-
-The built-in function :func:`unicode` provides access to all registered Unicode
-codecs (COders and DECoders). Some of the more well known encodings which these
-codecs can convert are *Latin-1*, *ASCII*, *UTF-8*, and *UTF-16*. The latter two
-are variable-length encodings that store each Unicode character in one or more
-bytes. The default encoding is normally set to ASCII, which passes through
-characters in the range 0 to 127 and rejects any other characters with an error.
-When a Unicode string is printed, written to a file, or converted with
-:func:`str`, conversion takes place using this default encoding. ::
-
- >>> u"abc"
- u'abc'
- >>> str(u"abc")
- 'abc'
- >>> u"äöü"
- u'\xe4\xf6\xfc'
- >>> str(u"äöü")
- Traceback (most recent call last):
- File "<stdin>", line 1, in ?
- UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)
-
-To convert a Unicode string into an 8-bit string using a specific encoding,
-Unicode objects provide an :func:`encode` method that takes one argument, the
+To convert a string into a sequence of bytes using a specific encoding,
+string objects provide an :func:`encode` method that takes one argument, the
name of the encoding. Lowercase names for encodings are preferred. ::
- >>> u"äöü".encode('utf-8')
- '\xc3\xa4\xc3\xb6\xc3\xbc'
-
-If you have data in a specific encoding and want to produce a corresponding
-Unicode string from it, you can use the :func:`unicode` function with the
-encoding name as the second argument. ::
-
- >>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
- u'\xe4\xf6\xfc'
+ >>> "Ã\83¤Ã\83\u0020Ã\83".encode('utf-8')
+ b'A*A A'
+.. % above example needs beefing up by a unicode dude
.. _tut-lists:
[2, 3]
>>> p[1][0]
2
- >>> p[1].append('xtra') # See section 5.1
+
+You can add something to the end of the list::
+
+ >>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
- ... print b
+ ... print(b)
... a, b = b, a+b
...
1
completion (since the parser cannot guess when you have typed the last line).
Note that each line within a basic block must be indented by the same amount.
-* The :keyword:`print` statement writes the value of the expression(s) it is
+* The :func:`print` function writes the value of the expression(s) it is
given. It differs from just writing the expression you want to write (as we did
- earlier in the calculator examples) in the way it handles multiple expressions
+ earlier in the calculator examples) in the way it handles multiple
+ expressions, floating point quantities,
and strings. Strings are printed without quotes, and a space is inserted
between items, so you can format things nicely, like this::
>>> i = 256*256
- >>> print 'The value of i is', i
+ >>> print('The value of i is', i)
The value of i is 65536
- A trailing comma avoids the newline after the output::
+ The keyword end can be used to avoid the newline after the output::
>>> a, b = 0, 1
>>> while b < 1000:
- ... print b,
+ ... print(b, ' ', end='')
... a, b = b, a+b
...
+ >>> print()
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
- Note that the interpreter inserts a newline before it prints the next prompt if
- the last line was not completed.
+ Note that nothing appeared after the loop ended, until we printed
+ a newline.
+
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
- print b,
+ print(b, end=' ')
a, b = b, a+b
def fib2(n): # return Fibonacci series up to n
1 1 2 3 5 8 13 21 34 55 89 144 233 377
This imports all names except those beginning with an underscore (``_``).
+In most cases Python programmers do not use this facility since it introduces
+an unknown set of names into the interpreter, possibly hiding some things
+you have already defined.
.. _tut-modulesasscripts:
a module when that module is imported. This will generally be an error. See
section :ref:`tut-standardmodules` for more information.
+.. %
+ Do we need stuff on zip files etc. ? DUBOIS
"Compiled" Python files
-----------------------
* The module :mod:`compileall` can create :file:`.pyc` files (or :file:`.pyo`
files when :option:`-O` is used) for all modules in a directory.
- .. %
+* If using Python in a parallel processing system with a shared file system,
+ you need to patch python to disable the creation of the compiled files
+ because otherwise the multiple Python interpreters will encounter race
+ conditions in creating them.
.. _tut-standardmodules:
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
- C> print 'Yuck!'
+ C> print('Yuck!')
Yuck!
C>
>>> import __builtin__
>>> dir(__builtin__)
- ['ArithmeticError', 'AssertionError', 'AttributeError', 'DeprecationWarning',
- 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',
- 'FloatingPointError', 'FutureWarning', 'IOError', 'ImportError',
- 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
- 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented',
- 'NotImplementedError', 'OSError', 'OverflowError',
- 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError',
- 'RuntimeWarning', 'StopIteration', 'SyntaxError',
- 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
- 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError',
- 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError',
- 'UserWarning', 'ValueError', 'Warning', 'WindowsError',
- 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__',
- '__name__', 'abs', 'basestring', 'bool', 'buffer',
- 'chr', 'classmethod', 'cmp', 'compile',
- 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
- 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float',
- 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',
- 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter',
- 'len', 'license', 'list', 'locals', 'map', 'max', 'min',
- 'object', 'oct', 'open', 'ord', 'pow', 'property', 'quit', 'range',
- 'repr', 'reversed', 'round', 'set',
- 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
- 'tuple', 'type', 'vars', 'zip']
+ ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'Buffer
+ Error', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Excep
+ tion', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError
+ ', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError',
+ 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImp
+ lemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecatio
+ nWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StopIteration',
+ 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True',
+ 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', '
+ UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueE
+ rror', 'Warning', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__'
+ , '__import__', '__name__', 'abs', 'all', 'any', 'basestring', 'bin', 'bool', 'b
+ uffer', 'bytes', 'chr', 'chr8', 'classmethod', 'cmp', 'compile', 'complex', 'cop
+ yright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'ex
+ ec', 'exit', 'filter', 'float', 'frozenset', 'getattr', 'globals', 'hasattr', 'h
+ ash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', '
+ len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'o
+ bject', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr
+ ', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'st
+ r', 'str8', 'sum', 'super', 'trunc', 'tuple', 'type', 'vars', 'zip']
.. _tut-packages:
three`` at the command line::
>>> import sys
- >>> print sys.argv
+ >>> print(sys.argv)
['demo.py', 'one', 'two', 'three']
The :mod:`getopt` module processes *sys.argv* using the conventions of the Unix
>>> random.randrange(6) # random integer chosen from range(6)
4
+The SciPy project <http://scipy.org> has many other modules for numerical
+computations.
.. _tut-internet-access:
>>> import urllib2
>>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
... if 'EST' in line or 'EDT' in line: # look for Eastern Time
- ... print line
+ ... print(line)
<BR>Nov. 25, 09:43:32 PM EST
def average(values):
"""Computes the arithmetic mean of a list of numbers.
- >>> print average([20, 30, 70])
+ >>> print(average([20, 30, 70]))
40.0
"""
return sum(values, 0.0) / len(values)
f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
f.write(self.infile)
f.close()
- print 'Finished background zip of: ', self.infile
+ print('Finished background zip of: ', self.infile)
background = AsyncZip('mydata.txt', 'myarchive.zip')
background.start()
- print 'The main program continues to run in foreground.'
+ print('The main program continues to run in foreground.')
background.join() # Wait for the background task to finish
- print 'Main program waited until background was done.'
+ print('Main program waited until background was done.')
The principal challenge of multi-threaded applications is coordinating threads
that share data or other resources. To that end, the threading module provides
>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
- >>> print "Handling", d.popleft()
+ >>> print("Handling", d.popleft())
Handling task1
unsearched = deque([starting_node])
Particularly notable contributions are collected in a book also titled Python
Cookbook (O'Reilly & Associates, ISBN 0-596-00797-3.)
+* http://scipy.org: The Scientific Python project includes modules for fast
+ array computations and manipulations plus a host of packages for such
+ things as linear algebra, Fourier transforms, non-linear solvers,
+ random number distributions, statistical analysis and the like.
+
For Python-related questions and problem reports, you can post to the newsgroup
:newsgroup:`comp.lang.python`, or send them to the mailing list at
python-list@python.org. The newsgroup and mailing list are gatewayed, so
projects / python / commitdiff