CS 11 Python track
Lecture 5: Python 3.x
Python 3.x
• Python 3.1.2 is the latest version of Python
• (not yet available on the CS cluster)
• This lecture will summarize the main differences
between Python 2.x and Python 3.x
• Comprehensive overview:
http://docs.python.org/dev/3.0/whatsnew/3.0.html
Overview
• Python 3.x is a major revision of the language
• Several new features
• A lot of cleaning up of old features
• Many dubious old features removed entirely
• some just deprecated; will be removed eventually
• "Deliberately incompatible" with older versions
• so old code will break if run under python 3.x
This lecture
• Too many changes in Python 3.x to
conveniently fit into one lecture
• Therefore, this lecture contains features that
• are most likely to trip you up
• are most radical
• are most interesting (according to me)
print statement (1)
• The print statement is no longer special
• it's just another function!
• So instead of writing
print "hello, world!"
• You write:
print("hello, world!")
print statement (2)
• Old:
print "foo", "bar", "baz"
• New:
print("foo", "bar", "baz")
print statement (3)
• Old:
print "foobar", # no newline
• New:
print("foobar", end="")
print("foobar", end=" ")
# space instead of newline
print statement (4)
• Old:
>>> print "There are <", 2**32, "> possibilities!"
There are < 4294967296 > possibilities!
• New:
>>> print("There are <", 2**32, "> possibilities!",
sep="") # no separator
There are <4294967296> possibilities!
print statement (5)
• Old:
>>> print # prints a newline only
• New:
>>> print()
print statement (6)
• Old:
>>> print >> sys.stderr, "error!"
• New:
>>> print("error!", file=sys.stderr)
String formatting (1)
• Old:
>>> "int: %d\tfloat: %f\tstring: %s\n" %
(10, 3.14, "this is a string")
• New:
>>> "int: {0}\tfloat: {1}\tstring: {2}\n".format(
10, 3.14, "this is a string")
• (Old syntax still supported for the time being)
String formatting (2)
• Keyword syntax:
>>> "a: {0}\tb: {1}\tc: {c}".format(1, 2, c=3)
'a: 1 b: 2 c: 3'
• Literal curly braces:
>>> "Braces: {{}}".format()
'Braces: {}'
String formatting (3)
• Attributes inside curly braces:
>>> lst = [1, 2, 3, 4, 5]
>>> "lst[3] = {0[3]}".format(lst)
'lst[3] = 4'
>>> dict = {"foo" : 1, "bar" : 2}
>>> "dict[\"foo\"] = {0[foo]}".format(dict)
'dict["foo"] = 1'
String formatting (4)
• Dot syntax inside curly braces:
>>> import string
>>> "lowercase letters:{0.ascii_lowercase}".format(
string)
'lowercase letters: abcdefghijklmnopqrstuvwxyz'
• Format specifiers:
>>> "pi: {0:15.8f}".format(math.pi)
'pi: 3.14159265'
Iterators (1)
• Iterators are a new kind of Python object
• Have been around for a while (since Python 2.2)
• Are used more extensively in Python 3.x
• Embody the notion of "sequence that you can take
the next item of"
Iterators (2)
• Iterators can be constructed from most Python
sequences using the iter() function:
>>> i = iter(range(10))
>>> i
<listiterator object at 0x81c30>
Iterators (3)
• Iterators have a __next__() special method:
>>> i = iter(range(10))
>>> i.__next__()
>>> i.__next__()
...
Iterators (4)
• Continuing:
>>> i.__next__()
>>> i.__next__()
>>> i.__next__()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
Iterators (5)
• Iterating through an iterator:
i = iter(range(5))
for item in i:
print(item)
4
Iterators (6)
• In Python 3.x, common functions like map() and
filter() return iterators, not lists
• However, you can turn an iterator into a list using
the list() built-in function
• Advantage of iterator: doesn't have to generate the
entire list all at once
The range() function
• The range() function no longer returns a list
• Instead, it's "lazy"; it evaluates its arguments as
they are needed (sort of like an iterator)
• Useful if you write e.g. range(1000000) and only
use the first (say) 1000 elements
• This is also doable in Python 2.x as the xrange()
function, which no longer exists in Python 3.x
Integer division
• Dividing two integers that don't divide evenly
returns a float:
1 / 2 # ==> 0.5
5 / 3 # ==> 1.66666...
• If you want truncating behavior, use the new //
operator:
1 // 2 # ==> 0
5 // 3 # ==> 1
Removed syntax
• Backtick syntax has been removed:
•
`foo` # used to be same as str(foo)
• <> no longer usable for !=
• from X import Y only legal at top level (yeah!)
• still works, but will be removed eventually
Syntax changes (1)
• True, False, None are reserved words
• Good news: can't assign to them
• Bad news: True still == 1 etc. (retarded)
• Binary literals
• Use 0b prefix (by analogy with 0x for hexadecimal)
•
0b11001 # ==> 25
• Also octal literals with 0o prefix (who cares?)
Syntax changes (2)
• Set literals
• {1, "foo", 4} is a set (not a dictionary)
• {} is still the empty dictionary; use set() for empty sets
• Set methods:
• intersection, union, difference
•
>>> {1, 2, 3}.intersection({1, 2, 5})
•
{1, 2}
• X in <set>
•
>>> 1 in {1, 2, 3}
•
True
Syntax changes (3)
• Set comprehensions:
•
>>> {x + y for x in range(3)
•
for y in range(3)}
•
{0, 1, 2, 3, 4}
• Note difference between this and corresponding
list comprehension: no duplicates!
•
>>> [x + y for x in range(3)
•
for y in range(3)]
•
[0, 1, 2, 1, 2, 3, 2, 3, 4]
Syntax changes (4)
• Dictionary comprehensions
•
>>> {k:v for (k, v) in
•
[("foo", 1), ("bar", 2), ("baz", 3)]}
•
{'baz': 3, 'foo': 1, 'bar': 2}
Syntax changes (5)
• Strings now use Unicode (16-bit) instead of ASCII
(8-bit) representation for characters
• Unicode characters can be typed in strings directly
as \uxxxx where x = hexadecimal digit
• Strings preceded by the character b are "byte
literals"; each character is one byte
•
>>> b"foo" # byte array: [102,111,111]
•
b'foo'
•
>>> bytes([102,111,111])
•
b'foo'
Syntax changes (6)
• Byte arrays can also have characters outside of
ASCII range:
•
>>> bytes([127,128,129])
•
b'\x7f\x80\x81'
•
>>> bytes([255,255,256])
•
Traceback (most recent call last):
•
File "<stdin>", line 1, in <module>
•
ValueError: bytes must be in range(0, 256)
Syntax changes (7)
• Function argument and return value annotations
•
>>> def foo(x:int, y:int) -> int:
•
... return x + y
•
>>> foo(3, 4)
•
7
•
>>> print(foo.__annotations__)
•
{'y': <class 'int'>, 'x': <class 'int'>,
'return': <class 'int'>}
Syntax changes (8)
• Python doesn't do anything with argument and
return value annotations except make them
available as the __annotations__ attribute of
the function
• Code introspection tools might use them for e.g.
some kind of run-time type checking
• What follows the : or -> doesn't have to be a type
name; it can be any python expression e.g.
•
def foo(x:"this is x",
•
y:"and this is y") -> 42: ...
Syntax changes (9)
• nonlocal statement
• Python allows nested functions:
•
def adder(x):
•
def add(y):
•
return x + y
•
return add
•
>>> add5 = adder(5)
•
>>> add5(10) # 15
• So far so good ...
Syntax changes (10)
• Sometimes want to modify variable in an outer
scope:
•
def counter(x):
•
count = x
•
def increment():
•
nonlocal count
•
count += 1
•
return count
•
return increment
•
>>> c = counter(0)
•
>>> c() # 1
Syntax changes (11)
• Iterable unpacking:
•
>>> a, *b, c = range(5)
•
>>> a
•
0
•
>>> c
•
4
•
>>> b
•
[1, 2, 3]
Built-in functions
• raw_input() is now just input()
• reduce() is now functools.reduce()
• dict.has_key() gone; use x in dict
Exceptions
• All exceptions must subclass from
BaseException
• raise MyException(args) instead of
raise MyException, args
(allowed in Python 2.x)
• Catching: except
MyException as e, not
except MyException, e
• Other changes too: see the online docs for the full
story
Function decorators (1)
• When you write:
•
@foo
•
def bar(x):
•
# ... whatever ...
• It's the same as:
•
def bar(x):
•
# ... whatever ...
•
bar = foo(bar) # "decorated" function
Function decorators (2)
• A very common decorator:
•
class Foo:
•
@staticmethod
•
def bar(x): # n.b. no "self"
•
return 2 * x
•
>>> Foo.bar(10)
•
20
• bar is a method of class Foo, not of Foo instances
• though it also works on instances
Summing up
• These changes remove language "warts", make
language cleaner and more consistent
• Many more extensions/changes than I've
discussed here!
• See online docs for comprehensive list
• Will take time to absorb all the changes
• Python 3.x provides "2to3" program to automate
most conversions
