Which Version Should I Use?

• No new major releases for Python 2.x
• Many of the less intuitive constructs have been improved
• Less corner cases
• Recent standard library improvements only available in Python 3
• New features
  • Clean Unicode/bytes separation
  • Exception chaining
  • Function annotations
  • Syntax for keyword-only arguments
  • Extended tuple unpacking
  • Non-local variable declarations
• Main issues
  • Many libraries are not (yet) Python 3 compatible
  • Ported libraries might have less Python 3 compatible extensions
  • You may not control your target environment
  • Support from alternative implementations is rare

Differences by Example

Use a good reference! (available as Android app ;)

• Strings are Unicode by default
  • Python 2 used byte arrays + character encoding as strings
  • u'...' is obsolete
  • Python 3 is less forgiving with mixing strings and byte arrays
  • Potential trouble interacting with C, the OS or the web
  • Indexing a single element from a byte array yields an integer (solution: use slicing)
  • Regular expressions also differentiate strings and byte arrays
• print is now a function
  • print >>sys.stderr, 1, 2, 3 ⇒ print(1, 2, 3, file=sys.stderr)
  • sys.stderr.write(.)
• xrange ⇒ range
  • Use list() if required (e.g. in interactive sessions)
• try...except statement
  • Python 2: except (RuntimeError, ImportError), e
  • Python 3: except (RuntimeError, ImportError) as e
• Python 2

• # Python 3 differences
  a_list = range(0, 10, 2)
  squares = [x ** 2 for x in range(10)]
  
  try:
      1 / 0
  except (ZeroDivisionError, AttributeError), e:
      pass
  
  a_string = u"text"
  

• Python 3

• # Python 3 differences
  a_list = range(0, 10, 2)
  a_list = list(range(0, 10, 2))
  
  squares = [x ** 2 for x in range(10)]
  
  try:
      1 / 0
  except (ZeroDivisionError, AttributeError) as e:
      pass
  
  a_string = "text"
  

• Floating point instead of floor division
• long data type removed
  • sys.maxint ⇒ sys.maxsize
• Relative imports
  • All imports now are absolute by default
  • from . import submodule
• __nonzero__(self) ⇒ __bool__(self)
  • Truth test for objects

  • 
    
    class Stack(object):
        """
        Stump of a single stack in a pre-marshalling problem.
    
        A stack can only be filled or emptied from top. Each stack has a given
        maximum high.
    
        The highest priority of any container on the stack is 1. Increasing
        numbers mean decreasing priority.
        """
    
        def __init__(self, max_size):
            """
            Initialize a new empty stack.
            """
            self._containers = []
            self._max_size = max_size
            self._steps = 0
    
        def __len__(self):
            """
            Use the container list's len.
            """
            return len(self._containers)
    
        def __bool__(self):
            """
            All existing stacks are True.
    
            This is important to be able to test for existance. Otherwise empty
            stacks would evaluate to False (as __len__ is the backup for evaluating
            truth values and empty stacks would be False.
            """
            return True
    
    
    def search_final_stack(container):
        """
        Return stack if found, otherwise None.
    
        Dummy implementation.
        """
        return stack
    
    
    stack = Stack(5)
    for _i in range(5):
        final_stack = search_final_stack(3)
        if final_stack:
            print("found a stack")
        else:
            print("no final stack available")
    

• reduce(.)
  • moved to functools.reduce(.)
• argparse
  • successor of optparse
• iterator.next() ⇒ next(iterator)

Case Study - Porting an Existing Program

1. Prerequisites
   • Make sure you have a comprehensive battery of tests
   • Ensure that required libraries are available for Python 3
   • pip3 and nosetests3 are your friends
2. Run the tests to see if they pass
3. Commit the current state to a VCS
4. Run 2to3
   1. Convert multiple files by passing a directory
   2. 2to3 -w dirname/
   3. Later, consider 2to3 -w -f idioms dirname/
   4. Shebangs are not adjusted
5. Manual porting "loop"
   1. Run the tests
   2. Fix failures
   3. Stop if all tests pass
6. Run a view manual system tests
   • If errors occur, create new unit tests
   • Fix remaining issues
7. Commit the result to a VCS (maybe a new branch)

• Flowchart
• Comprehensive example

Conclusion

• Use Python 3 whenever possible
• Porting is a pain
• #1 problem: difference between strings and byte arrays
• Be sure to use version control before porting
• Unit tests are essential...
• Don't port anything without unit tests
• Unit tests are essential. Really!

Further Reading