20102012 - Laurent Pointal Abrg v1.3.0 - English Python 3.

2 Reference Card Licence Creative Commons Attribution 2 Cheat Sheet Symbols sample(pop,k) Bits Manipulations optional instructions , repeatable instructions, immutable data, ordered container ( non (with integers) a<<b a>>b a&b a|b a^b ordered), constant, variable, type, function & String .method, parameter, [,optional parameter], Escape : \ keyword, literal, module, file. \\ \ \' ' \" " Introspection & Help \n new line \t tab help([objet or "subject"]) \N{name} unicode name id(objet) dir([object]) vars([object]) \xhh hh hexa \0oo oo octal locals() globals() \uhhhh et \Uhhhhhhhh unicode hexa hhhh Qualified Access prefix r, disable \ : r"\n" \n Separator . between a namespace and a name in Formating : "{model}".format(data) that space. Namespaces : object, class, function, "{} {}".format(3,2) "{1} {0} {0}".format(3,9) module, package. Examples : "{x} {y}".format(y=2,x=5) math.sin(math.pi) f.__doc__ "{0!r} {0!s}".format("text\n") MyClasse.nbObjects() "{0:b}{0:o}{0}{0:x}".format(100) "{0:0.2f}{0:0.3g}{0:.1e}".format(1.45) point.x rectangle.width() Operations Base Types s*n (repeat) s1+s2 (concatenate) *= += undefined : None .split([sep[,n]]) .join(iterable) Boolean : bool True / False .splitlines([keepend]) .partition(sep) bool(x) False if x nul or empty .replace(old,new[,n]) .find(s[, start[,end]]) Integer : int 0 165 -57 .count(s[, start[,end]]) .index(s[, binary:0b101 octal:0o700 hexa:0xf3e start[,end]]) .isdigit() & Co .lower() int(x[,base]) .bit_length() .upper() .strip([chars]) Floating : float 0.0 -13.2e-4 .startswith(s[,start[,end]]) float(x) .as_integer_ratio() .endsswith(s[,start[,end]]) Complex : complex 0j -1.2e4+9.4j .encode([enc[, err]]) complex(re[,img]) .real .imag ord(c) chr(i) .conjugate() Conditional Expression String : str '' 'toto' "toto" """multiline toto""" Evaluated as a value. str(x) repr(x) expr1 if condition else expr2 Identifiers, Variables & Assignment Flow Control Identifiers : [a-zA-Z_] followed by or one or statements blocs delimited by indentation (idem multiple [a-zA-Z0-9_], accent and non-latin functions, classes, methods). Convention 4 alphabetical chars allowed (but should be spaces - tune editor. avoided). Alternative If name = expression if condition1: name1,name2,nameN = sequence # block executed if condition1 is true

Summary necessarily incomplete to keep on one paper sheet, see http://docs.python.org/py3k.

Managed Context with managed() as v :

ArithmeticError - ZeroDivisionError IndexError - KeyError - AttributeError - IOError - ImportError - NameError SyntaxError - TypeError NotImplementedError

# Block executed in a managed context Function Definition and Call def fname(x,y=4,*args,**kwargs): # function block or, if no code, pass return ret_expression

x: simple parameter y: parameter with default value args: variable parameters by order (tuple) kwargs: named variable parameters (dict) ret_expression: tuple return multiple values Call res = fname(expr,param=expr,*tuple,**dict) Anonymous Functions lambda x,y: expression
Sequences & Indexation

for any direct access ordered container. ith Item : x[i] Slice : x[start:end] x[start:end:step] i, start, end, step integers positive or negative start/end missing up to start/end x[i] x x[st:end]
0 -6 -6 0 1 -5 -5 1 2 -4 -4 2 3 -3 -3 3 4 -2 -2 4 5 -1 -1 5 6

Modification (if sequence is modifiable) x[i]=expression x[start:end]=iterable del x[i] del x[start:end]
Containers & Iterables

sequence containing N items name1 = name2 = nameX = expression unpacking sequence: first,*remain=sequence increment : name=name+expression augmented assignment : name+=expression (with other operators too) deletion : del nom
Identifiers Conventions

Details in PEP 8 Style Guide for Python

A_CONSTANT uppercase alocalvar lowercase without _ a_global_var lowercase with _ a_function lowercase with _ a_method lowercase with _ AClass title AnExceptionError title with Error at end amodule lowercase rather without _ apackage lowercase rather without _ Avoid l O I (l min, o maj, i maj) alone. _xxx internal usage __xxx modified _Class__xxx __xxx__ spcial reserved name Logical Operations a<b a<=b a>=b a>b a=ba==b aba!=b not a a and b a or b (expr) combined : 12<x<=34 Maths -a a+b a-b a*b a/b aba**b (expr) euclidian division a=b.q+r q=a//b et r=a%b et q,r=divmod(a,b) |x|abs(x) xy%zpow(x,y[,z]) round(x[,n]) following functions/data in module math e pi ceil(x) floor(x) trunc(x) exexp(x) log(x) sqrt(x) cos(x) sin(x) tan(x) acos(x) asin(x) atan(x) atan2(x,y) hypot(x,y) cosh(x) sinh(x) following functions in module random seed([x]) random() randint(a,b) randrange([start],end[,step]) uniform(a,b) choice(seq) shuffle(x[,rnd])

An iterable provide values one after the other. Ex : elif condition2: containers, dictionary views, iterable objets, generator functions # block executed if condition2 is true else: Generators (calculate values when needed) # block executed if all conditions are false range([start,]end[,step]) Loop Over Sequence ( expr for var in iter if cond ) for var in iterable: Generic Operations # block executed with var being successively v in containeur v not in containeur # each of the values in iterable len(containeur) enumerate(iter[,start]) else: iter(o[,sent]) all(iter) any(iter) # executed after, except if exit for loop by break filter(fct,iter) map(fct,iter,) var with multiple variables : for x,y,z in max(iter) min(iter) sum(iter[,start]) var index,valuer : for i,v in enumerate() reversed(seq) sorted(iter[,k][,rev]) On sequences : .count(x) .index(x[,i[,j]]) iterable : see Containers & Iterables String : (sequence of chars) Loop While cf. types bytes, bytearray, memoryview to while condition: directly manipulate bytes (+notation # block executed while condition is true b"bytes"). else: List : list [] [1,'toto',3.14] # executed after, except if exit while loop by list(iterable) .append(x) break .extend(iterable) .insert(i,x) .pop([i]) Loop Break : break .remove(x) .reverse() .sort() Immediate exit of the loop, without going through else [ expr for var in iter if cond ] block. Tuple : tuple () (9,'x',36) (1,) Loop Jump : continue tuple(iterable) 9,'x',36 1, Immediate jump at loop start with next iteration. Errors Processing: Exceptions Set : set {1,'toto',42} try: set(iterable) frozenset(iterable) # block executed in normal case .add(x) .remove(x) .discard(x) .copy() .clear() .pop() except exc as e: |, &, diff-, sym.diff^, < # block executed if an error of type exc is |= &= -= ^= detected Dictionnary (associative array, map) : dict else:
# block executed in case of normal exit from try finally: # block executed in all case exc for n types : except (exc1,exc2,excn) as e optional, fetch exception {} {1:'one',2:'two'} dict(iterable) dict(a=2,b=4) dict.fromkeys(seq[,val]) d[k]=expr d[k] del d[k] .update(iter) .keys() .values() .items() .pop(k[,def]) .popitem() .get(k[,def]) .setdefault(k[,def]) .clear() .copy() items, keys, values iterable views.

detect specific exceptions (ex. ValueError) and not generic ones (ex. Exception). Raising Exeptions (error situation) raise exc([args]) raise propagate exception Some exception classes : Exception -

Input/Output & Files print("x=",x[,y][,sep=][,end=][,file=]) input("Age ? ") str explicit cast to int or float if needed. File : f=open(name[,mode][,encoding=]) mode : 'r' read (default) 'w' write 'a' append '+' read write 'b' binary mode encoding : 'utf-8' 'latin1' 'ascii' .write(s) .read([n]) .readline() .flush() .close() .readlines() Loop in lines :for line in f : Managed context (close) : with open() as f: in module os (see also os.path): getcwd() chdir(path) listdir(path) Command line parameters in sys.argv Modules & Packages Module : script file extension .py (and C compiled modules). File toto.py module toto. Package : directory with file __init__.py. Contains

def __bool__(self): # return a boolean def __format__(self,format_spec): # return a string following specified format Special Comparison Mehods Return True, False or NotImplemented. x<y def __lt__(self,y): x<=y def __le__(self,y): x==y def __eq__(self,y): x!=y def __ne__(self,y): x>y def __gt__(self,y): x>=y def __ge__(self,y): Special Operations Methods

obj self

def __getattr__(self,name): # called if name not found as existing attribute def __getattribute__(self,name): # called in all case of name access. def __setattr__(self,name,valeur): def __delattr__(self,name): def __dir__(self): # return a list Accessors class C(object): def getx(self): def setx(self,value): def delx(self): x = property(getx,setx,delx,"docx") # Simpler, accessor to y, with decorators @property def y(self): # read """docy""" @y.setter def y(self,valeur): # modification @y.deleter def y(self): # deletion

Property

Return a new object of the class, containing the operation result, or NotImplemented if cannot work with given y argument. x self x+y def __add__(self,y): x-y def __sub__(self,y): module files. x*y def __mul__(self,y): Searched in the PYTHONPATH, see sys.path list. x/y def __truediv__(self,y): Module Sample : x//y def __floordiv__(self,y): #!/usr/bin/python3 x%y def __mod__(self,y): # -*- coding: utf-8 -*divmod(x,y) def __divmod__(self,y): """Module documentation - cf PEP257""" # File: mymodule.py x**y def __pow__(self,y): # Author: Joe Student pow(x,y,z) def __pow__(self,y,z): # Import other modules, functions x<<y def __lshift__(self,y): import math from random import seed,uniform x>>y def __rshift__(self,y): # Definition of constants and globals x&y def __and__(self,y): MAXIMUM = 4 x|y def __or__(self,y): lstFiles = [] # Definition of functions and classes x^y def __xor__(self,y): def f(x): -x def __neg__(self): """Function documentation""" +x def __pos__(self): class Converter(object): abs(x) def __abs__(self): """Class documentation""" ~x def __invert__(self): nb_conv = 0 # class var def __init__(self,a,b): Following methods called after, on y if x don't """init documentation""" support required operation. self.v_a = a # instance var y self x+y def __radd__(self,x): def action(self,y): """Method documentation""" x-y def __rsub__(self,x): x*y def __rmul__(self,x): # Module auto-test x/y def __rtruediv__(self,x): if __name__ == '__main__': if f(2) != 4: # problem x//y def __rfloordiv__(self,x): x%y def __rmod__(self,x): Modules / Names Imports divmod(x,y) def __rdivmod__(self,x): import mymondule x**y def __rpow__(self,x): from mymodule import f,MAXIMUM x<<y def __rlshift__(self,x): from mymodule import * from mymodule import f as fct x>>y def __rrshift__(self,x): To limit * effect, define in mymodule : x&y def __rand__(self,x): __all__ = [ "f", "MAXIMUM"] x|y def __ror__(self,x): Import via package : x^y def __rxor__(self,x) :
from os.path import dirname Class Definition Special methods, reserved names __xxxx__. class ClassName([superclass]): # class block class_variable = expression def __init__(self[,params]): # initialization block self.instance_variable = expression def __del__(self): # destruction block @staticmethod # @decorator def fct([,params]): # static method (callable without object) Special Augmented Assignment Methods

Descriptors Protocol o.x def __get__(self,o,classe_de_o): o.x=v def __set__(self,o,v): del o.x def __delete__(self,o):
Special Function Call Method

Use an object as if it was a function (callable) : o(params) def __call__(self[,params]):

For efficient storage in dict and set. hash(o) def __hash__(self): Define to None if object not hashable.

Special Container Methods

o self len(o) def __len__(self): o[key] def __getitem__(self,key): o[key]=v def __setitem__(self,key,v): del o[key] def __delitem__(self,key): for i in o: def __iter__(self):

Membership Tests isinstance(obj,class) isssubclass(subclass,parentclass)

Modify self object on which they are applied. x self x+=y def __iadd__(self,y): x-=y def __isub__(self,y): x*=y def __imul__(self,y): x/=y def __itruediv__(self,y): x//=y def __ifloordiv__(self,y): x%=y def __imod__(self,y): x**=y def __ipow__(self,y): x<<=y def __ilshift__(self,y): x>>=y def __irshift__(self,y): x&=y def __iand__(self,y): x|=y def __ior__(self,y): x^=y def __ixor__(self,y):

Special Numerical Conversion Methods

Use the class as a function, parameters are passed to constructor __init__. obj = ClasseName(params)
Special Conversion Methods def __str__(self): # return display string def __repr__(self): # return representation string def __bytes__(self): # return bytes string object

Return the converted value. x self complex(x) def __complex__(self,x): int(x) def __int__(self,x): float(x) def __float__(self,x): round(x,n) def __round__(self,x,n): def __index__(self):
# return an int usable as index Special Attribute Access Methods Access with obj.name. Exception AttributeError if attribute not found.

# return a new iterator on the container reversed(o) def __reversed__(self): x in o def __contains__(self,x): For notation [start:end:step], a slice object is given to container methods as value for key parameter. Slice: slice(start,end,step) .start .stop .step .indices(lentgh) Special Iterator Methods def __iter__(self):# return self def __next__(self):# return next item If no more item, raise exception StopIteration. Special Managed Context Methods Used for with statement. def __enter__(self): # called at entry in the managed context # return value used for context' as variable def __exit__(self,etype,eval,tb): # called at exit of managed context Special Metaclass Methods __prepare__ = callable def __new__(cls[,params]): # allocation and return a new cls object isinstance(o,cls) def __instancecheck__(cls,o): isssubclass(subclass,cls) def __subclasscheck__(cls,subclass): Generators Calculate values when needed (ex.: range). Generator functions, contains a statement yield. yield expression yield from squence variable = (yield expression) transmission of

values to the generator. If no more item, raise exception StopIteration. Generator Function Control generator.__next__() generator.send(value) generator.throw(type[,value[,traceback]]) generator.close()