Numbers -------integers are represented as longs and can be as wide as we need 'em to be // is a flooring division / floors for 2 integers only

, otherwise the result is a float (in python 2.5) Lambda -------no statements, just expressions is a closure, access to all variables from context within which it is created Strings -------'lite"ral' "liter'al" u'unicode string' u"unicode string" r'raw one' r"raw too" no difference between ' and " You can use sprintf style strings : "\u%0.4i" % num Files --------use the built-in open('file','mode') modes (a 'b' can be added for binary mode on Windows): r rU r+ w a Modules and packages --------PYTHONPATH can be used to play with the search path .pth files too the search path is in sys.path and can be modified at runtime loaded modules are in sys.modules from modulename import *|name #imports in current namespace and copies all the non-mutable objects by-value import happen only once, unless you use 'reload' - reload is a function not a statement and is not recursive import dir1.dir2.file dir1 __init__ dir2 __init__ file #package import (init files are read from first to last)

you can prepend top level attributes with a _ to prevent them from being imported by a import * mod alternatively, __all__ can also be a list containing the attributes to be imported by an import * To programmatically import a module:

OR

>>> modname = "string" >>> exec "import " + modname >>> modname = "string" >>> string = __import__(modname)

Don't use from in recursive imports reload may not impact from import Buil-in functions --------map (like blocks) >>> map((lambda x: x + 3), counters) # Function expression [4, 5, 6, 7] or >>> map(pow, [1, 2, 3], [2, 3, 4]) # 1**2, 2**3, 3**4 [1, 8, 81] reduce (like inject) >>> reduce((lambda x, y: x + y), [1, 2, 3, 4]) 10 filter (like reject) >>> filter((lambda x: x > 0), range(-5, 5)) [1, 2, 3, 4] iter(list|dic) #returns an iterator on the argument Classes and OOP --------class A(Superclass1,Superclass2): pass assigning to an object's attribute always changes that object, and no other (lookups go through inheritance tree, not assignments) class assignments are made at the top level of a class def, without any keyword or 'self' instance variables are assigned in __init__ using self.XXX to call the superclass' constructor, use the name of the parent.__init__(), otherwise, the constructor replaces the parent's instances have a __class__ attribute containing a reference to their class classes have a __bases__ tuple containing their parents assigning to an object's attribute always changes that object, and no other changing a class variable through an instance does not change the class variable, but rather assigns a new property to the instance you cant overload methods in Python, the last definition will be the one used if you do so you can use built-in getattr to get an attribute from an object, and you can use apply to call it you can mangle names by prepending __ to their names. But it prevents children from accessing the variable too (multiple inheritance SOL). __new__ ? __metaclass__ ? new style classes inherit frmo built-ins or 'object': class newstyle(object): ...normal code... new style classes do a breadth-first search on attribute names instead of a depth

first search for classic classes. You can of course reassign attributes explicitly to avoid conflicts new style classes can have __slots__ attribute that lists all the possible attributes of the class class limiter(object): __slots__ = ['age', 'name', 'job'] in new style, you can also use the built-in property to create accessors a la Ruby new style classes can overload __getattribute__ which intercepts ALL attribute references does __getattr__ intercept all refs? Python did not have class methods or static methods before 2.2. Now you can call the builtin staticmethod or classmethod like this: class Multi: def imeth(self, x): # Normal instance method print self, x def smeth(x): # Static: no instance passed print x def cmeth(cls, x): # Class: gets class, not instance print cls, x smeth = staticmethod(smeth) # Make smeth a static method. cmeth = classmethod(cmeth) # Make cmeth a class method. You redefine the name to a static/class method.. Static methods do not take a magic first parameter, class methods take the class object as their first parameter Method Overloads Called for __init__ Constructor Object creation: Class( ) __del__ Destructor Object reclamation __add__ Operator '+' X + Y, X += Y __or__ Operator '|' (bitwise or) X | Y, X |= Y __repr__,__str__ Printing, conversions print X, `X`, str(X) __call__ Function calls X( ) __getattr__ Qualification X.undefined __setattr__ Attribute assignment X.any = value __getitem__ Indexing X[key], for loops, in tests __setitem__ Index assignment

X[key] = value __len__ Length len(X), truth tests __cmp__ Comparison X == Y, X < Y __lt__ Specific comparison X < Y (or else __cmp__) __eq__ Specific comparison X == Y (or else __cmp__) __radd__ Right-side operator '+' Noninstance + X __iadd__ In-place (augmented) addition X += Y (or else __add__) __iter__ Iteration contexts for loops,in tests, others Use __iter__ like this: class Squares: def __init__(self, start, stop): self.value = start - 1 self.stop = stop def __iter__(self): # Get iterator object return self def next(self): # on each for iteration. if self.value == self.stop: raise StopIteration self.value += 1 return self.value ** 2 #prints out all the squares: 1 4 9 16.. Decorators --------on decorators: A function definition may be wrapped by one or more decorator expressions. Decorator expressions are evaluated when the function is defined, in the scope that contains the function definition. The result must be a callable, which is invoked with the function object as the only argument. The returned value is bound to the function name instead of the function object. Multiple decorators are applied in nested fashion. For example, the following code: @f1(arg) @f2 def func(): pass is equivalent to: def func(): pass func = f1(arg)(f2(func)) Exceptions

--------inherit from Exception and override __repr__ to provide a meaningful string for exceptions classes raise string # Matches except with same string object raise string, data # Pass optional extra data (default=None). raise instance # Same as: raise instance.__class__ instance. raise class, instance # Matches except with this class or its superclass raise # Reraise the current exception use that form if you need the exception object in except block except Exception, exc: print exc.message Notes --------you can curry (or uncurry?) arguments with the * marker, and kwargs with ** default argument are kept and reused between function calls

if you assign to a global var in a function, the variable will be local everywhere within the function (sic) Only 0, empty built-ins, False and None are false Dictionaries can't have lists as keys (keys need to be hashable) list tricks: >>> L = [4, 5, 6] >>> X = L * 4 # Like [4, 5, 6] + [4, 5, 6] + ... >>> Y = [L] * 4 # [L] + [L] + ... = [L, L,...] >>> X [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6] >>> Y [[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]] #Because L was nested in the second repetition, Y winds up embedding references back to the original list assigned to L, and is open to the same sorts of side effects noted in the last section: >>> L[1] = 0 # Impacts Y but not X >>> X [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6] >>> Y [[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]] swap without a tmp var: nudge, wink = wink, nudge

for most for loops, you can append an else block that is executed unless the loop ended with a break

default argument are kept and reused

between function calls

if you assign to a global var in a function, the variable will be local everywhere within the function (sic) Only 0, empty built-ins, False and None are false

Dictionaries can't have lists as keys (keys need to be hashable) list gotcha: >>> L = [4, 5, 6] >>> X = L * 4 # Like [4, 5, 6] + [4, 5, 6] + ... >>> Y = [L] * 4 # [L] + [L] + ... = [L, L,...] >>> X [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6] >>> Y [[4, 5, 6], [4, 5, 6], [4, 5, 6], [4, 5, 6]] #Because L was nested in the second repetition, Y winds up embedding references back to the original list assigned to L, and is open to the same sorts of side effects noted in the last section: >>> L[1] = 0 # Impacts Y but not X >>> X [4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6] >>> Y [[4, 0, 6], [4, 0, 6], [4, 0, 6], [4, 0, 6]] swap without a tmp var: nudge, wink = wink, nudge

for most for loops, you can append an else block that is executed unless the loop ended with a break

Master your semester with Scribd & The New York Times

Special offer for students: Only $4.99/month.

Master your semester with Scribd & The New York Times

Cancel anytime.