Examples

• 244

  Integer Division

  edit move example delete share

  244

  The standard division symbol (/) operates differently in Python 3 and Python 2 when applied to integers.

  When dividing an integer by another integer in Python 3, the division operation x / y represents a true division and produces a floating point result. In Python 3 the / maps to __truediv__. Meanwhile, the same operation in Python 2 represents a classic division that rounds the result down toward negative infinity (also known as taking the floor).

  For example:

  Code	Python 2 output	Python 3 output
  3 / 2	1	1.5
  2 / 3	0	0.6666666666666666
  -3 / 2	-2	-1.5

  The rounding-towards-zero behavior was deprecated in Python 2.2, but remains in Python 2.7 for the sake of backward compatibility and was removed in Python 3.

  Note: To get a float result (without floor rounding) we can specify one of the operands with the decimal point. The above example of 2/3 which gives 0 in Python 2 shall be used as 2 / 3.0 or 2.0 / 3 or 2.0/3.0 to get `0.6666666666666666.'

  ---

  There is also the floor division operator (//), which works the same way in both versions: it rounds down to the nearest integer (i.e., works the same as the / operator in Python 2). In Python 3 the // operator maps to __floordiv__.

  Code	Python 2 output	Python 3 output
  3 // 2	1	1
  2 // 3	0	0
  -3 // 2	-2	-2

  One can explicitly enforce true division or floor division using native functions in the operator module:

  from operator import truediv, floordiv
  assert truediv(10, 8) == 1.25                              # equiv. `/` in Python 3
  assert floordiv(10, 8) == 1                                # equiv. `/` in Python 2  or `//`
  

  While clear and explicit, using operator functions for every division can be tedious. Changing the behavior of the / operator will often be preferred. A common practice is to eliminate typical division behavior by adding from __future__ import division as the first statement in each module:

  # needs to be the first statement in a module
  from __future__ import division
  

  Code	Python 2 output	Python 3 output
  3 / 2	1.5	1.5
  2 / 3	0.6666666666666666	0.6666666666666666
  -3 / 2	-1.5	-1.5

  from __future__ import division guarantees that the / operator represents actual division and only within the modules that contain the __future__ import, so there are no compelling reasons for not enabling it in all new modules.

  Note: Some other programming languages use rounding toward zero (truncation) rather than rounding down toward negative infinity as Python does (i.e. in those languages -3 / 2 == -1). This behavior may create confusion when porting or comparing code.

  ---

  Note on float operands: As an alternative to from __future__ import division, one could use the usual division symbol / and ensure that at least one of the operands is a float: 3 / 2.0 == 1.5. However, this can be considered bad practice. It is just too easy to write average = sum(items) / len(items) and forget to cast one of the arguments to float. Moreover, such cases may frequently evade notice during testing, e.g., if you test on an array containing floats but receive an array of ints in production. Additionally, if the same code is used in Python 3, programs that expect 3 / 2 == 1 to be True will not work correctly.

  See PEP 238 for more detailed rationale why the division operator was changed in Python 3 and why old-style division should be avoided.

  ---

  See the Simple Math topic for more about division.

  edited Dec 23 '16 at 23:40

  

  

  

  

  

  +42
• 113

  Unpacking Iterables

  edit move example delete share

  113

  Python 3.x3.0

  In Python 3, you can unpack an iterable without knowing the exact number of items in it, and even have a variable hold the end of the iterable. For that, you provide a variable that may collect a list of values. This is done by placing an asterisk before the name. For example, unpacking a list:

  first, second, *tail, last = [1, 2, 3, 4, 5]
  print(first)
  # Out: 1
  print(second)
  # Out: 2
  print(tail)
  # Out: [3, 4]
  print(last)
  # Out: 5
  

  Note: When using the *variable syntax, the variable will always be a list, even if the original type wasn't a list. It may contain zero or more elements depending on the number of elements in the original list.

  first, second, *tail, last = [1, 2, 3, 4]
  print(tail)
  # Out: [3]
  
  first, second, *tail, last = [1, 2, 3]
  print(tail)
  # Out: []
  print(last)
  # Out: 3
  

  Similarly, unpacking a str:

  begin, *tail = "Hello"
  print(begin)
  # Out: 'H'
  print(tail)
  # Out: ['e', 'l', 'l', 'o']
  

  Example of unpacking a date; _ is used in this example as a throwaway variable (we are interested only in year value):

  person = ('John', 'Doe', (10, 16, 2016))
  *_, (*_, year_of_birth) = person
  print(year_of_birth)
  # Out: 2016
  

  It is worth mentioning that, since * eats up a variable number of items in the given sequence, assignments do not allow two *s for the same expression — it wouldn't know how many elements went into the first unpacking, and how many in the second:

  *head, *tail = [1, 2]
  # Out: SyntaxError: two starred expressions in assignment
  

  Python 3.x3.5

  So far we have discussed unpacking in assignments. * and ** were extended in Python 3.5. It's now possible to have several unpacking operations in one expression:

  {*range(4), 4, *(5, 6, 7)}
  # Out: {0, 1, 2, 3, 4, 5, 6, 7}
  

  Python 2.x2.0

  It is also possible to unpack an iterable into function arguments:

  iterable = [1, 2, 3, 4, 5]
  print(iterable)
  # Out: [1, 2, 3, 4, 5]
  print(*iterable)
  # Out: 1 2 3 4 5
  

  Python 3.x3.5

  Unpacking a dictionary uses two adjacent stars ** (PEP 448):

  tail = {'y': 2, 'z': 3}
  {'x': 1, **tail}
   # Out: {'x': 1, 'y': 2, 'z': 3}
  

  This allows for both overriding old values and merging dictionaries.

  dict1 = {'x': 1, 'y': 1}
  dict2 = {'y': 2, 'z': 3}
  {**dict1, **dict2}
  # Out: {'x': 1, 'y': 2, 'z': 3}
  

  Python 3.x3.0

  Python 3 removed tuple unpacking in functions. Hence the following doesn't work in Python 3

  # Works in Python 2, but syntax error in Python 3:
  map(lambda (x, y): x + y, zip(range(5), range(5)))
  # Same is true for non-lambdas:
  def example((x, y)):
      pass
  
  # Works in both Python 2 and Python 3:
  map(lambda x: x[0] + x[1], zip(range(5), range(5)))
  # And non-lambdas, too:
  def working_example(x_y):
      x, y = x_y
      pass
  

  See PEP 3113 for detailed rationale.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +22
• 99

  Strings: Bytes versus Unicode

  edit move example delete share

  99

  Python 2.x2.7

  In Python 2 there are two types of strings: bytes (str) and text (unicode).

  In Python 2, an object of type str is always a byte sequence, but is commonly used for both text and binary data.

  A string literal is interpreted as a byte string.

  s = 'Cafe'    # type(s) == str
  

  There are two exceptions: You can define a Unicode (text) literal explicitly by prefixing the literal with u:

  s = u'Café'   # type(s) == unicode
  b = 'Lorem ipsum'  # type(b) == str
  

  Alternatively, you can specify that a whole module's string literals should create Unicode (text) literals:

  from __future__ import unicode_literals
  
  s = 'Café'   # type(s) == unicode
  b = 'Lorem ipsum'  # type(b) == unicode
  

  In order to check whether your variable is a string (either Unicode or a byte string), you can use:

  isinstance(s, basestring)
  

  Python 3.x3.0

  In Python 3, the str type is a Unicode text type.

  s = 'Cafe'           # type(s) == str
  s = 'Café'           # type(s) == str (note the accented trailing e)
  

  Additionally, Python 3 added a bytes object, suitable for binary "blobs" or writing to encoding-independent files. To create a bytes object, you can prefix b to a string literal or call the string's encode method:

  # Or, if you really need a byte string:
  s = b'Cafe'          # type(s) == bytes
  s = 'Café'.encode()  # type(s) == bytes
  

  To test whether a value is a string, use:

  isinstance(s, str)
  

  Python 3.x3.3

  It is also possible to prefix string literals with a u prefix to ease compatibility between Python 2 and Python 3 code bases. Since, in Python 3, all strings are Unicode by default, prepending a string literal with u has no effect:

  u'Cafe' ==  'Cafe' 
  

  Note that you must encode a Python 3 text (str) object to convert it into a bytes representation of that text. The default encoding of this method is UTF-8.

  You can use decode to ask a bytes object for what Unicode text it represents:

  >>> b.decode()
  'Café'
  

  Python 2.x2.6

  While the bytes type exists in both Python 2 and 3, the unicode type only exists in Python 2. To use Python 3's implicit Unicode strings in Python 2, add the following to the top of your code file:

  from __future__ import unicode_literals
  print(repr("hi"))
  # u'hi'
  

  Python 3.x3.0

  Another important difference is that indexing bytes in Python 3 results in an int output like so:

  b"abc"[0] == 97
  

  Whilst slicing in a size of one results in a length 1 bytes object:

  b"abc"[0:1] == b"a"
  

  In addition, Python 3 fixes some unusual behavior with unicode, i.e. reversing byte strings in Python 2. For example, the following issue is resolved:

  # -*- coding: utf8 -*-
  print("Hi, my name is Łukasz Langa.")
  print(u"Hi, my name is Łukasz Langa."[::-1])
  print("Hi, my name is Łukasz Langa."[::-1])
  
  # Output in Python 2
  # Hi, my name is Łukasz Langa.
  # .agnaL zsakuŁ si eman ym ,iH
  # .agnaL zsaku�� si eman ym ,iH
  
  # Output in Python 3
  # Hi, my name is Łukasz Langa.
  # .agnaL zsakuŁ si eman ym ,iH
  # .agnaL zsakuŁ si eman ym ,iH
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +18
• 71

  Print statement vs. Print function

  edit move example delete share

  71

  In Python 2, print is a statement:

  Python 2.x2.7

  print "Hello World"
  print                         # print a newline
  print "No newline",           # add trailing comma to remove newline 
  print >>sys.stderr, "Error"   # print to stderr
  print("hello")                # print "hello", since ("hello") == "hello"
  print()                       # print an empty tuple "()"
  print 1, 2, 3                 # print space-separated arguments: "1 2 3"
  print(1, 2, 3)                # print tuple "(1, 2, 3)"
  

  In Python 3, print() is a function, with keyword arguments for common uses:

  Python 3.x3.0

  print "Hello World"              # SyntaxError
  print("Hello World")
  print()                          # print a newline (must use parentheses)
  print("No newline", end="")      # end specifies what to append (defaults to newline)
  print("Error", file=sys.stderr)  # file specifies the output buffer
  print("Comma", "separated", "output", sep=",")  # sep specifies the separator
  print("A", "B", "C", sep="")     # null string for sep: prints as ABC
  print("Flush this", flush=True)  # flush the output buffer, added in Python 3.3
  print(1, 2, 3)                   # print space-separated arguments: "1 2 3"
  print((1, 2, 3))                 # print tuple "(1, 2, 3)"
  

  ---

  The print function has the following parameters:

  print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
  

  sep is what separates the objects you pass to print. For example:

  print('foo', 'bar', sep='~') # out: foo~bar
  print('foo', 'bar', sep='.') # out: foo.bar
  

  end is what the end of the print statement is followed by. For example:

  print('foo', 'bar', end='!') # out: foo bar!
  

  Printing again following a non-newline ending print statement will print to the same line:

  print('foo', end='~')
  print('bar')
  # out: foo~bar
  

  Note : For future compatibility, print function is also available in Python 2.6 onwards; however it cannot be used unless parsing of the print statement is disabled with

  from __future__ import print_function
  

  This function has exactly same format as Python 3's, except that it lacks the flush parameter.

  See PEP 3105 for rationale.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +14
• 33

  Differences between range and xrange functions

  edit move example delete share

  33

  In Python 2, range function returns a list while xrange creates a special xrange object, which is an immutable sequence, which unlike other built-in sequence types, doesn't support slicing and has neither index nor count methods:

  Python 2.x2.3

  print(range(1, 10))
  # Out: [1, 2, 3, 4, 5, 6, 7, 8, 9]
  
  print(xrange(1, 10))
  # Out: xrange(1, 10)
  
  print(isinstance(xrange(1, 10), xrange))
  # Out: True
  

  In Python 3, xrange was expanded to range, which thus now creates a range object. There is no xrange type:

  Python 3.x3.0

  print(range(1, 10))
  # Out: range(1, 10)
  
  print(isinstance(range(1, 10), range))
  # Out: True
  
  # print(xrange(1, 10))
  # The output will be:
  #Traceback (most recent call last):
  #  File "<stdin>", line 1, in <module>
  #NameError: name 'xrange' is not defined
  

  Additionally, since Python 3.2, range also supports slicing, index and count:

  print(range(1, 10)[3:7])
  # Out: range(3, 7)
  print(range(1, 10).count(5))
  # Out: 1
  print(range(1, 10).index(7))
  # Out: 6
  

  ---

  The advantage of using a special sequence type instead of a list is that the interpreter does not have to allocate memory for a list and populate it:

  Python 2.x2.3

  # range(10000000000000000)
  # The output would be:
  # Traceback (most recent call last):
  #  File "<stdin>", line 1, in <module>
  # MemoryError
  
  print(xrange(100000000000000000))
  # Out: xrange(100000000000000000)
  

  Since the latter behaviour is generally desired, the former one was removed in Python 3. If you still want to have a list in Python 3, you can simply use the list() constructor on a range object:

  Python 3.x3.0

  print(list(range(1, 10)))
  # Out: [1, 2, 3, 4, 5, 6, 7, 8, 9]
  

  ---

  Compatibility

  In order to maintain compatibility between both Python 2.x and Python 3.x versions, you can use the builtins module from the external package future to achieve both forward-compatiblity and backward-compatiblity:

  Python 2.x2.0

  #forward-compatible
  from builtins import range
  
  for i in range(10**8):
      pass
  

  Python 3.x3.0

  #backward-compatible
  from past.builtins import xrange
  
  for i in xrange(10**8):
      pass
  

  The range in future library supports slicing, index and count in all Python versions, just like the built-in method on Python 3.2+.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +12
• 20

  Leaked variables in list comprehension

  edit move example delete share

  20

  Python 2.x2.3

  x = 'hello world!'
  vowels = [x for x in 'AEIOU'] 
  
  print (vowels)
  # Out: ['A', 'E', 'I', 'O', 'U']
  print(x)
  # Out: 'U'   
  

  Python 3.x3.0

  x = 'hello world!'
  vowels = [x for x in 'AEIOU']
  
  print (vowels)
  # Out: ['A', 'E', 'I', 'O', 'U']
  print(x)
  # Out: 'hello world!'
  

  As can be seen from the example, for Python2 the value of x was leaked: it masked hello world! and printed out U, since this was the last value of x when the loop ended.

  However, in Python3 x prints the orignally defined hello world!, since the local variable from the list comprehension does not mask variables from the surrounding scope.

  Additionally, neither generator expressions (available in Python since 2.5) nor dictionary or set comprehensions (which were backported to Python 2.7 from Python 3) leak variables in Python 2.

  Note that in both Python 2 and Python 3, variables will leak into the surrounding scope when using a for loop:

  x = 'hello world!'
  vowels = []
  for x in 'AEIOU':
      vowels.append(x)
  print(x)
  # Out: 'U'
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +5
• 20

  Raising and handling Exceptions

  edit move example delete share

  20

  This is the Python 2 syntax, note the commas , on the raise and except lines:

  Python 2.x2.3

  try:
      raise IOError, "input/output error"
  except IOError, exc:
      print exc
  

  In Python 3, the , syntax is dropped and replaced by parenthesis and the as keyword:

  try:
      raise IOError("input/output error")
  except IOError as exc:
      print(exc)
  

  For backwards compatibility, the Python 3 syntax is also available in Python 2.6 onwards, so it should be used for all new code that does not need to be compatible with previous versions.

  ---

  Python 3.x3.0

  Python 3 also adds exception chaining, wherein you can signal that some other exception was the cause for this exception. For example

  try:
      file = open('database.db')
  except FileNotFoundError as e:
      raise DatabaseError('Cannot open {}') from e
  

  The exception raised in the except statement is of type DatabaseError, but the original exception is marked as the __cause__ attribute of that exception. When the traceback is displayed, the original exception will also be displayed in the traceback:

  Traceback (most recent call last):
    File "<stdin>", line 2, in <module>
  FileNotFoundError
  
  The above exception was the direct cause of the following exception:
  
  Traceback (most recent call last):
    File "<stdin>", line 4, in <module>
  DatabaseError('Cannot open database.db')
  

  If you throw in an except block without explicit chaining:

  try:
      file = open('database.db')
  except FileNotFoundError as e:
      raise DatabaseError('Cannot open {}')
  

  The traceback is

  Traceback (most recent call last):
    File "<stdin>", line 2, in <module>
  FileNotFoundError
  
  During handling of the above exception, another exception occurred:
  
  Traceback (most recent call last):
    File "<stdin>", line 4, in <module>
  DatabaseError('Cannot open database.db')
  

  Python 2.x2.0

  Neither one is supported in Python 2.x, the original exception and its traceback will be lost if another exception is raised in the except block. The following code can be used for compatibility:

  import sys
  import traceback
  
  try:
      funcWithError()
  except:
      sys_vers = getattr(sys, 'version_info', (0,))
      if sys_vers < (3,0):
          traceback.print_exc()
      raise Exception("new exception")
  

  Python 3.x3.0

  To "forget" the previously thrown exception, use raise from None

  try:
      file = open('database.db')
  except FileNotFoundError as e:
      raise DatabaseError('Cannot open {}') from None
  

  Now the traceback would simply be

  Traceback (most recent call last):
    File "<stdin>", line 4, in <module>
  DatabaseError('Cannot open database.db')
  

  Or in order to make it compatible with both Python 2 and 3 you may use the six package like so:

  import six
  try:
      file = open('database.db')
  except FileNotFoundError as e:
      six.raise_from(DatabaseError('Cannot open {}'), None)
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +6
• 15

  Comparison of different types

  edit move example delete share

  15

  Python 2.x2.3

  Objects of different types can be compared. The results are arbitrary, but consistent. They are ordered lexicographically by type so an 'int' is less than a 'string' and a 'tuple' is greater than a 'list':

  [1, 2] > 'foo'
  # Out: False
  (1, 2) > 'foo'
  # Out: True
  [1, 2] > (1, 2)
  # Out: False
  100 < [1, 'x'] < 'xyz' < (1, 'x')
  # Out: True
  

  This was originally done so a list of mixed types could be sorted and objects would be grouped together by type:

  l = [7, 'x', (1,2), [5,6], 5, 8.0, 'y', 1.2, [7, 8], 'z']
  sorted(l)
  # Out: [1.2, 5, 7, 8.0, [5, 6], [7, 8], 'x', 'y', 'z', (1, 2)]
  

  Python 3.x3.0

  An exception is raised when comparing different (non-numeric) types:

  1 < 1.5
  # Out: True
  
  [1, 2] > 'foo'
  # TypeError: unorderable types: list() > str()
  (1, 2) > 'foo'
  # TypeError: unorderable types: tuple() > str()
  [1, 2] > (1, 2)
  # TypeError: unorderable types: list() > tuple()
  

  To sort mixed lists in Python 3 by types and to achieve compatibility between versions, you have to provide a key to the sorted function:

  >>> list = [1, 'hello', [3, 4], {'python':2}, 'stackoverflow', 8, {'python':3}, [5, 6]]
  >>> sorted(list, key=lambda x: str(x))
  # Out: [1, 8, [3, 4], [5, 6], 'hello', 'stackoverflow', {'python': 2}, {'python': 3}]
  

  lambda x: str(x) is converting each item to string only for the function. It then sees the string representation starting with either [, ', { or 0-9 and it's able to sort those (and all the following characters).

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +6
• 14

  True, False and None

  edit move example delete share

  14

  In Python 2, True, False and None are built-in constants. Which means it's possible to reassign them.

  Python 2.x2.0

  True, False = False, True
  True   # False
  False  # True
  

  You can't do this with None since Python 2.4.

  Python 2.x2.4

  None = None  # SyntaxError: cannot assign to None
  

  In Python 3, True, False, and None are now keywords.

  Python 3.x3.0

  True, False = False, True  # SyntaxError: can't assign to keyword
  
  None = None  # SyntaxError: can't assign to keyword
  

  edited Dec 9 '16 at 11:44

  

  

  

  
• 13

  User Input

  edit move example delete share

  13

  In Python 2, user input is accepted using the raw_input function,

  Python 2.x2.3

  user_input = raw_input()
  

  While in Python 3 user input is accepted using the input function.

  Python 3.x3.0

  user_input = input()
  

  In Python 2, the input function will accept input and interpret it. While this can be useful, it has several security considerations and was removed in Python 3. To access the same functionality, eval(input()) can be used.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +5
• 10

  yield from

  edit move example delete share

  10

  Since Python 3.3 it is possible to delegate generation:

  def countdown(n):
      if n >= 0:
          yield n
          yield from countdown(n-1)
  
  for number in countdown(5):
      print(number) # 5 4 3 2 1 0
  

  For basic iterators, countdown could be implemented roughly equivalently as:

  def countdown(n):
      if n >= 0:
          yield n
          for number in countdown(n-1):
              yield number
  

  However, yield from will also propagate up values received by send and the yield from expression evaluates to the return value of the delegated function.

  def inner():
      x = yield "inner yield"
      yield "received value: " + x
      return "inner return"
  
  def outer():
      inner_ret = yield from inner()
      yield "first outer yield + " + inner_ret
      return "outer return"
  
  example = outer()
  
  next(example)
  #>>> 'inner yield'
  
  example.send("sent value")
  #>>> 'received value: sent value'
  
  next(example)
  #>>> 'first outer yield + inner return'
  
  next(example)
  #>>> Traceback (most recent call last):
  #>>>   File "", line 22, in <module>
  #>>> StopIteration: outer return
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +1
• 9

  dict methods

  edit move example delete share

  9

  Changing in the return value

  In Python 3 the dict.items method now returns a view object while in Python 2 it returns a list, which could potentially use up a lot of memory if the dictionary to be copied is very large. The equivalent of dict.items in python2 is dict.iteritems.

  dict.iteritems doesn't exist in Python 3, since dict.items already returns an iterator.

  Python 2

  x = {1: 'one', 2: 'two', 3: 'three'}
  print(x)
  # {1: 'one', 2: 'two', 3: 'three'}
  print(x.items())
  # [(1, 'one'), (2, 'two'), (3, 'three')]
  print(x.iteritems())
  # <dictionary-itemiterator object at (random hexadecimal code)>
  print([i for i in x.iteritems()])
  # [(1, 'one'), (2, 'two'), (3, 'three')]
  

  Python 3

  x = {1: 'one', 2: 'two', 3: 'three'}
  print(x)
  # {1: 'one', 2: 'two', 3: 'three'}
  print(x.items)
  # <built-in method items of dict object at (random hexadecimal code)>
  print(x.items())
  # dict_items([(1, 'one'), (2, 'two'), (3, 'three')])
  print([i for i in x.items()])
  # [(1, 'one'), (2, 'two'), (3, 'three')]
  

  The same also goes for other dictionary methods: dict.keys, dict.values and dict.items return a list in Python 2, whilst in Python 3 they return a view object.

  From the Python documentation:

  [view objects] provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes.

  dict.viewkeys, dict.viewvalues and dict.viewitems have been back-ported to Python 2.7 to return view objects when they're called; however, these methods are not valid in Python 3.

  Method .has_key() of Python 2

  In Python 2 dict.has_key() is used to test whether the dict has a certain key.

  x = {1: 'one', 2: 'two', 3: 'three'}
  print(x.has_key(1))
  # True
  

  But this method has been removed in Python 3. Instead, the in operator Is used.

  x = {1: 'one', 2: 'two', 3: 'three'}
  # print(x.has_key(1))
  # Don't run it, unless you want this:
  #Traceback (most recent call last):
  #File "<stdin>", line 1, in <module>
  #AttributeError: 'dict' object has no attribute 'has_key'
  print(1 in x)
  # True
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +2
• 8

  Removed <> operator, `` synonym of repr, for L or l for long integers and ur prefix.

  edit move example delete share

  8

  In Python 2 <> is a synonym for !=;likewise `foo` was a synonym for repr(foo). In Python 2 long integer literals first to be suffixed with L or l, which later became optional. L or l suffixes are not supported in Python 3. Finally, though Python 3 supports both raw strings and optional u prefix since version 3.3, ur prefix (for "raw Unicode strings") is not supported.

  Python 2.x2.7

  >>> 1 <> 2
  True
  >>> 1 <> 1
  False
  >>> foo = 'hello world'
  >>> repr(foo)
  "'hello world'"
  >>> `foo`
  "'hello world'"
  >>> 1L
  1L
  >>> type(1L)
  <type 'long'>
  >>> ur'raw string\n'
  u'raw string\\n'
  

  Python 3.x3.0

  >>> 1 <> 2
    File "<stdin>", line 1
      1 <> 2
         ^
  SyntaxError: invalid syntax
  >>> `foo`
        File "<stdin>", line 1
      `foo`
      ^
  SyntaxError: invalid syntax
  
  >>> 1L
    File "<stdin>", line 1
      1L
       ^
  SyntaxError: invalid syntax
  
  >>> r'raw string\n'
  'raw string\\n'
  >>> ur'raw string\n'
    File "<stdin>", line 1
      ur'raw string\n'
                     ^
  SyntaxError: invalid syntax
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 8

  Renamed modules

  edit move example delete share

  8

  A few modules in the standard library have been renamed:

  Old name	New name
  _winreg	winreg
  ConfigParser	configparser
  copy_reg	copyreg
  Queue	queue
  SocketServer	socketserver
  _markupbase	markupbase
  repr	reprlib
  test.test_support	test.support
  Tkinter	tkinter
  tkFileDialog	tkinter.filedialog
  urllib / urllib2	urllib, urllib.parse, urllib.error, urllib.response, urllib.request, urllib.robotparser

  Some modules have even been converted from files to libraries. Take tkinter and urllib from above as an example.

  Compatibility

  When maintaining compatibility between both Python 2.x and 3.x versions, you can use the future external package to enable importing top-level standard library packages with Python 3.x names on Python 2.x versions.

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 8

  The next() method does not exist in Python 3, use next() function

  edit move example delete share

  8

  In Python 2, an iterable can be traversed by using a method called next on the iterable itself:

  Python 2.x2.3

  g = (i for i in range(0,3))
  g.next()  # Yields 0
  g.next()  # Yields 1
  g.next()  # Yields 2
  

  In Python 3 the .next method has been renamed to .__next__, acknowledging its "magic" role, so calling .next will raise an AttributeError. The correct way to access this functionality in both Python 2 and Python 3 is to call the next function with the iterator as an argument.

  Python 3.x3.0

  g = (i for i in range(0,3))
  next(g)  # Yields 0
  next(g)  # Yields 1
  next(g)  # Yields 2
  

  This code is portable across versions from 2.6 through to current releases.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +3
• 7

  Long vs. Int

  edit move example delete share

  7

  In Python 2 any integer bigger than 2**31 - 1 will be converted into the long data type. For example:

  Python 2

  2**31        # Output: 2147483648L
  type(2**31)  # Output: <type 'long'>
  2**30        # Output: 2147483647
  type(2**30)  # Output: <type 'int'>
  2**31- 1     # Output: 2147483647L (because 2**31 is long and long - int is long)
  

  However, in Python 3 the long data type was removed - no matter how big the integer is it will be int.

  Python 3

  2**1024
  # Output: 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
  print(-(2**1024))
  # Output: -179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216
  type(2**1024)
  # Output: <class 'int'>
  

  However, builtin methods still do not accept numbers too big.

  import sys
  sys.setrecursionlimit(2**31)
  # Traceback (most recent call last):
  #  File "<pyshell#1>", line 1, in <module>
  #   sys.setrecursionlimit(2**31)
  # OverflowError: Python int too large to convert to C long
  

  edited Dec 9 '16 at 11:44

  

  

  

  
• 6

  All classes are "new-style classes" in Python 3.

  edit move example delete share

  6

  In Python 3.x all classes are new-style classes; when defining a new class python implicitly makes it inherit from object. As such, specifying object in a class definition is a completely optional:

  Python 3.x3.0

  class X: pass
  class Y(object): pass
  

  Both of these classes now contain object in their mro (method resolution order):

  Python 3.x3.0

  >>> X.__mro__
  (__main__.X, object)
  
  >>> Y.__mro__
  (__main__.Y, object)
  

  In Python 2.x classes are, by default, old-style classes; they do not implicitly inherit from object. This causes the semantics of classes to differ depending on if we explicitly add object as a base class:

  Python 2.x2.3

  class X: pass
  class Y(object): pass
  

  In this case, if we try to print the __mro__ of Y, similar output as that in the Python 3.x case will appear:

  Python 2.x2.3

  >>> Y.__mro__
  (<class '__main__.Y'>, <type 'object'>)
  

  This happens because we explicitly made Y inherit from object when defining it: class Y(object): pass. For class X which does not inherit from object the __mro__ attribute does not exist, trying to access it results in an AttributeError.

  In order to ensure compatibility between both versions of Python, classes can be defined with object as a base class:

  class mycls(object):
      """ I am fully compatible with Python 2/3"""
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +3
• 5

  Absolute/Relative Imports

  edit move example delete share

  5

  In Python 3, PEP 404 changes the way imports work from Python 2. Implicit relative imports are no longer allowed in packages and from ... import * imports are only allowed in module level code.

  To achieve Python 3 behavior in Python 2:

  • the absolute imports feature can be enabled with from __future__ import absolute_import
  • explicit relative imports are encouraged in place of implicit relative imports

  ---

  For clarification, in Python 2, a module can import the contents of another module located in the same directory as follows:

  import foo
  

  Notice the location of foo is ambiguous from the import statement alone. This type of implicit relative import is thus discouraged in favor of explicit relative imports, which look like the following:

  from .moduleY import spam
  from .moduleY import spam as ham
  from . import moduleY
  from ..subpackage1 import moduleY
  from ..subpackage2.moduleZ import eggs
  from ..moduleA import foo
  from ...package import bar
  from ...sys import path
  

  The dot . allows an explicit declaration of the module location within the directory tree.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +1
• 5

  filter(), map() and zip() return iterators instead of sequences

  edit move example delete share

  5

  Python 2.x2.7

  In Python 2 filter, map and zip built-in functions return a sequence. map and zip always return a list while with filter the return type depends on the type of given parameter:

  >>> s = filter(lambda x: x.isalpha(), 'a1b2c3')
  >>> s
  'abc'
  >>> s = map(lambda x: x * x, [0, 1, 2])
  >>> s
  [0, 1, 4]
  >>> s = zip([0, 1, 2], [3, 4, 5])
  >>> s
  [(0, 3), (1, 4), (2, 5)]
  

  Python 3.x3.0

  In Python 3 filter, map and zip return iterator instead:

  >>> it = filter(lambda x: x.isalpha(), 'a1b2c3')
  >>> it
  <filter object at 0x00000098A55C2518>
  >>> ''.join(it)
  'abc'
  >>> it = map(lambda x: x * x, [0, 1, 2])
  >>> it
  <map object at 0x000000E0763C2D30>
  >>> list(it)
  [0, 1, 4]
  >>> it = zip([0, 1, 2], [3, 4, 5])
  >>> it
  <zip object at 0x000000E0763C52C8>
  >>> list(it)
  [(0, 3), (1, 4), (2, 5)]
  

  Since Python 2 itertools.izip is equivalent of Python 3 zip izip has been removed on Python 3.

  edited Dec 9 '16 at 11:44

  

  

  
• 5

  map()

  edit move example delete share

  5

  map() is a builtin that is useful for applying a function to elements of an iterable. In Python 2, map returns a list. In Python 3, map returns a map object, which is a generator.

  # Python 2.X
  >>> map(str, [1, 2, 3, 4, 5])
  ['1', '2', '3', '4', '5']
  >>> type(_)
  >>> <class 'list'>
  
  # Python 3.X
  >>> map(str, [1, 2, 3, 4, 5])
  <map object at 0x*>
  >>> type(_)
  <class 'map'>
  
  # We need to apply map again because we "consumed" the previous map....
  >>> map(str, [1, 2, 3, 4, 5])
  >>> list(_)
  ['1', '2', '3', '4', '5']
  

  In Python 2, you can pass None to serve as an identity function. This no longer works in Python 3.

  Python 2.x2.3

  >>> map(None, [0, 1, 2, 3, 0, 4])
  [0, 1, 2, 3, 0, 4]
  

  Python 3.x3.0

  >>> list(map(None, [0, 1, 2, 3, 0, 5]))
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: 'NoneType' object is not callable
  

  Moreover, when passing more than one iterable as argument in Python 2, map pads the shorter iterables with None (similar to itertools.izip_longest). In Python 3, iteration stops after the shortest iterable.

  In Python 2:

  Python 2.x2.3

  >>> map(None, [1, 2, 3], [1,2], [1, 2, 3, 4, 5])
  [(1, 1, 1), (2, 2, 2), (3, None, 3), (None, None, 4), (None, None, 5)]
  

  In Python 3:

  Python 3.x3.0

  >>> list(map(lambda x, y, z: (x, y, z), [1,2,3], [1,2], [1,2,3,4,5]))
  [(1, 1, 1), (2, 2, 2)]
  
  # to obtain the same padding as in Python 2 use zip_longest from itertools
  >>> import itertools
  >>> list(itertools.zip_longest([1, 2, 3], [1,2], [1, 2, 3, 4, 5]))
  [(1, 1, 1), (2, 2, 2), (3, None, 3), (None, None, 4), (None, None, 5)]
  

  Note: instead of map consider using list comprehensions, which are Python 2/3 compatible. Replacing map(str, [1, 2, 3, 4, 5]):

  >>> [str(i) for i in [1, 2, 3, 4, 5]]
  ['1', '2', '3', '4', '5']
  

  edited Dec 18 '16 at 18:58

  

  

  

  

  

  +2
• 5

  Reduce is no longer a built-in

  edit move example delete share

  5

  In Python 2, reduce is available either as a built-in function or from the functools package (version 2.6 onwards), whereas in Python 3 reduce is available only from functools. However the syntax for reduce in both Python2 and Python3 is the same and is reduce(function_to_reduce, list_to_reduce).

  As an example, let us consider reducing a list to a single value by dividing each of the adjacent numbers. Here we use divmod function from the operator library.

  In Python 2.x it is as simple as:

  Python 2.x2.3

  >>> my_list = [1,2,3,4,5]
  >>> import operator
  >>> reduce(operator.truediv,my_list)
  0.008333333333333333
  

  In Python 3.x the example becomes a bit more complicated:

  Python 3.x3.0

  >>> my_list = [1,2,3,4,5]
  >>> import operator, functools
  >>> functools.reduce(operator.truediv,my_list)
  0.008333333333333333
  

  We can also use from functools import reduce to avoid calling reduce with the namespace name.

  edited Dec 9 '16 at 11:44

  

  

  

  

  

  +1
• 5

  The round() function tie-breaking and return type

  edit move example delete share

  5

  round() tie breaking

  In Python 2, using round() on a number equally close to two integers will return the one furthest from 0. For example:

  Python 2.x2.7

  round(1.5)  # Out: 2.0
  round(0.5)  # Out: 1.0
  round(-0.5)  # Out: -1.0
  round(-1.5)  # Out: -2.0
  

  In Python 3 however, round() will return the even integer (aka bankers' rounding). For example:

  Python 3.x3.0

  round(1.5)  # Out: 2
  round(0.5)  # Out: 0
  round(-0.5)  # Out: 0
  round(-1.5)  # Out: -2
  

  The round() function follows the half to even rounding strategy that will round half-way numbers to the nearest even integer (for example, round(2.5) now returns 2 rather than 3).

  As per reference in Wikipedia, this is also known as unbiased rounding, convergent rounding, statistician's rounding, Dutch rounding, Gaussian rounding, or odd-even rounding.

  Half to even rounding is part of the IEEE 754 standard and it's also the default rounding mode in Microsoft's .NET.

  This rounding strategy tends to reduce the total rounding error. Since on average the amount of numbers that are rounded up is the same as the amount of numbers that are rounded down, rounding errors cancel out. Other rounding methods instead tend to have an upwards or downwards bias in the average error .

  ---

  round() return type

  The round() function returns a float type in Python 2.7

  Python 2.x2.7

  round(4.8)
  # 5.0
  

  Starting from Python 3.0, if the second argument (number of digits) is omitted, it returns an int.

  Python 3.x3.0

  round(4.8)
  # 5
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 4

  Branching based on Python version

  edit move example delete share

  4

  If you need to execute different code for different Python versions, then do consider that in time be a Python 4 with which your code could be compatible. Thus, for version tests, test whether the current version is Python 2, or greater than Python 2. It is common to define two variables PY2 and PY3 where PY2 is true for Pythons 2 (and 1 and 0.x), and PY3 for versions 3.0 and up:

  import sys
  PY2 = sys.version_info < (3,)
  PY3 = not PY2
  

  Some guides advocate the way PY3 = sys.version_info[0] == 3, but it will break whenever Python 4 is released.

  Then you can use for example

  if PY2:
      text_type = unicode
  else:
      text_type = str
  

  ---

  You shouldn't branch everywhere but instead refactor your code so that a whole function definition is changed based on whether 2 or 3 is in use. Thus do not write

  def my_func():
      if PY2:
          # Python 2 way
      else:
          # Python 3 way
  

  but rather

  if PY2:
      def my_func():
          # Python 2 way
  else:
      def my_func():
          # Python 3 way
  

  Meanwhile,defining an exact function according to the version instead of judging the version in the function itself will increase the modularity and the readability of the code.

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 4

  Compatible Subclassing with super

  edit move example delete share

  4

  Given a class

  class Pet(object):
      """A parent class."""
      def __init__(self, name):
          self.name = name
  

  Python 2.x2.0

  super(Class, instance) - Python 2/3 Compatible

  Python 2 and 3 support a concise way to subclass using super().

  class Python(Pet):
      "A sub-class using super() with args."
      def __init__(self, name):
          super(Python, self).__init__(name)                 # py2/3 compatible
          
  python = Python("Monty")
  python.name
  
  # Py2/3 Output: 'Monty'
  

  Python 3.x3.0

  super() - Python 3-only

  Note that arguments in super() are listed in reverse and is related to Python's Method Resoultion Order (MRO). It has been a source of much confusion among users. Therefore, since Python 3, super() was modified and no longer requires arguments as revised in PEP 3135.

  class Python(Pet):
      "A sub-class using super() without args."
      def __init__(self, name):
          super().__init__(name)                             # no args; only py3 compatible
          
  python = Python("Monty")
  python.name
  
  # Py2 Output: TypeError: super() takes at least 1 argument (0 given)
  # Py3 Output: 'Monty'
  

  Be aware that using this new super() (without arguments) is incompatible with Python 2. For more insight, see the rationale behind the new super() explained by Python Core Developer, Raymond Hettinger.

  edited Dec 9 '16 at 11:44

  

  

  

  
• 4

  Use __future__ imports

  edit move example delete share

  4

  To use Python 3 code in Python 2, it is necessary to include certain imports from the __future__ module. We will discuss the following imports:

  from __future__ import print_function, division, absolute_import, unicode_literals
  

  The first import will make the print function from Python 3 available within this module, as opposed to the print statement provided by Python 2. The following uses the REPL to show the difference:

  >>> print("Hello", "world")
  ('Hello', 'world')
  >>> print "Hello", "world"
  Hello world
  >>> from __future__ import print_function
  >>> print("Hello", "world")
  Hello world
  

  The division import makes the / operator perform a true division instead of a flooring division.

  >>> print(3 / 2)
  1
  >>> from __future__ import division
  >>> print(3 / 2)
  1.5
  

  The absolute_import import makes the import statement work as it does in Python 3, rather than it does in Python 2. The import statement in Python 2 had some limitations and opacities, which are cleared up in Python 3. Using this import will ensure that Python will always look for a top-level module, rather than looking first in the current package.

  unicode_literals makes 'string' literals generate unicode strings in Python 3. However, this can lead to problems, as there are some functions that expect str from Python 2 and str from Python 3.

  Python 3.x3.3

  Additionally, since Python 3.3, the optional prefix u is allowed for strings, marking the string as unicode:

  u"This is explicitly a unicode string."
  

  Thus, if you don't use unicode_literals, you can use:

  # a bytes binary data literal; actually `str` in Python 2, `bytes` in Python 3
  b'123'
  
  # a `str` literal; the type named `str` in both Pythons
  '123'
  
  # a unicode literal; this is of type `unicode` in Python 2, and type `str` in Python 3
  u'123'
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 3

  Extended List, Set, and Dictionary Unpacking

  edit move example delete share

  3

  Python 3.5+ supports extended unpacking, as described in PEP 448

  List

  >>> [-1, *range(4), -2]
  [-1, 0, 1, 2, 3, -2]
  

  Set

  >>> {-1, *range(4), -2, *range(-4, -6, -1)}
  {0, 1, 2, 3, -2, -5, -4, -1}
  

  Dictionary

  >>> x = {1: "one", 2: "two"}
  >>> y = {3: "three", 2: "other-two"}
  >>> {5: 'five', **x}
  {1: 'one', 2: 'two', 5: 'five'}
  

  Later values override earlier ones:

  >>> {1: 'foo', 5: 'five', **x, **y}
  {1: 'one', 2: 'other-two', 3: 'three', 5: 'five'}
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 3

  File I/O

  edit move example delete share

  3

  file is no longer a builtin name in 3.x (open still works).

  Internal details of file I/O have been moved to the standard library io module, which is also the new home of StringIO:

  import io
  assert io.open is open # the builtin is an alias
  buffer = io.StringIO()
  buffer.write('hello, ') # returns number of characters written
  buffer.write('world!\n')
  buffer.getvalue() # 'hello, world!\n'
  

  The file mode (text vs binary) now determines the type of data produced by reading a file (and type required for writing):

  with open('data.txt') as f:
      first_line = next(f)
      assert type(first_line) is str
  with open('data.bin', 'rb') as f:
      first_kb = f.read(1024)
      assert type(first_kb) is bytes
  

  The encoding for text files defaults to whatever is returned by locale.getpreferredencoding(False). To specify an encoding explicitly, use the encoding keyword parameter:

  with open('old_japanese_poetry.txt', 'shift_jis') as text:
      haiku = text.read()
  

  edited Dec 9 '16 at 11:44

  

  

  
• 3

  Get web page content

  edit move example delete share

  3

  try:
      # For Python 3.0 and later
      from urllib.request import urlopen
  except ImportError:
      # Fall back to Python 2's urllib2
      from urllib2 import urlopen
  
  url = 'https://en.wikipedia.org/wiki/Python_(programming_language)'
  response = urlopen(url)
  
  data = response.read()
  print(data)
  

  In Python 3, urllib2.urlopen was moved to the urllib library, so it is now in urllib.request.urlopen.

  By itself, urlopen returns a byte string of the HTML. The above code prints this data encoded as it was received, and in Python 3 additionally escaped. To correctly process the data further it needs to be decoded according to response's encoding:

  Python 3.x3.0

  encoding = response.info().get_content_charset()
  print(data.decode(encoding))
  

  Python 2.x2.7

  encoding = response.info().getencoding()
  print data.decode(encoding).encode('utf-8')  # assumes utf-8 encoding for stdout
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 3

  Keyword only arguments

  edit move example delete share

  3

  In Python 3 you can define a function that takes keyword-only arguments.

  >>> def foo(bar, *, baz):
  ...     return bar, baz
  

  Arguments following the star * must be specified by name:

  >>> foo(1, baz=2)
  (1, 2)
  

  Attempting to pass them as positional arguments raises a TypeError

  >>> foo(1, 2)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: foo() takes 1 positional argument but 2 were given
  

  The bare * is just syntax to differentiate positional and keyword arguments, and does not imply the function takes variadic arguments. However, variadic arguments and keyword-only arguments can be easily combined:

  >>> def foo(*args, baz):
  ...     return args, baz
  ...
  >>> foo(1, 2, 3, baz=4)
  ((1, 2, 3), 4)
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 3

  Octal Constants

  edit move example delete share

  3

  In Python 2, an octal literal could be defined as

  0755  # only Python 2
  

  To ensure cross-compatibility, use

  0o755  # both Python 2 and Python 3
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 2

  cmp function removed in Python 3

  edit move example delete share

  2

  In Python 3 the cmp built-in function was removed, together with the __cmp__ special method.

  From the documentation:

  The cmp() function should be treated as gone, and the __cmp__() special method is no longer supported. Use __lt__() for sorting, __eq__() with __hash__(), and other rich comparisons as needed. (If you really need the cmp() functionality, you could use the expression (a > b) - (a < b) as the equivalent for cmp(a, b).)

  Moreover all built-in functions that accepted the cmp parameter now only accept the key keyword only parameter.

  In the functools module there is also useful function cmp_to_key(func) that allows you to convert from a cmp-style function to a key-style function:

  Transform an old-style comparison function to a key function. Used with tools that accept key functions (such as sorted(), min(), max(), heapq.nlargest(), heapq.nsmallest(), itertools.groupby()). This function is primarily used as a transition tool for programs being converted from Python 2 which supported the use of comparison functions.

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 2

  Return value when writing to a file object

  edit move example delete share

  2

  In Python 2, writing directly to a file handle returns None:

  Python 2.x2.3

  hi = sys.stdout.write('hello world\n')
  # Out: hello world
  type(hi)
  # Out: <type 'NoneType'>
  

  In Python 3, writing to a handle will return the number of characters written:

  Python 3.x3.0

  import sys
  hi = sys.stdout.write('hello world\n')
  # Out: hello world
  type(hi)
  # Out: <class 'int'>
  hi
  # Out: 12
  

  Note that this return is characters and not bytes or ASCII-specific:

  Python 3.x3.0

  >>> privyet = sys.stdout.write('Привет мир\n')
  Привет мир
  >>> privyet
  11
  

  edited Dec 9 '16 at 11:44

  

  

  

  

  
• 1

  Class Boolean Value

  edit move example delete share

  1

  Python 2.x2.7

  In Python 2, if you want to define a class boolean value by your self, you need to implement the __nonzero__ method on your class. The value is True by default.

  class MyClass:
      def __nonzero__(self):
          return False
  
  my_instance = MyClass()
  print bool(MyClass)       # True
  print bool(my_instance)   # False
  

  Python 3.x3.0

  In Python 3, __bool__ is used instead of __nonzero__

  class MyClass:
      def __bool__(self):
          return False
  
  my_instance = MyClass()
  print(bool(MyClass))       # True
  print(bool(my_instance))   # False
  

  edited Dec 9 '16 at 11:44

  

  

  

  
• 1

  encode/decode to hex no longer available

  edit move example delete share

  1

  Python 2.x2.7

  "1deadbeef3".decode('hex')
  # Out: '\x1d\xea\xdb\xee\xf3'
  '\x1d\xea\xdb\xee\xf3'.encode('hex')
  # Out: 1deadbeef3
  

  Python 3.x3.0

  "1deadbeef3".decode('hex')
  # Traceback (most recent call last):
  #   File "<stdin>", line 1, in <module>
  # AttributeError: 'str' object has no attribute 'decode'
  
  b"1deadbeef3".decode('hex')
  # Traceback (most recent call last):
  #   File "<stdin>", line 1, in <module>
  # LookupError: 'hex' is not a text encoding; use codecs.decode() to handle arbitrary codecs
  
  '\x1d\xea\xdb\xee\xf3'.encode('hex')
  # Traceback (most recent call last):
  #   File "<stdin>", line 1, in <module>
  # LookupError: 'hex' is not a text encoding; use codecs.encode() to handle arbitrary codecs
  
  b'\x1d\xea\xdb\xee\xf3'.encode('hex')
  # Traceback (most recent call last):
  #  File "<stdin>", line 1, in <module>
  # AttributeError: 'bytes' object has no attribute 'encode'
  

  However, as suggested by the error message, you can use the codecs module to achieve the same result:

  import codecs
  codecs.decode('1deadbeef4', 'hex')
  # Out: b'\x1d\xea\xdb\xee\xf4'
  codecs.encode(b'\x1d\xea\xdb\xee\xf4', 'hex')
  # Out: b'1deadbeef4'
  

  Note that codecs.encode returns a bytes object. To obtain a str object just decode to ASCII:

  codecs.encode(b'\x1d\xea\xdb\xee\xff', 'hex').decode('ascii')
  # Out: '1deadbeeff'
  

  edited Dec 27 '16 at 9:20

  

  

  

  

  

  +1
• 1

  exec statement is a function in Python 3

  edit move example delete share

  1

  In Python 2, exec is a statement, with special syntax: exec code [in globals[, locals]]. In Python 3 exec is now a function: exec(code, [, globals[, locals]]), and the Python 2 syntax will raise a SyntaxError.

  As print was changed from statement into a function, a __future__ import was also added. However, there is no from __future__ import exec_function, as it is not needed: the exec statement in Python 2 can be also used with syntax that looks exactly like the exec function invocation in Python 3. Thus you can change the statements

  Python 2.x2.3

  exec 'code'
  exec 'code' in global_vars
  exec 'code' in global_vars, local_vars
  

  to forms

  Python 3.x3.0

  exec('code')
  exec('code', global_vars)
  exec('code', global_vars, local_vars)
  

  and the latter forms are guaranteed to work identically in both Python 2 and Python 3.

  edited Dec 9 '16 at 11:44