Python 2.7 Quick Reference

Style chooser: Modern, Modern B&W, Modern Colored, Classic, High contrast or Printing
[Hint: Use styles Modern B&W or Printing to print. If you get problems, try printing the PDF versions instead]

Contents

• Front matter
• Invocation Options
• Environment variables
• Lexical entities : keywords, identifiers, string literals, boolean constants, numbers, sequences, dictionaries, sets, operators
• Basic types and their operations: None, bool, Numeric types, sequence types, list, dictionary, string, file, set, named tuples, date/time
• Advanced types
• Statements: assignment, conditional expressions, control flow, exceptions, name space, function def, class def
• Iterators; Generators; Descriptors; Decorators
• Built-in Functions
• Built-in Exceptions
• Standard methods & operators redefinition in user-created Classes
• Special informative state attributes for some types
• Important modules : sys, os, posix, posixpath, shutil, time, string, re, math, compressions
• List of modules in the base distribution
• Workspace exploration and idiom hints
• Python mode for Emacs

Front matter

Last updated on April 16, 2013.

Apr 16-May 27, 2013

Some corrections, see bottom, by Stefan McKinnon Høj-Edwards.

Oct, 2011

upgraded by Stefan McKinnon Høj-Edwards for Python 2.7

Feb 10, 2009

upgraded by Richard Gruet and Josh Stone for Python 2.6

Dec 14, 2006

upgraded by Richard Gruet for Python 2.5

Feb 17, 2005,

upgraded by Richard Gruet for Python 2.4

Oct 3, 2003

upgraded by Richard Gruet for Python 2.3

May 11, 2003, rev 4

upgraded by Richard Gruet for Python 2.2 (restyled by Andrei)

Aug 7, 2001

upgraded by Simon Brunning for Python 2.1

May 16, 2001

upgraded by Richard Gruet and Simon Brunning for Python 2.0

Jun 18, 2000

upgraded by Richard Gruet for Python 1.5.2

Oct 20, 1995

created by Chris Hoffmann for Python 1.3

Features added in 2.7 since 2.6
Features added in 2.6 since 2.5
Features added in 2.5 since 2.4
A link

• Python Bestiary, author: Ken Manheimer
• Python manuals, authors: Guido van Rossum and Fred Drake
• python-mode.el, author: Tim Peters
• and the readers of comp.lang.python

• Python's nest: http://www.python.org
• Official documentation: http://docs.python.org/2.7/   [Module index; Language Reference]
  (use Ctrl-F to search the PQR)
• Other doc & free books : FAQs, Dive into Python (from 2004), Python Cookbook - Popular Python recipes, Thinking in Python (from 2001), Text processing in Python (from 2003)
• Getting started: Python Tutorial, 7mn to Hello World (windows)
• Topics: HOWTOs, Databases, Web programming, XML, Web Services, Parsers, NumPy & SciPy - Numeric & Scientific Computing, GUI programming, Distributing
• Where to find packages: Python Package Index (PyPI), Python Eggs, SourceForge (search "python"), Easy Install, O'Reilly Python DevCenter
• Wiki: moinmoin
• Newsgroups: comp.lang.python and comp.lang.python.announce
• Misc pages: Daily Python URL
• Python Development: http://www.python.org/dev/
• Jython - Java implementation of Python: http://www.jython.org/
• IronPython - Python on .Net: http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython
• ActivePython: http://www.ActiveState.com/ASPN/Python/
• Help desk: help@python.org
• 2 excellent (but somehow outdated) Python reference books: Python Essential Reference (Python 2.1) by David Beazley & Guido Van Rossum (Other New Riders) and Python in a nutshell by Alex martelli (O'Reilly).
• Python 2.4 Reference Card (cheatsheet) by Laurent Pointal, designed for printing (15 pages).
• Online Python 2.2 Quick Reference by the New Mexico Tech Computer Center.

Tip: From within the Python interpreter, type help, help(object) or help("name") to get help.

Invocation Options

python[w] [-BdEhimOQsStuUvVWxX3] [-c command | scriptFile | - ] [args]
    (pythonw does not open a terminal/console; python does)

• Available IDEs in std distrib: IDLE (tkinter based, portable), Pythonwin (on Windows). Other free IDEs: IPython (enhanced interactive Python shell - 2011), Eric (2011), SPE (2010), BOA constructor (GUI Builder - 2011), PyDev (Eclipse plugin - 2011).
• Typical python module header :

  #!/usr/bin/env python
# -*- coding: latin1 -*-

  Since 2.3 the encoding of a Python source file must be declared as one of the two first lines (or defaults to 7 bits Ascii) [PEP-0263], with the format:
  

  # -*- coding: encoding -*-

  Std encodings are defined here, e.g. ISO-8859-1 (aka latin1), iso-8859-15 (latin9), UTF-8... Not all encodings supported, in particular UTF-16 is not supported.
  
• It's now a syntax error if a module contains string literals with 8-bit characters but doesn't have an encoding declaration (was a warning before).
• Since 2.5, from __future__ import feature statements must be declared at beginning of source file.
• Site customization: File sitecustomize.py is automatically loaded by Python if it exists in the Python path (ideally located in ${PYTHONHOME}/lib/site-packages/).
• Tip: when launching a Python script on Windows,
  

  <pythonHome>\python myScript.py args ... can be reduced to :
  myScript.py args ... if <pythonHome> is in the PATH envt variable, and further reduced to :
  myScript args ... provided that .py;.pyw;.pyc;.pyo is added to the PATHEXT envt variable.

Environment variables

Notable lexical entities

Keywords

        and       del       for       is        raise
        assert    elif      from      lambda    return
        break     else      global    not       try
        class     except    if        or        while
        continue  exec      import    pass      with
        def       finally   in        print     yield

• (List of keywords available in std module: keyword)
• Illegitimate Tokens (only valid in strings): $ ? (plus @ before 2.4)
• A statement must all be on a single line. To break a statement over multiple lines, use "\", as with the C preprocessor.
  Exception: can always break when inside any (), [], or {} pair, or in triple-quoted strings.
• More than one statement can appear on a line if they are separated with semicolons (";").
• Comments start with "#" and continue to end of line.

Identifiers

(letter | "_") (letter | digit | "_")*

• Python identifiers keywords, attributes, etc. are case-sensitive.
• Special forms: _ident (not imported by 'from module import *'); __ident__ (system defined name); __ident (class-private name mangling).

String literals

• Use \ at end of line to continue a string on next line.
• Adjacent strings are concatened, e.g. 'Monty ' 'Python' is the same as 'Monty Python'.
• u'hello' + ' world'  --> u'hello world'   (coerced to unicode)

• NUL byte (\000) is not an end-of-string marker; NULs may be embedded in strings.
• Strings (and tuples) are immutable: they cannot be modified.

Boolean constants

• True
• False

Since 2.3, they are of new type bool.

Numbers

• Decimal integer: 1234, 1234567890546378940L (or l)
• Binary integer: 0b10, 0B10, 0b10101010101010101010101010101010L (begins with a 0b or 0B)
• Octal integer: 0177, 0o177, 0O177, 0177777777777777777L (begins with a 0 , 0o, or 0O)
• Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFFL (begins with 0x or 0X)
• Long integer (unlimited precision): 1234567890123456L (ends with L or l) or long(1234)
• Float (double precision): 3.14e-10, .001, 10., 1E3
• Complex: 1J, 2+3J, 4+5j (ends with J or j, + separates (float) real and imaginary parts)

Integers and long integers are unified starting from release 2.2 (the L suffix is no longer required)

Sequences

Strings and tuples are immutable, lists are mutable.

• Strings (types str and unicode) of length 0, 1, 2 (see above)
    '', '1', "12", 'hello\n'
• Tuples (type tuple) of length 0, 1, 2, etc:
    () (1,) (1,2) # parentheses are optional if len > 0
• Lists (type list) of length 0, 1, 2, etc:
    [] [1] [1,2]

• Indexing is 0-based. Negative indices (usually) mean count backwards from end of sequence.
• Sequence slicing [starting-at-index : but-less-than-index [ : step]]. Start defaults to 0, end to len(sequence), step to 1.

    a = (0,1,2,3,4,5,6,7)
    a[3] == 3
    a[-1] == 7
    a[2:4] == (2, 3)
    a[1:] == (1, 2, 3, 4, 5, 6, 7)
    a[:3] == (0, 1, 2)
    a[:] == (0,1,2,3,4,5,6,7) # makes a copy of the sequence.
    a[::2] == (0, 2, 4, 6) # Only even numbers. 
    a[::-1] = (7, 6, 5, 4, 3 , 2, 1, 0) # Reverse order.

Dictionaries (Mappings)

Dictionaries (type dict) of length 0, 1, 2, etc: {key: value} {1 : 'first'} {1 : 'first', 'two': 2, key:value}

Sets

Operators and their evaluation order

• Alternate names are defined in module operator (e.g. __add__ and add for +)
• Most operators are overridable

Basic types and their operations

Comparisons (defined between any types)

• Comparison behavior can be overridden for a given class by defining special method __cmp__.
• (1) X < Y < Z < W has expected meaning, unlike C
• (2) Compare object identities (i.e. id(object)), not object values.

None

• None is used as default return value on functions. Built-in single object with type NoneType. Might become a keyword in the future.
• Input that evaluates to None does not print when running Python interactively.
• None is now a constant; trying to bind a value to the name "None" is now a syntax error.

Boolean operators

• Truth testing behavior can be overridden for a given class by defining special method __nonzero__.
• (1) Evaluate second arg only if necessary to determine outcome.

Numeric types

Floats, integers, long integers, Decimals.

• Floats (type float) are implemented with C doubles.
• Integers (type int) are implemented with C longs (signed 32 bits, maximum value is sys.maxint)
• Long integers (type long) have unlimited size (only limit is system resources).
• Integers and long integers are unified starting from release 2.2 (the L suffix is no longer required). int() returns a long integer instead of raising OverflowError. Overflowing operations such as 2<<32 no longer trigger FutureWarning and return a long integer.
• Since 2.4, new type Decimal introduced (see module: decimal) to compensate for some limitations of the floating point type, in particular with fractions. Unlike floats, decimal numbers can be represented exactly; exactness is preserved in calculations; precision is user settable via the Context type [PEP 327].

Operators on all numeric types

• (1) / is still a floor division (1/2 == 0) unless validated by a from __future__ import division.
• (2) int and long has bit_length() method that returns the number of bits necessary to represent its argument in binary.
• classes may override methods __truediv__ and __floordiv__ to redefine these operators.

Bit operators on integers and long integers

Complex Numbers

• Type complex, represented as a pair of machine-level double precision floating point numbers.
• The real and imaginary value of a complex number z can be retrieved through the attributes z.real and z.imag.

Numeric exceptions

TypeError

raised on application of arithmetic operation to non-number

OverflowError

numeric bounds exceeded

ZeroDivisionError

raised when zero second argument of div or modulo op

Operations on all sequence types (lists, tuples, strings)

• (1) if i or j is negative, the index is relative to the end of the string, ie len(s)+i or len(s)+j is substituted. But note that -0 is still 0.
• (2) The slice of s from i to j is defined as the sequence of items with index k such that i<= k < j.
  If i or j is greater than len(s), use len(s). If j is omitted, use len(s). If i is greater than or equal to j, the slice is empty.
• (3) For strings: x in s is True if x is a substring of s.
• (4) Raises a ValueError exception when x is not found in s (i.e. out of range).

Operations on mutable sequences (type list)

• (1) Raises a ValueError exception when x is not found in s (i.e. out of range).
• (2) The sort() method takes an optional argument cmp specifying a comparison function taking 2 list items and returning -1, 0, or 1 depending on whether the 1st argument is considered smaller than, equal to, or larger than the 2nd argument. Note that this slows the sorting process down considerably. Since 2.4, 2 optional keywords args are added: key is a function of one argument that used to extract a comparison key from each list element (faster than cmp). Also, see attrgetter and itemgetter in the operator module. reverse: If True, reverse the sense of the comparison used.
  Since Python 2.3, the sort is guaranteed "stable". This means that two entries with equal keys will be returned in the same order as they were input. For example, you can sort a list of people by name, and then sort the list by age, resulting in a list sorted by age where people with the same age are in name-sorted order.
• (3) The sort() and reverse() methods modify the list in place for economy of space when sorting or reversing a large list. They don't return the sorted or reversed list to remind you of this side effect.
• (4) The pop() method is not supported by mutable sequence types other than lists. The optional argument i defaults to -1, so that by default the last item is removed and returned.
• (5) Raises a TypeError when x is not a list object.
• (6) append vs. extend: append takes any object and places as last element in list, while extend only takes a iterable object and extends the list with each element in x.

Operations on mappings / dictionaries (type dict)

• TypeError is raised if key is not acceptable.
• (1) KeyError is raised if key k is not in the map.
• (2) Keys and values are listed in random order.
• (3) Never raises an exception if k is not in the map, instead it returns defaultval. defaultval is optional, when not provided and k is not in the map, None is returned.
• (4) Never raises an exception if k is not in the map, instead returns defaultVal, and adds k to map with value defaultVal. defaultVal is optional. When not provided and k is not in the map, None is returned and added to map.
• (5) A view object provides a dynamic view on the dictionary's entries, which means that when the dictionary changes, the view reflects these changes. A view object is also iterable.

Operations on strings (types str & unicode)

• (1) Padding is done using spaces or the given character.
• (2) If optional argument start is supplied, substring s[start:] is processed. If optional arguments start and end are supplied, substring s[start:end] is processed.
• (3) Default encoding is sys.getdefaultencoding(), can be changed via sys.setdefaultencoding(). Optional argument errors may be given to set a different error handling scheme. The default for errors is 'strict', meaning that encoding errors raise a ValueError. Other possible values are 'ignore' and 'replace'. See also module codecs.
• (4) If optional argument tabsize is not given, a tab size of 8 characters is assumed.
• (5) Returns False if string s does not contain at least one character.
• (6) Returns False if string s does not contain at least one cased character.
• (7) A titlecased string is a string in which uppercase characters may only follow uncased characters and lowercase characters only cased ones.
• (8) s is returned if width is less than len(s).
• (9) If the optional argument maxCount is given, only the first maxCount occurrences are replaced.
• (10) If separator is not specified or None, any whitespace string is a separator. If maxsplit is given, at most maxsplit splits are done.
• (11) Line breaks are not included in the resulting list unless keepends is given and true.
• (12) table must be a string of length 256.

String formatting with the % operator

formatString % args --> evaluates to a string

• formatString mixes normal text with C printf format fields :

  %[flag][width][.precision] formatCode

  where formatCode is one of c, s, i, d, u, o, x, X, e, E, f, g, G, r, % (see table below).
• The flag characters -, +, blank, # and 0 are understood (see table below).
• Width and precision may be a * to specify that an integer argument gives the actual width or precision. Examples of width and precision :
  

  Examples

  Format string	Result
  '%3d' % 2	' 2'
  '%*d' % (3, 2)	' 2'
  '%-3d' % 2	'2 '
  '%03d' % 2	'002'
  '% d' % 2	' 2'
  '%+d' % 2	'+2'
  '%+3d' % -2	' -2'
  '%- 5d' % 2	' 2 '
  '%.4f' % 2	'2.0000'
  '%.*f' % (4, 2)	'2.0000'
  '%0*.*f' % (10, 4, 2)	'00002.0000'
  '%10.4f' % 2	' 2.0000'
  '%010.4f' % 2	'00002.0000'

• %s will convert any type argument to string (uses str() function)
• args may be a single arg or a tuple of args

  '%s has %03d quote types.' % ('Python', 2)  == 'Python has 002 quote types.'

• Right-hand-side can also be a mapping:

  a = '%(lang)s has %(c)03d quote types.' % {'c':2, 'lang':'Python'}

  (vars() function very handy to use on right-hand-side)

String templating

String formatting with format()

Operations on files (type file)

Operators on file objects

File Exceptions

EOFError

End-of-file hit when reading (may be raised many times, e.g. if f is a tty).

IOError

Other I/O-related I/O operation failure

Operation on sets (types set & frozenset)

Named Tuples

Date/Time

• time: time access and conversions
• datetime: classes date, time, datetime, timedelta, tzinfo.
• calendar: with functions such as isleap(year), leapdays(y1, y2) and weekday(year, month, day).

Advanced Types

• Module objects
• Class objects
• Class instance objects
• Type objects (see module: types)
• File objects (see above)
• Slice objects
• Ellipsis object, used by extended slice notation (unique, named Ellipsis)
• Null object (unique, named None)
• XRange objects
• Callable types:
  • User-defined (written in Python):
    • User-defined Function objects
    • User-defined Method objects
  • Built-in (written in C):
    • Built-in Function objects
    • Built-in Method object
• Internal Types:
  • Code objects (byte-compile executable Python code: bytecode)
  • Frame objects (execution frames)
  • Traceback objects (stack trace of an exception)

Statements

Assignment operators

• (1) Can unpack tuples, lists, and strings:
  

  first, second = l[0:2]    # equivalent to: first=l[0]; second=l[1]
[f, s] = range(2)    # equivalent to: f=0; s=1
c1,c2,c3 = 'abc'    # equivalent to: c1='a'; c2='b'; c3='c'
(a, b), c, (d, e, f) = ['ab', 'c', 'def']    # equivalent to: a='a'; b='b'; c='c'; d='d'; e='e'; f='f'


  Tip: x,y = y,x swaps x and y.
• (2) Multiple assignment possible:
  

  a = b = c = 0
list1 = list2 = [1, 2, 3]    # list1 and list2 points to the same list (l1 is l2)


• (3) Not exactly equivalent - a is evaluated only once. Also, where possible, operation performed in-place - a is modified rather than replaced.

Conditional Expressions

Control Flow statements

Exception statements

• An exception is an instance of an exception class.
• Exception classes must be derived from the predefined class: Exception, e.g.:

  class TextException(Exception): pass
  try:
      if bad:
          raise TextException()
  except Exception:
      print 'Oops'  # This will be printed because TextException is a subclass of Exception
  

• When an error message is printed for an unhandled exception, the class name is printed, then a colon and a space, and finally the instance converted to a string using the built-in function str().
• All built-in exception classes derives from StandardError, itself derived from Exception.
  
• [PEP 352]: Exceptions can now be new-style classes, and all built-in ones are. Built-in exception hierarchy slightly reorganized with the introduction of base class BaseException. Raising strings as exceptions is now deprecated (warning).

Name Space Statements

Packages (>1.5): a package is a name space which maps to a directory including module(s) and the special initialization module __init__.py (possibly empty).
Packages/directories can be nested. You address a module's symbol via [package.[package...].module.symbol.
[1.51: On Mac & Windows, the case of module file names must now match the case as used in the import statement]

import sys; print sys.argv
import package1.subpackage.module
package1.subpackage.module.foo()

from sys import argv; print argv
from package1 import module; module.foo()
from package1.module import foo; foo()

from sys import *; print argv
from package.module import *; print x

Function Definition

def funcName ([paramList]):
    suite

Creates a function object and binds it to name funcName.

paramList ::= [param [, param]*]
param ::= value | id=value | *id | **id

• Args are passed by "call-by-object-reference". This means, that mutable objects can be modified (ie. inout parameters), while immutable are passed by value (ie. in parameters).
• Use return to return (None) from the function, or return value to return value. Use a tuple to return more than one value, e.g. return 1,2,3
• Keyword arguments arg=value specify a default value (evaluated at function def. time). They can only appear last in the param list, e.g. foo(x, y=1, s='').
• Pseudo-arg *args captures a tuple of all remaining non-keyword args passed to the function, e.g. if def foo(x, *args): ... is called foo(1, 2, 3), then args will contain (2,3).
• Pseudo-arg **kwargs captures a dictionary of all extra keyword arguments, e.g. if def foo(x, **kwargs): ... is called foo(1, y=2, z=3), then kwargs will contain {'y':2, 'z':3}. if def foo(x, *args, **kwargs): ... is called foo(1, 2, 3, y=4, z=5), then args will contain (2, 3), and kwargs will contain {'y':4, 'z':5}
• args and kwargs are conventional names, but other names may be used as well.
• *args and **kwargs can be "forwarded" (individually or together) to another function, e.g.
  def f1(x, *args, **kwargs):
  f2(*args, **kwargs)
  Since 2.6, **kwargs can be any mapping, not only a dict.
• See also Anonymous functions (lambdas).

Class Definition

class className [(super_class1[, super_class2]*)]:
  suite

Creates a class object and assigns it name className.
suite may contain local "defs" of class methods and assignments to class attributes.

class MyClass (class1, class2): ...
  Creates a class object inheriting from both class1 and class2. Assigns new class object to name MyClass.

class MyClass: ...
  Creates a base class object (inheriting from nothing). Assigns new class object to name MyClass. Since 2.5 the equivalent syntax class MyClass(): ... is allowed.

class MyClass (object): ...
  Creates a new-style class (inheriting from object makes a class a new-style class -available since Python 2.2-). Assigns new class object to name MyClass.

• First arg to class instance methods (operations) is always the target instance object, called 'self' by convention.
• Special static method __new__(cls[,...]) called when instance is created. 1st arg is a class, others are args to __init__(), more details here
• Special method __init__() is called when instance is created.
• Special method __del__() called when no more reference to object.
• Create instance by "calling" class object, possibly with arg (thus instance=apply(aClassObject, args...) creates an instance!)

class c (c_parent):
    def __init__(self, name): 
        self.name = name
    def print_name(self): 
        print "I'm", self.name
    def call_parent(self): 
        c_parent.print_name(self)
        
instance = c('tom')
print instance.name
'tom'
instance.print_name()
"I'm tom"

Types / classes unification

x = int(2) # built-in cast function now a constructor for base type
y = 3  # <=> int(3) (litterals are instances of new base types)
print type(x), type(y) # int, int

assert isinstance(x, int) # replaces isinstance(x, types.IntType)

assert issubclass(int, object) # base types derive from base class 'object'.
s = "hello" # <=> str("hello")
assert isinstance(s, str)

f = 2.3  # <=> float(2.3)
class MyInt(int): pass    # may subclass base types
x,y = MyInt(1), MyInt("2")

print x, y, x+y # => 1,2,3

class MyList(list): pass

l = MyList("hello")

print l # ['h', 'e', 'l', 'l', 'o']

Documentation Strings

class C:
    "A description of C"
        def __init__(self):
            "A description of the constructor"
            # etc.
            
c.__doc__ == "A description of C".
c.__init__.__doc__ == "A description of the constructor"

Iterators

• An iterator enumerates elements of a collection. It is an object with a single method next() returning the next element or raising StopIteration.
• You get an iterator on obj via the new built-in function iter(obj), which calls obj.__class__.__iter__().
• A collection may be its own iterator by implementing both __iter__() and next().
• Built-in collections (lists, tuples, strings, dict) implement __iter__(); dictionaries (maps) enumerate their keys; files enumerates their lines.
• You can build a list or a tuple from an iterator, e.g. list(anIterator)
• Python implicitly uses iterators wherever it has to loop :
  • for elt in collection:
  • if elt in collection:
  • when assigning tuples: x,y,z= collection

Generators

• A generator is a function that retains its state between 2 calls and produces a new value at each invocation. The values are returned (one at a time) using the keyword yield, while return or raise StopIteration() are used to notify the end of values.
• A typical use is the production of IDs, names, or serial numbers. Fancier applications like nanothreads are also possible.
• To use a generator: call the generator function to get a generator object, then call generator.next() to get the next value until StopIteration is raised.
• 2.4 introduces generator expressions [PEP 289] similar to list comprehensions, except that they create a generator that will return elements one by one, which is suitable for long sequences :
    linkGenerator = (link for link in get_all_links() if not link.followed)
  for link in linkGenerator:
    ...process link...
  Generator expressions must appear between parentheses.
• [PEP342] Generators before 2.5 could only produce output. Now values can be passed to generators via their method send(value). yield is now an expression returning a value, so val = (yield i) will yield i to the caller, and will reciprocally evaluate to the value "sent" back by the caller, or None.
  Two other new generator methods allow for additional control:
  • throw(type, value=None, traceback=None) is used to raise an exception inside the generator (appears as raised by the yield expression).
  • close() raises a new GeneratorExit exception inside the generator to terminate the iteration.
• Since 2.6 Generator objects have a gi_code attribute that refers to the original code object backing the generator.

def genID(initialValue=0):
  v = initialValue
  while v < initialValue + 1000:
    yield "ID_%05d" % v
    v += 1
  return    # or: raise StopIteration()

generator = genID() # Create a generator
for i in range(10): # Generates 10 values
  print generator.next()

Descriptors / Attribute access

Decorators for functions, methods & classes

• @staticmethod - makes a method static (unbound) from an instance.
• @classmethod - A class method receives the class as implicit first argument, just like an instance method receives the instance.
• @prop.getter, @prop.setter and @prop.deleter - Use a function for getting, setting or deleting the property prop

Misc

lambda [param_list]: returnedExpr

Creates an anonymous function.
returnedExpr must be an expression, not a statement (e.g., not "if xx:...", "print xxx", etc.) and thus can't contain newlines. Used mostly for filter(), map(), reduce() functions, and GUI callbacks.

List comprehensions

result = [expression for item1 in sequence1  [if condition1]
  [for item2 in sequence2 [if condition2] ... for itemN in sequenceN [if conditionN]]
  ]

is equivalent to:

result = []
for item1 in sequence1:
  if (condition1):
    for item2 in sequence2:
      if (condition2):
        ...
        for itemN in sequenceN:
          if (conditionN):
            result.append(expression)

NB! Note that in the list comprehension example, the outer (non-italic) square brackets are mandatory (for lists, round brackets for sets or curly brackets for dictionaries, see below), whereas the middle, italic brackets indicate optional blocks in the list comprehension.

List comprehensions for dictionaries and sets

>>> {x: x*x for x in range(6)}
		{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25} # Dictionary

Equivalent to:

>>> dict([(x, x*x) for x in range(6)])

Sets:

>>> {('a'*x) for x in range(6)}
		 set(['', 'a', 'aa', 'aaa', 'aaaa', 'aaaaa'])

See also Generator expressions.

Built-In Functions

x = 1; assert eval('x + 1') == 2

Built-In Exception classes

• GeneratorExit
  Raised by the close() method of generators to terminate the iteration. Before 2.6 was derived from Exception.
• KeyboardInterrupt
  On user entry of the interrupt key (often `CTRL-C'). Before 2.5 was derived from Exception.
• SystemExit
  On sys.exit(). Before 2.5 was derived from Exception.
• Exception
  Base of all errors. Before 2.5 was the base of all exceptions.
  • GeneratorExit
    Moved under BaseException.
  • StandardError
    Base class for all built-in exceptions; derived from Exception root class.
    • ArithmeticError
      Base class for arithmetic errors.
      • FloatingPointError
        When a floating point operation fails.
      • OverflowError
        On excessively large arithmetic operation.
      • ZeroDivisionError
        On division or modulo operation with 0 as 2nd argument.
    • AssertionError
      When an assert statement fails.
    • AttributeError
      On attribute reference or assignment failure
    • EnvironmentError
      On error outside Python; error arg. tuple is (errno, errMsg...)
      • IOError
        I/O-related operation failure.
      • OSError
        Used by the os module's os.error exception.
        • WindowsError
          When a Windows-specific error occurs or when the error number does not correspond to an errno value.
    • EOFError
      Immediate end-of-file hit by input() or raw_input()
    • ImportError
      On failure of import to find module or name.
    • KeyboardInterrupt
      Moved under BaseException.
    • LookupError
      base class for IndexError, KeyError
      • IndexError
        On out-of-range sequence subscript
      • KeyError
        On reference to a non-existent mapping (dict) key
    • MemoryError
      On recoverable memory exhaustion
    • NameError
      On failure to find a local or global (unqualified) name.
      • UnboundLocalError
        On reference to an unassigned local variable.
    • ReferenceError
      On attempt to access to a garbage-collected object via a weak reference proxy.
    • RuntimeError
      Obsolete catch-all; define a suitable error instead.
      • NotImplementedError
        On method not implemented.
    • SyntaxError
      On parser encountering a syntax error
      • IndentationError
        On parser encountering an indentation syntax error
        • TabError
          On improper mixture of spaces and tabs
    • SystemError
      On non-fatal interpreter error - bug - report it !
    • TypeError
      On passing inappropriate type to built-in operator or function.
    • ValueError
      On argument error not covered by TypeError or more precise.
      • UnicodeError
        On Unicode-related encoding or decoding error.
        • UnicodeDecodeError
          On Unicode decoding error.
        • UnicodeEncodeError
          On Unicode encoding error.
        • UnicodeTranslateError
          On Unicode translation error.
  • StopIteration
    Raised by an iterator's next() method to signal that there are no further values.
  • SystemExit
    Moved under BaseException.
  • Warning
    Base class for warnings (see module warning)
    • DeprecationWarning
      Warning about deprecated code.
    • FutureWarning
      Warning about a construct that will change semantically in the future.
    • ImportWarning
      Warning about probable mistake in module import (e.g. missing __init__.py).
    • OverflowWarning
      Warning about numeric overflow. Won't exist in Python 2.5.
    • PendingDeprecationWarning
      Warning about future deprecated code.
    • RuntimeWarning
      Warning about dubious runtime behavior.
    • SyntaxWarning
      Warning about dubious syntax.
    • UnicodeWarning
      When attempting to compare a Unicode string and an 8-bit string that can't be converted to Unicode using default ASCII encoding (raised a UnicodeDecodeError before 2.5).
    • UserWarning
      Warning generated by user code.

Standard methods & operators redefinition in classes

class C:
    def __init__(self, v): self.value = v
    def __add__(self, r): return self.value + r

a = C(3) # sort of like calling C.__init__(a, 3)
a + 4    # is equivalent to a.__add__(4)

Operators

See list in the operator module. Operator function names are provided with 2 variants, with or without leading & trailing '__' (e.g. __add__ or add).

• a + 3  calls __add__(a, 3)
• 3 + a  calls __radd__(a, 3)

Special informative state attributes for some types:

Important Modules

sys

os

posix

posixpath

shutil

time

string

As of Python 2.0, much (though not all) of the functionality provided by the string module have been superseded by built-in string methods.
Since 2.5 (?) all string module methods are considered deprecated => use built-in string methods instead.