diff options
| author | Andrew M. Kuchling <amk@amk.ca> | 2001-08-06 17:43:49 (GMT) |
|---|---|---|
| committer | Andrew M. Kuchling <amk@amk.ca> | 2001-08-06 17:43:49 (GMT) |
| commit | 13423f337ddcd71394a76b00ee55c3aa55365e93 (patch) | |
| tree | e353bbe0de4be8aeed8076ef3bfec43748aa0896 | |
| parent | 7b1262230ce8671283c4bf6b248ac254b08a89f1 (diff) | |
| download | cpython-13423f337ddcd71394a76b00ee55c3aa55365e93.zip cpython-13423f337ddcd71394a76b00ee55c3aa55365e93.tar.gz cpython-13423f337ddcd71394a76b00ee55c3aa55365e93.tar.bz2 | |
Update cheatsheet to 2.0 from Brunning/Gruet's quick reference
| -rw-r--r-- | Misc/cheatsheet | 2747 |
1 files changed, 2212 insertions, 535 deletions
diff --git a/Misc/cheatsheet b/Misc/cheatsheet index 204b51b..a4d96e2 100644 --- a/Misc/cheatsheet +++ b/Misc/cheatsheet @@ -1,541 +1,2218 @@ - A Python Bestiary - Itemizing Python Objects and Nuances - - $Revision$ $Date$ ken.manheimer@nist.gov - - Notable lexical entities - ======================== - - Keywords - - access and break class - continue def del elif - else except exec finally - for from global if - import in is lambda - not or pass print - raise return try while + Python 2.0 Quick Reference + + + + 16 May 2001 upgraded by Richard Gruet and Simon Brunning for Python 2.0 + 2000/07/18 upgraded by Richard Gruet, rgruet@intraware.com for Python 1.5.2 +from V1.3 ref +1995/10/30, by Chris Hoffmann, choffman@vicorp.com + +Based on: + Python Bestiary, Author: Ken Manheimer, ken.manheimer@nist.gov + Python manuals, Authors: Guido van Rossum and Fred Drake + What's new in Python 2.0, Authors: A.M. Kuchling and Moshe Zadka + python-mode.el, Author: Tim Peters, tim_one@email.msn.com + + and the readers of comp.lang.python + +Python's nest: http://www.python.org Developement: http:// +python.sourceforge.net/ ActivePython : http://www.ActiveState.com/ASPN/ +Python/ +newsgroup: comp.lang.python Help desk: help@python.org +Resources: http://starship.python.net/ and http://www.vex.net/parnassus/ +Full documentation: http://www.python.org/doc/ +An excellent Python reference book: Python Essential Reference by David Beazley +(New Riders) + + +Contents + + * Invocation Options + * Environment Variables + * Lexical Entities : keywords, identifiers, strings, numbers, sequences, + dictionaries, operators + * Basic Types And Their Operations + * Advanced Types + * Statements + * 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, getopt + * List of modules In base distribution + * Workspace Exploration And Idiom Hints + * Python Mode for Emacs + * The Python Debugger + + + +Invocation Options + +python [-diOStuUvxX?] [-c command | script | - ] [args] + + Invocation Options +Option Effect +-d Outputs parser debugging information (also PYTHONDEBUG=x) +-i Inspect interactively after running script (also PYTHONINSPECT=x) and + force prompts, even if stdin appears not to be a terminal +-O Optimize generated bytecode (set __debug__ = 0 =>s suppresses asserts) +-S Don't perform 'import site' on initialization +-t Issue warnings about inconsistent tab usage (-tt: issue errors) +-u Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x). +-U Force Python to interpret all string literals as Unicode literals. +-v Verbose (trace import statements) (also PYTHONVERBOSE=x) +-x Skip first line of source, allowing use of non-unix Forms of #!cmd +[DEL:-X [DEL:Disable class based built-in exceptions (for backward +:DEL] compatibility management of exceptions):DEL] +-? Help! +-c Specify the command to execute (see next section). This terminates the +command option list (following options are passed as arguments to the command). + the name of a python file (.py) to execute read from stdin. +script Anything afterward is passed as options to python script or command, + not interpreted as an option to interpreter itself. +args passed to script or command (in sys.argv[1:]) + If no script or command, Python enters interactive mode. + + * Available IDEs in std distrib: IDLE (tkinter based, portable), Pythonwin + (Windows). + + + +Environment variables + + Environment variables + Variable Effect +PYTHONHOME Alternate prefix directory (or prefix;exec_prefix). The + default module search path uses prefix/lib + Augments the default search path for module files. The format + is the same as the shell's $PATH: one or more directory + pathnames separated by ':' or ';' without spaces around + (semi-)colons! +PYTHONPATH On Windows first search for Registry key HKEY_LOCAL_MACHINE\ + Software\Python\PythonCore\x.y\PythonPath (default value). You + may also define a key named after your application with a + default string value giving the root directory path of your + app. + If this is the name of a readable file, the Python commands in +PYTHONSTARTUP that file are executed before the first prompt is displayed in + interactive mode (no default). +PYTHONDEBUG If non-empty, same as -d option +PYTHONINSPECT If non-empty, same as -i option +PYTHONSUPPRESS If non-empty, same as -s option +PYTHONUNBUFFERED If non-empty, same as -u option +PYTHONVERBOSE If non-empty, same as -v option +PYTHONCASEOK If non-empty, ignore case in file/module names (imports) + + + + +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 + def finally in print + + * (list of keywords in std module: keyword) + * Illegitimate Tokens (only valid in strings): @ $ ? + * 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) + +Strings + + "a string enclosed by double quotes" + 'another string delimited by single quotes and with a " inside' + '''a string containing embedded newlines and quote (') marks, can be + delimited with triple quotes.''' + """ may also use 3- double quotes as delimiters """ + u'a unicode string' U"Another unicode string" + r'a raw string where \ are kept (literalized): handy for regular + expressions and windows paths!' + R"another raw string" -- raw strings cannot end with a \ + ur'a unicode raw string' UR"another raw unicode" + + 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) String Literal Escapes \newline Ignored (escape newline) - \\ Backslash (\) \e Escape (ESC) \v Vertical Tab (VT) - \' Single quote (') \f Formfeed (FF) \0XX char with - \" Double quote (") \n Linefeed (LF) octal value XX - \a Bell (BEL) \r Carriage Return (CR) \xXX char with - \b Backspace (BS) \t Horizontal Tab (TAB) hex value XX - - Illegitimate Tokens (only valid in strings): @ $ ? - - Operating environment (Unix) - - Shell environment vars: - - PYTHONPATH: dirs to be prepended to module search path; a la shell PATH - PYTHONSTARTUP: names path of file to be loaded on interactive startup - - Internal (module sys) vars ('import sys' to refer to them): - - argv - list of command and arguments passed to python script - builtin_module_names - list of names of modules compiled in to python - ( exc_* values are set only during handling of a raised exception) - exc_type - type of exception being handled - exc_value - exception's parameter ('raise's 2nd arg) - exc_traceback - exception's traceback obj - exit(N) - exit from python with status N, by raising SystemExit - exitfunc - function hook, to be called on exit if set - last_type - type of last unhandled exception - last_value - value of last unhandled exception - last_traceback - traceback of last unhandled exception - modules - list of modules already loaded - path - list of strings specifying module-load search path - ps1='>>>' - string specifying primary prompt, iff interactive - ps2='...' - string specifying secondary prompt, iff interactive - settrace - system trace function, used by debuggers, etc - setprofile - system profile function - stdin - standard input file object - stdout - standard output file object - stderr - standard error file object - tracebacklimit=1000 - maximum number of traceback levels to print - - - Objects - behaviors, special attributes, operations, statements, etc - ==================================================================== - - General object aspects - - Boolean values and operators - - False values: None, numeric zeros, empty sequences and mappings - True values: all other values - - not X: if X is false then 1, else 0 - ( 'or', 'and' evaluate second arg only if necessary to determine outcome) - X or Y: if X is false then Y, else X - X and Y: if X is false then X, else Y - - Special methods for any type (s: self) - - id(obj) unique identifier for object (currently, its address) - __init__(s, args) object instantiation - see Classes, below - __del__(s) object demise - __repr__(s) repr() and `...` conversions - __str__(s) str() and 'print' statement - __cmp__(s) implements <, ==, >, <=, <>, !=, >=, is [not] - __hash__(s) hash() and dictionary operations - - Special informative state attributes for some types: - - X.__dict__ dict used to store object's writeable attributes - X.__methods__ list of X's methods; on many built-in types. - X.__members__ lists of X's data attributes - X.__class__ class to which X belongs - X.__bases__ tuple of X base classes - - General Name Space behavior and binding - - Name space search order: local, global, builtin - - "global" name space = file = module - "local" name space = function or method - - Code Block scopes (ns = name space, cb = containing block) - - ( global ns generally is containing module, unless overriden by args) - - Code block type Local ns Notes - --------------- -------- ----- - Module same as global ns - Script same as global ns global ns is __main__ - Interactive cmd same as global ns global ns is __main__ - Class def new ns - Function body new ns - 'exec' string local ns of cb (or args) - 'eval' string local ns of caller (or args) - 'execfile' file local ns of caller (or args) - 'input' expr local ns of caller - - Binding operations and exceptions: - - ~ SyntaxError: on attempt to bind to literals or other non-bindables - ~ NameError: on attempt to evaluate unbound atom - - ( for object attribute functions, obj: object, nm: string, val: any value) - getattr(obj, nm) get value of obj.nm - hasattr(obj, nm) true if obj has nm attribute - setattr(obj, nm, val) set obj.nm to val - - assignment statement: targ1, targ2, ,,, = obj1, obj2, ,,, - deletion statement: del obj1, obj2, ... - for loop target identifiers, 'except' clauses (see Statements, below) - formal params (see Callables, below) - import statement (see Modules objects, below) - class and func defs (see Callables, below) - - Name space linkage - - global statement: global var, ... # Interpret 'var's as globals - X access statement: access ... # control inst and class vars access - - @ Built-in Exceptions - - AttributeError On attribute reference or assignment failure - EOFError Immediate end-of-file hit by input() or raw_input() - IOError I/O-related I/O operation failure - ImportError On failure of `import' to find module or name - IndexError On out-of-range sequence subscript - KeyError On reference to a non-existent mapping (dict) key - KeyboardInterrupt On user entry of the interrupt key (often `Control-C') - MemoryError On recoverable memory exhaustion - NameError On failure to find a local or global (unqualified) name - OverflowError On excessively large arithmetic operation - RuntimeError Obsolete catch-all; define a suitable error instead - SyntaxError On parser encountering a syntax error - SystemError On non-fatal interpreter error - bug - report it - SystemExit On `sys.exit()' - TypeError On passing inappropriate type to built-in op or func - ValueError On arg error not covered by TypeError or more precise - ZeroDivisionError On division or modulo operation with 0 as 2nd arg - - **** Numbers **** - - @ Integers: 'C' long, >= 32 bits precision; OverflowError if bounds exceeded - @ Long Integers: unlimited precision - '2147483648L' - @ Floating point: machine double-precision floating point - '2147483648.0' - - Numeric operations vs special methods (s = self, o = other) - - s+o = __add__(s,o) s-o = __sub__(s,o) - s*o = __mul__(s,o) s/o = __div__(s,o) - s%o = __mod__(s,o) divmod(s,o) = __divmod__(s,o) - pow(s,o) = __pow__(s,o) - s&o = __and__(s,o) - s^o = __xor__(s,o) s|o = __xor__(s,o) - s<<o = __lshift__(s,o) s>>o = __rshift__(s,o) - nonzero(s) = __nonzero__(s) coerce(s,o) = __coerce__(s,o) - -s = __neg__(s) +s = __pos__(s) - abs(s) = __abs__(s) ~s = __invert__(s) (bitwise) - int(s) = __int__(s) long(s) = __long__(s) - float(s) = __float__(s) - oct(s) = __oct__(s) hex(s) = __hex__(s) - - Numeric functions: - - range(start=0,end,step=1) create arithmetic progression list - round(x, n=0) round floating point x to n decimal places - xrange(start=0,end,step=1) create virtual arithmetic progressions tuple - - Numeric exceptions: - - ~ TypeError: raised on application of arithemetic opertion to non-number - ~ OverflowError: numeric bounds exceeded - ~ ZeroDivisionError: raised when zero second argument of div or modulo op - - **** Collections - Sequences and Mappings **** - - Collections general operations vs methods (s: self, i: index or key) - - len(s) = __len__(s) length of object, >= 0. Length 0 == false - s[i] = __getitem__(s,i) Element at index/key i, origin 0 - - Sequences - - @ String (immutable sequence): 'string contents' - - 'this is a string' - "and so is this" - ''' and this begins a 'multi-line' string with embedded quotes... - and this is the end of that string.''' - - `expr` = __repr__(expr), converts arbitrary expr to string - chr(int) string of ascii letter at ordinate in (0 <= int < 256) - ord(string) ascii ordinate of string (string must be length 1) - string % arg format operator, a la C sprintf - arg for single directive can be any (suitable) type - arg for multiple directives must be tuple or dict - dict (mapping) arg uses parenthesized directives that are keys into it - supports %, c, s, i, d, u, o, x, X, e, E, f, g, G directives - * can be width and precision; directs use of corresponding (int) args - * can not be used with dict args - flag characters -, +, blank, #, and 0 understood. - %s conversion takes any python object, converts using `str()' - ANSI directives %p and %n not supported - %s conversions do *not* take \000 as end of string - - @ Tuples (immutable sequence): (oneelem, another, etc) - - parens may be left off all but empty tuples - singletons represented by affixing a comma to an expr - empty tuple represented using empty parens - - @ Lists (mutable sequence): [oneelem, another, etc] - - assignment - must be 1-1 map of items in target and object sequences - deletion - similar rules as for assignment - - List special methods: see mutable sequence ops vs methods, below - - Sequences general ops vs methods (s: self, i,j: indices, v: val) - - All collections general methods, plus: - s[i:j] __getslice__(s,i,j), all s[k] s.t. i <= k < j - min(s) smallest item of s - max(s) largest item of s - v [not] in s 1 if v [not] equal to an item in s, else 0 - s + seq concatenation of s and seq - s * num num copies of s concatenated, also, `num * s' - - Immutable sequence ops vs methods (s: self, i,j: indices, v: val) - - All collections and sequences general methods, plus: - s[i:j] __getslice__(s,i,j), all s[k] s.t. i <= k < j - ( For s[i:j], len(self) is intrinsically added to i, j < 0) - ( Complex elems of immutable seqs may be mutable, see dictionaries, below) - - Mutable sequence ops vs methods (s: self, i,j: indices, v: val) - - All sequences' general methods, plus: - ( for non-slice refs, i < 0 intrinsically has len(s) added) - ( For slice refs, len(s) *is not* intrinsically added to i, j < 0) - ( for assignment/deletion, index refs must point to existing items - s[i]=v = __setitem__(s,i,v) - del s[i] = __delitem__(s,i) - s[i:j] = __getslice__(s,i,j) - s[i:j]=seq = __setslice__(s,i,j,seq) - del s[i:j] = __delslice__(s,i,j) == s[i:j] = [] - s.append(seq) == `s[len(seq):len(seq)] = seq' (but faster) - s.count(v) number of i's for which `s[i] == v' - s.index(v) first i such that `s[i] == v', or IndexError if none - s.insert(i, v) == `s[i:i] = [v]' - s.remove(v) == `del s[s.index(v)]', or IndexError if v not in s - s.reverse() reverse the items of s in place - s.sort() permute s items so s[i] <= s[j], for i < j - - Mappings - - @ Dictionaries: {key1: val1, key2: val2, ...} - - built-in types as keys must be unalterable: obj & all contents immutable - User-defined classes as keys must have __hash__() and __cmp__() methods - ~ TypeError is raised if key not acceptable - ~ KeyError is raised if reference made using non-existent key - key types may vary (contrary to ref man) - - Dictionaries ops vs methods (s: self, k: key, v: val) - - all collections general ops, plus: - hash(s) = __hash__(s) - hash value for dictionary references - s[k]=v = __setitem__(s,k,v) - del s[k] = __delitem__(s,k) - s.items() = a list copy of s's (key, item) pairs - s.keys() = a list copy of s's keys - s.values() = a list copy of s's values - s.has_keys(k) = 1 if s has key k, else 0 - ( s.items, .keys, and .values yield random but mutually consistent order) - - **** Callables **** - - @ User defined functions: 'def name (param-list): suite' - - suite is not evaluated at statement execution, but at function invocation - function parameters, comma separated on param-list: - func_code: special attr, code object representing compiled function body - func_globals: special attr, ref to global dict of funcs definition module - func(arg-list) invocation - - @ User defined methods: like functions, with extra implicit arg - - Same as functions, but passed class instance as additional first argument - im_self: special attr, method's class instance object - im_func: special attr, function object - mthd(args) invocation, same as mthd.im_func(mthd.im_self, args) - - @ Classes: 'class name[ (inheritance)]: suite' - - inheritance list is evaluated, if any, to identify base classes for name - suite is executed in new local name space, which goes to the class object - class name is bound in encompassing local name space - container for dictionary containing class's ns dictionary - __dict__: ro attr, class ns as dictionary object - __bases__: ro attr, class' base classes in tuple - __init__(self, args..): implements object instantiation - __del__(self): implements impending object deletion - - @ Class instances - - __dict__: ro attr, class' attribute dictionary - __class__: ro attr, instance's class object - - Callables special method vs ops (f: function) - - apply(f, args-tuple) call f with args-tuple as arg list - compile(str, flnm, kind) compile string into exectuable code object - eval(str, glbls=, lcls=) evaluate string as expression (cond_list) - filter(f, seq) => seq of seq elems for which f is true - map(f, lst, [lst2, ...]) => list of f applied to succesive lsts elems - reduce(f, lst, initlzr) => value of f applied to elems and cume result - - @ **** Null object: `None' **** - - @ **** Type objects, print as: <type 'int'> **** - ( '<...>' form is only for printing - cannot be entered that way, - - accessed via built-in func 'type()' - ( equal only when identical (same id()), - so can't just use the string name, must use object with the same str val) - - @ **** Modules **** - - functions and methods in a module share module's ("global") namespace - function uses "global" statement to instantiate var in global context - Modules use "import" to incorp other module's names - see Name Spaces - - Special attrs, methods, and operations - - __dict__: attr, module's ns as dictionary; can modify vals but not sruct - __name__: ro attr, module's name as string - import Instantiate module or module components within another - reload(amod) Reread an imported module - - @ **** Files **** - - wrapper around a C stdio file pointer - sys.stdin, sys.stdout, sys.stderr are standard io-stream file objects - - File operations: - - open(nm, mode='r', bufsize=sysdef) return new file object - close() A closed file cannot be read or written anymore. - flush() Flush the internal buffer, like stdio's `fflush()'. - isatty() 1 if file connected to a tty(-like) device, else 0. - read(SIZE) Read up to SIZE bytes frm file, less on EOF or no data - readline() Read one entire line from the file. - readlines() `readline()' til EOF and return list of lines read. - seek(OFFSET,WHENCE) Set file's current position, like stdio's `fseek()' - tell() Return file's current position, like stdio's `ftell()'. - write(STR) Write a string to the file. There is no return value. - - File functions: - - input(prompt='') like raw input but accept '\' line continuations - print exp, exp2, ... Write values to stdout - raw_input(prompt='') prompt then read single line of input - - **** Internal types **** - - @ Code objects - represent exectuable code - function obj sans context - @ Frame objects - represent executable frames - may occur in traceback objs - @ Traceback objects - stack trace of an exception - - Control statements - ================== - - * Calls and Evaluation * - - ( See also Callables, in Objects section above, for ops and methods.) - - exec: exec expr [ in expr2 [, expr3]] # Dynamic execution of python code - return: return [expr] # Leave current func call with expr value - - * Conditionals and Loops * - ( See also Boolean values, above) - - break: break # Terminate nearest enclosing loop - continue: continue # Continue next cycle of enclosing loop - if: if cond: suite [\n elif cond: suite \n ...] [\n else: suite] - for: for targs in conds: suite [ \n else: suite ] - while: while cond: suite [ \n else : suite ] - - * Exceptions * - - raise: raise expr [, expr2] # Raise exception expr, passing expr2 if any - try... # Handle exceptions: - try: suite [\n except [cond [, targ]]: suite \n ... \n] [else: suite] - try: suite \n finally: suite # Specify a 'cleanup' handler - ( two 'try' forms cannot be mixed together) - - System modules - ============== - @ * Built-ins * - - sys Interpreter state (see Operating Environment, above) - __builtin__ Access to all built-in python identifiers - __main__ Scope of the interpreters main program, script or stdin - array Obj efficiently representing arrays of basic values - math Math functions of C standard - time Time-related functions - regex Regular expression matching operations - marshal Read and write some python values in binary format - strop Miscellaneous string operations - struct Convert between python values and C structs + \\ Backslash (\) \e Escape (ESC) \v Vertical Tab (VT) + \' Single quote (') \f Formfeed (FF) \OOO char with octal value OOO + \" Double quote (") \n Linefeed (LF) + \a Bell (BEL) \r Carriage Return (CR) \xHH char with hex value HH + \b Backspace (BS) \t Horizontal Tab (TAB) + \uHHHH unicode char with hex value HHHH, can only be used in unicode string + \UHHHHHHHH unicode char with hex value HHHHHHHH, can only be used in unicode string + \AnyOtherChar is left as-is + + * 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. + +Numbers + + Decimal integer: 1234, 1234567890546378940L (or l) + Octal integer: 0177, 0177777777777777777L (begin with a 0) + Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFFL (begin with 0x or 0X) + Long integer (unlimited precision): 1234567890123456L (ends with L or l) + 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) + +Sequences + + * String of length 0, 1, 2 (see above) + '', '1', "12", 'hello\n' + * Tuple of length 0, 1, 2, etc: + () (1,) (1,2) # parentheses are optional if len > 0 + * 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]. Start defaults to +'0'; End defaults to 'sequence-length'. + +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. + +Dictionaries (Mappings) + + Dictionary of length 0, 1, 2, etc: + {} {1 : 'first'} {1 : 'first', 'next': 'second'} + +Operators and their evaluation order + + Operators and their evaluation order +Highest Operator Comment + (...) [...] {...} `...` Tuple, list & dict. creation; string + conv. + s[i] s[i:j] s.attr f(...) indexing & slicing; attributes, fct + calls + +x, -x, ~x Unary operators + x**y Power + x*y x/y x%y mult, division, modulo + x+y x-y addition, substraction + x<<y x>>y Bit shifting + x&y Bitwise and + x^y Bitwise exclusive or + x|y Bitwise or + x<y x<=y x>y x>=y x==y x!=y Comparison, + x<>y identity, + x is y x is not y membership + x in s x not in s + not x boolean negation + x and y boolean and + x or y boolean or +Lowest lambda args: expr anonymous function + +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) + + Comparisons +Comparison Meaning Notes +< strictly less than (1) +<= less than or equal to +> strictly greater than +>= greater than or equal to +== equal to +!= or <> not equal to +is object identity (2) +is not negated object identity (2) + +Notes : + 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. + +Boolean values and operators + + Boolean values and operators + Value or Operator Returns Notes +None, numeric zeros, empty sequences and False +mappings +all other values True +not x True if x is False, else + True +x or y if x is False then y, else (1) + x +x and y if x is False then x, else (1) + y + +Notes : + 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. + +None + + None is used as default return value on functions. Built-in single object + with type NoneType. + Input that evaluates to None does not print when running Python + interactively. + +Numeric types + +Floats, integers and long integers. + + Floats are implemented with C doubles. + Integers are implemented with C longs. + Long integers have unlimited size (only limit is system resources) + +Operators on all numeric types + + Operators on all numeric types + Operation Result +abs(x) the absolute value of x +int(x) x converted to integer +long(x) x converted to long integer +float(x) x converted to floating point +-x x negated ++x x unchanged +x + y the sum of x and y +x - y difference of x and y +x * y product of x and y +x / y quotient of x and y +x % y remainder of x / y +divmod(x, y) the tuple (x/y, x%y) +x ** y x to the power y (the same as pow(x, y)) + +Bit operators on integers and long integers + + Bit operators +Operation >Result +~x the bits of x inverted +x ^ y bitwise exclusive or of x and y +x & y bitwise and of x and y +x | y bitwise or of x and y +x << n x shifted left by n bits +x >> n x shifted right by n bits + +Complex Numbers + + * 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) + + Operations on all sequence types +Operation Result Notes +x in s 1 if an item of s is equal to x, else 0 +x not in s 0 if an item of s is equal to x, else 1 +s + t the concatenation of s and t +s * n, n*s n copies of s concatenated +s[i] i'th item of s, origin 0 (1) +s[i:j] slice of s from i (included) to j (excluded) (1), (2) +len(s) length of s +min(s) smallest item of s +max(s) largest item of (s) + +Notes : + (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 i is omitted, use +len(s). If i is greater than or + equal to j, the slice is empty. + +Operations on mutable (=modifiable) sequences (lists) + + Operations on mutable sequences + Operation Result Notes +s[i] =x item i of s is replaced by x +s[i:j] = t slice of s from i to j is replaced by t +del s[i:j] same as s[i:j] = [] +s.append(x) same as s[len(s) : len(s)] = [x] +s.extend(x) same as s[len(s):len(s)]= x (5) +s.count(x) return number of i's for which s[i] == x +s.index(x) return smallest i such that s[i] == x (1) +s.insert(i, x) same as s[i:i] = [x] if i >= 0 +s.remove(x) same as del s[s.index(x)] (1) +s.pop([i]) same as x = s[i]; del s[i]; return x (4) +s.reverse() reverse the items of s in place (3) +s.sort([cmpFct]) sort the items of s in place (2), (3) + +Notes : + (1) raise a ValueError exception when x is not found in s (i.e. out of +range). + (2) The sort() method takes an optional argument specifying a comparison +fct of 2 arguments (list items) which should + return -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. + (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) [New 1.5.2] The pop() method is experimental and not supported by +other mutable sequence types than lists. + The optional argument i defaults to -1, so that by default the last +item is removed and returned. + (5) [New 1.5.2] Experimental ! Raises an exception when x is not a list +object. + + + +Operations on mappings (dictionaries) + + Operations on mappings + Operation Result Notes +len(d) the number of items in d +d[k] the item of d with key k (1) +d[k] = x set d[k] to x +del d[k] remove d[k] from d (1) +d.clear() remove all items from d +d.copy() a shallow copy of d +d.has_key(k) 1 if d has key k, else 0 +d.items() a copy of d's list of (key, item) pairs (2) +d.keys() a copy of d's list of keys (2) +d1.update(d2) for k, v in d2.items(): d1[k] = v (3) +d.values() a copy of d's list of values (2) +d.get(k,defaultval) the item of d with key k (4) +d.setdefault(k,defaultval) the item of d with key k (5) + + Notes : + 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) d2 must be of the same type as d1 + (4) 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. + (5) Never raises an exception if k is not in the map, instead it 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. + +Operations on strings + +Note that these string methods largely (but not completely) supersede the +functions available in the string module. + + + Operations on strings + Operation Result Notes +s.capitalize() return a copy of s with only its first character + capitalized. +s.center(width) return a copy of s centered in a string of length width (1) + . +s.count(sub[ return the number of occurrences of substring sub in (2) +,start[,end]]) string s. +s.encode([ return an encoded version of s. Default encoding is the +encoding[,errors current default string encoding. (3) +]]) +s.endswith(suffix return true if s ends with the specified suffix, (2) +[,start[,end]]) otherwise return false. +s.expandtabs([ return a copy of s where all tab characters are (4) +tabsize]) expanded using spaces. +s.find(sub[,start return the lowest index in s where substring sub is (2) +[,end]]) found. Return -1 if sub is not found. +s.index(sub[ like find(), but raise ValueError when the substring is (2) +,start[,end]]) not found. +s.isalnum() return true if all characters in s are alphanumeric, (5) + false otherwise. +s.isalpha() return true if all characters in s are alphabetic, (5) + false otherwise. +s.isdigit() return true if all characters in s are digit (5) + characters, false otherwise. +s.islower() return true if all characters in s are lowercase, false (6) + otherwise. +s.isspace() return true if all characters in s are whitespace (5) + characters, false otherwise. +s.istitle() return true if string s is a titlecased string, false (7) + otherwise. +s.isupper() return true if all characters in s are uppercase, false (6) + otherwise. +s.join(seq) return a concatenation of the strings in the sequence + seq, seperated by 's's. +s.ljust(width) return s left justified in a string of length width. (1), + (8) +s.lower() return a copy of s converted to lowercase. +s.lstrip() return a copy of s with leading whitespace removed. +s.replace(old, return a copy of s with all occurrences of substring (9) +new[, maxsplit]) old replaced by new. +s.rfind(sub[ return the highest index in s where substring sub is (2) +,start[,end]]) found. Return -1 if sub is not found. +s.rindex(sub[ like rfind(), but raise ValueError when the substring (2) +,start[,end]]) is not found. +s.rjust(width) return s right justified in a string of length width. (1), + (8) +s.rstrip() return a copy of s with trailing whitespace removed. +s.split([sep[ return a list of the words in s, using sep as the (10) +,maxsplit]]) delimiter string. +s.splitlines([ return a list of the lines in s, breaking at line (11) +keepends]) boundaries. +s.startswith return true if s starts with the specified prefix, +(prefix[,start[ otherwise return false. (2) +,end]]) +s.strip() return a copy of s with leading and trailing whitespace + removed. +s.swapcase() return a copy of s with uppercase characters converted + to lowercase and vice versa. + return a titlecased copy of s, i.e. words start with +s.title() uppercase characters, all remaining cased characters + are lowercase. +s.translate(table return a copy of s mapped through translation table (12) +[,deletechars]) table. +s.upper() return a copy of s converted to uppercase. + +Notes : + (1) Padding is done using spaces. + (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) 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'. + (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 maxsplit is given, only the first maxsplit +occurrences are replaced. + (10) If sep 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. All characters occurring in the +optional argument deletechars are removed prior to translation. + +String formatting with the % operator + +formatString % args--> evaluates to a string + + * formatString uses C printf format codes : %, c, s, i, d, u, o, x, X, e, E, + f, g, G, r (details below). + * Width and precision may be a * to specify that an integer argument gives + the actual width or precision. + * The flag characters -, +, blank, # and 0 are understood. (details below) + * %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.) + + Format codes +Conversion Meaning +d Signed integer decimal. +i Signed integer decimal. +o Unsigned octal. +u Unsigned decimal. +x Unsigned hexidecimal (lowercase). +X Unsigned hexidecimal (uppercase). +e Floating point exponential format (lowercase). +E Floating point exponential format (uppercase). +f Floating point decimal format. +F Floating point decimal format. +g Same as "e" if exponent is greater than -4 or less than precision, + "f" otherwise. +G Same as "E" if exponent is greater than -4 or less than precision, + "F" otherwise. +c Single character (accepts integer or single character string). +r String (converts any python object using repr()). +s String (converts any python object using str()). +% No argument is converted, results in a "%" character in the result. + (The complete specification is %%.) + + Conversion flag characters +Flag Meaning +# The value conversion will use the ``alternate form''. +0 The conversion will be zero padded. +- The converted value is left adjusted (overrides "-"). + (a space) A blank should be left before a positive number (or empty + string) produced by a signed conversion. ++ A sign character ("+" or "-") will precede the conversion (overrides a + "space" flag). + +File Objects + +Created with built-in function open; may be created by other modules' functions +as well. + +Operators on file objects + + File operations + Operation Result +f.close() Close file f. +f.fileno() Get fileno (fd) for file f. +f.flush() Flush file f's internal buffer. +f.isatty() 1 if file f is connected to a tty-like dev, else 0. +f.read([size]) Read at most size bytes from file f and return as a string + object. If size omitted, read to EOF. +f.readline() Read one entire line from file f. +f.readlines() Read until EOF with readline() and return list of lines read. + Set file f's position, like "stdio's fseek()". +f.seek(offset[, whence == 0 then use absolute indexing. +whence=0]) whence == 1 then offset relative to current pos. + whence == 2 then offset relative to file end. +f.tell() Return file f's current position (byte offset). +f.write(str) Write string to file f. +f.writelines(list Write list of strings to file f. +) + +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 + + + Advanced Types + + -See manuals for more details - + + Module objects + + Class objects + + Class instance objects + + Type objects (see module: types) + + File objects (see above) + + Slice objects + + XRange objects + + Callable types: + o User-defined (written in Python): + # User-defined Function objects + # User-defined Method objects + o Built-in (written in C): + # Built-in Function objects + # Built-in Method objects + + Internal Types: + o Code objects (byte-compile executable Python code: bytecode) + o Frame objects (execution frames) + o Traceback objects (stack trace of an exception) + + + Statements + + pass -- Null statement + del name[,name]* -- Unbind name(s) from object. Object will be indirectly + (and automatically) deleted only if no longer referenced. + print [>> fileobject,] [s1 [, s2 ]* [,] + -- Writes to sys.stdout, or to fileobject if supplied. + Puts spaces between arguments. Puts newline at end + unless statement ends with comma. + Print is not required when running interactively, + simply typing an expression will print its value, + unless the value is None. + exec x [in globals [,locals]] + -- Executes x in namespaces provided. Defaults + to current namespaces. x can be a string, file + object or a function object. + callable(value,... [id=value], [*args], [**kw]) + -- Call function callable with parameters. Parameters can + be passed by name or be omitted if function + defines default values. E.g. if callable is defined as + "def callable(p1=1, p2=2)" + "callable()" <=> "callable(1, 2)" + "callable(10)" <=> "callable(10, 2)" + "callable(p2=99)" <=> "callable(1, 99)" + *args is a tuple of positional arguments. + **kw is a dictionary of keyword arguments. + + Assignment operators + + Caption + Operator Result Notes + a = b Basic assignment - assign object b to label a (1) + a += b Roughly equivalent to a = a + b (2) + a -= b Roughly equivalent to a = a - b (2) + a *= b Roughly equivalent to a = a * b (2) + a /= b Roughly equivalent to a = a / b (2) + a %= b Roughly equivalent to a = a % b (2) + a **= b Roughly equivalent to a = a ** b (2) + a &= b Roughly equivalent to a = a & b (2) + a |= b Roughly equivalent to a = a | b (2) + a ^= b Roughly equivalent to a = a ^ b (2) + a >>= b Roughly equivalent to a = a >> b (2) + a <<= b Roughly equivalent to a = a << b (2) + + Notes : + (1) Can unpack tuples, lists, and strings. + first, second = a[0:2]; [f, s] = range(2); c1,c2,c3='abc' + Tip: x,y = y,x swaps x and y. + (2) Not exactly equivalent - a is evaluated only once. Also, where + possible, operation performed in-place - a is modified rather than + replaced. + + Control Flow + + if condition: suite + [elif condition: suite]* + [else: suite] -- usual if/else_if/else statement + while condition: suite + [else: suite] + -- usual while statement. "else" suite is executed + after loop exits, unless the loop is exited with + "break" + for element in sequence: suite + [else: suite] + -- iterates over sequence, assigning each element to element. + Use built-in range function to iterate a number of times. + "else" suite executed at end unless loop exited + with "break" + break -- immediately exits "for" or "while" loop + continue -- immediately does next iteration of "for" or "while" loop + return [result] -- Exits from function (or method) and returns result (use a tuple to + return more than one value). If no result given, then returns None. + + Exception Statements + + assert expr[, message] + -- expr is evaluated. if false, raises exception AssertionError + with message. Inhibited if __debug__ is 0. + try: suite1 + [except [exception [, value]: suite2]+ + [else: suite3] + -- statements in suite1 are executed. If an exception occurs, look + in "except" clauses for matching <exception>. If matches or bare + "except" execute suite of that clause. If no exception happens + suite in "else" clause is executed after suite1. + If exception has a value, it is put in value. + exception can also be tuple of exceptions, e.g. + "except (KeyError, NameError), val: print val" + try: suite1 + finally: suite2 + -- statements in suite1 are executed. If no + exception, execute suite2 (even if suite1 is + exited with a "return", "break" or "continue" + statement). If exception did occur, executes + suite2 and then immediately reraises exception. + raise exception [,value [, traceback]] + -- raises exception with optional value + value. Arg traceback specifies a traceback object to + use when printing the exception's backtrace. + raise -- a raise statement without arguments re-raises + the last exception raised in the current function +An exception is either a string (object) or a class instance. + Can create a new one simply by creating a new string: + + my_exception = 'You did something wrong' + try: + if bad: + raise my_exception, bad + except my_exception, value: + print 'Oops', value + +Exception classes must be derived from the predefined class: Exception, e.g.: + class text_exception(Exception): pass + try: + if bad: + raise text_exception() + # This is a shorthand for the form + # "raise <class>, <instance>" + except Exception: + print 'Oops' + # This will be printed because + # text_exception is a subclass of Exception +When an error message is printed for an unhandled exception which is a +class, 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. + +Name Space Statements + +[1.51: On Mac & Windows, the case of module file names must now match the case +as used + in the import statement] +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/dirs can be nested. You address a + module's symbol via '[package.[package...]module.symbol's. +import module1 [as name1] [, module2]* + -- imports modules. Members of module must be + referred to by qualifying with [package.]module name: + "import sys; print sys.argv:" + "import package1.subpackage.module; package1.subpackage.module.foo()" + module1 renamed as name1, if supplied. +from module import name1 [as othername1] [, name2]* + -- imports names from module module in current namespace. + "from sys import argv; print argv" + "from package1 import module; module.foo()" + "from package1.module import foo; foo()" + name1 renamed as othername1, if supplied. +from module import * + -- imports all names in module, except those starting with "_"; + *to be used sparsely, beware of name clashes* : + "from sys import *; print argv" + "from package.module import *; print x' + NB: "from package import *" only imports the symbols defined + in the package's __init__.py file, not those in the + template modules! +global name1 [, name2]* + -- names are from global scope (usually meaning from module) + rather than local (usually meaning only in function). + -- E.g. in fct without "global" statements, assuming + "a" is name that hasn't been used in fct or module + so far: + -Try to read from "a" -> NameError + -Try to write to "a" -> creates "a" local to fcn + -If "a" not defined in fct, but is in module, then + -Try to read from "a", gets value from module + -Try to write to "a", creates "a" local to fct + But note "a[0]=3" starts with search for "a", + will use to global "a" if no local "a". + +Function Definition + +def func_id ([param_list]): suite + -- Creates a function object & binds it to name func_id. + + param_list ::= [id [, id]*] + id ::= value | id = value | *id | **id + [Args are passed by value.Thus only args representing a mutable object + can be modified (are inout parameters). Use a tuple to return more than + one value] + +Example: + def test (p1, p2 = 1+1, *rest, **keywords): + -- Parameters with "=" have default value (v is + evaluated when function defined). + If list has "*id" then id is assigned a tuple of + all remaining args passed to function (like C vararg) + If list has "**id" then id is assigned a dictionary of + all extra arguments passed as keywords. + +Class Definition + +class <class_id> [(<super_class1> [,<super_class2>]*)]: <suite> + -- Creates a class object and assigns it name <class_id> + <suite> may contain local "defs" of class methods and + assignments to class attributes. +Example: + class my_class (class1, class_list[3]): ... + Creates a class object inheriting from both "class1" and whatever + class object "class_list[3]" evaluates to. Assigns new + class object to name "my_class". + - First arg to class methods is always instance object, called 'self' + by convention. + - 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!) + - In current implementation, can't subclass off built-in + classes. But can "wrap" them, see UserDict & UserList modules, + and see __getattr__() below. +Example: + 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" + Call parent's super class by accessing parent's method + directly and passing "self" explicitly (see "call_parent" + in example above). + Many other special methods available for implementing + arithmetic operators, sequence, mapping indexing, etc. + +Documentation Strings + +Modules, classes and functions may be documented by placing a string literal by +itself as the first statement in the suite. The documentation can be retrieved +by getting the '__doc__' attribute from the module, class or function. +Example: + class C: + "A description of C" + def __init__(self): + "A description of the constructor" + # etc. +Then c.__doc__ == "A description of C". +Then c.__init__.__doc__ == "A description of the constructor". + +Others + +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 ... for itemN in sequenceN] + ] +is equivalent to: +result = [] +for item1 in sequence1: + for item2 in sequence2: + ... + for itemN in sequenceN: + if (condition1) and furthur conditions: + result.append(expression) + + + +Built-In Functions + + Built-In Functions + Function Result +__import__(name[, Imports module within the given context (see lib ref for +globals[, locals[, more details) +fromlist]]]) +abs(x) Return the absolute value of number x. +apply(f, args[, Calls func/method f with arguments args and optional +keywords]) keywords. +callable(x) Returns 1 if x callable, else 0. +chr(i) Returns one-character string whose ASCII code isinteger i +cmp(x,y) Returns negative, 0, positive if x <, ==, > to y +coerce(x,y) Returns a tuple of the two numeric arguments converted to a + common type. + Compiles string into a code object.filename is used in + error message, can be any string. It isusually the file +compile(string, from which the code was read, or eg. '<string>'if not read +filename, kind) from file.kind can be 'eval' if string is a single stmt, or + 'single' which prints the output of expression statements + thatevaluate to something else than None, or be 'exec'. +complex(real[, Builds a complex object (can also be done using J or j +image]) suffix,e.g. 1+3J) +delattr(obj, name) deletes attribute named name of object obj <=> del obj.name + If no args, returns the list of names in current +dir([object]) localsymbol table. With a module, class or class + instanceobject as arg, returns list of names in its attr. + dict. +divmod(a,b) Returns tuple of (a/b, a%b) +eval(s[, globals[, Eval string s in (optional) globals, locals contexts.s must +locals]]) have no NUL's or newlines. s can also be acode object. + Example: x = 1; incr_x = eval('x + 1') +execfile(file[, Executes a file without creating a new module, unlike +globals[, locals]]) import. +filter(function, Constructs a list from those elements of sequence for which +sequence) function returns true. function takes one parameter. +float(x) Converts a number or a string to floating point. +getattr(object, [<default> arg added in 1.5.2]Gets attribute called name +name[, default])) from object,e.g. getattr(x, 'f') <=> x.f). If not found, + raisesAttributeError or returns default if specified. +globals() Returns a dictionary containing current global variables. +hasattr(object, Returns true if object has attr called name. +name) +hash(object) Returns the hash value of the object (if it has one) +hex(x) Converts a number x to a hexadecimal string. +id(object) Returns a unique 'identity' integer for an object. +input([prompt]) Prints prompt if given. Reads input and evaluates it. + Converts a number or a string to a plain integer. Optional +int(x[, base]) base paramenter specifies base from which to convert string + values. +intern(aString) Enters aString in the table of "interned strings" + andreturns the string. Interned strings are 'immortals'. +isinstance(obj, returns true if obj is an instance of class. Ifissubclass +class) (A,B) then isinstance(x,A) => isinstance(x,B) +issubclass(class1, returns true if class1 is derived from class2 +class2) + Returns the length (the number of items) of an object +len(obj) (sequence, dictionary, or instance of class implementing + __len__). +list(sequence) Converts sequence into a list. If already a list,returns a + copy of it. +locals() Returns a dictionary containing current local variables. + Converts a number or a string to a long integer. Optional +long(x[, base]) base paramenter specifies base from which to convert string + values. + Applies function to every item of list and returns a listof +map(function, list, the results. If additional arguments are passed,function +...) must take that many arguments and it is givento function on + each call. +max(seq) Returns the largest item of the non-empty sequence seq. +min(seq) Returns the smallest item of a non-empty sequence seq. +oct(x) Converts a number to an octal string. +open(filename [, Returns a new file object. First two args are same asthose +mode='r', [bufsize= for C's "stdio open" function. bufsize is 0for unbuffered, +implementation 1 for line-buffered, negative forsys-default, all else, of +dependent]]) (about) given size. +ord(c) Returns integer ASCII value of c (a string of len 1). Works + with Unicode char. +pow(x, y [, z]) Returns x to power y [modulo z]. See also ** operator. +range(start [,end Returns list of ints from >= start and < end.With 1 arg, +[, step]]) list from 0..arg-1With 2 args, list from start..end-1With 3 + args, list from start up to end by step +raw_input([prompt]) Prints prompt if given, then reads string from stdinput (no + trailing \n). See also input(). +reduce(f, list [, Applies the binary function f to the items oflist so as to +init]) reduce the list to a single value.If init given, it is + "prepended" to list. + Re-parses and re-initializes an already imported module. + Useful in interactive mode, if you want to reload amodule +reload(module) after fixing it. If module was syntacticallycorrect but had + an error in initialization, mustimport it one more time + before calling reload(). + Returns a string containing a printable and if possible +repr(object) evaluable representation of an object. <=> `object` + (usingbackquotes). Class redefinissable (__repr__). See + also str() +round(x, n=0) Returns the floating point value x rounded to n digitsafter + the decimal point. +setattr(object, This is the counterpart of getattr().setattr(o, 'foobar', +name, value) 3) <=> o.foobar = 3Creates attribute if it doesn't exist! +slice([start,] stop Returns a slice object representing a range, with R/ +[, step]) Oattributes: start, stop, step. + Returns a string containing a nicely +str(object) printablerepresentation of an object. Class overridable + (__str__).See also repr(). +tuple(sequence) Creates a tuple with same elements as sequence. If already + a tuple, return itself (not a copy). + Returns a type object [see module types] representing + thetype of obj. Example: import typesif type(x) == +type(obj) types.StringType: print 'It is a string'NB: it is + recommanded to use the following form:if isinstance(x, + types.StringType): etc... +unichr(code) code. +unicode(string[, Creates a Unicode string from a 8-bit string, using +encoding[, error thegiven encoding name and error treatment ('strict', +]]]) 'ignore',or 'replace'}. + Without arguments, returns a dictionary correspondingto the + current local symbol table. With a module,class or class +vars([object]) instance object as argumentreturns a dictionary + corresponding to the object'ssymbol table. Useful with "%" + formatting operator. +xrange(start [, end Like range(), but doesn't actually store entire listall at +[, step]]) once. Good to use in "for" loops when there is abig range + and little memory. +zip(seq1[, seq2, Returns a list of tuples where each tuple contains the nth +...]) element of each of the argument sequences. + + + + +Built-In Exceptions + +Exception> + Root class for all exceptions + SystemExit + On 'sys.exit()' + StandardError + Base class for all built-in exceptions; derived from Exception + root class. + ArithmeticError + Base class for OverflowError, ZeroDivisionError, + FloatingPointError + FloatingPointError + When a floating point operation fails. + OverflowError + On excessively large arithmetic operation + ZeroDivisionError + On division or modulo operation with 0 as 2nd arg + AssertionError + When an assert statement fails. + AttributeError + On attribute reference or assignment failure + EnvironmentError [new in 1.5.2] + On error outside Python; error arg tuple is (errno, errMsg...) + IOError [changed in 1.5.2] + I/O-related operation failure + OSError [new in 1.5.2] + used by the os module's os.error exception. + EOFError + Immediate end-of-file hit by input() or raw_input() + ImportError + On failure of `import' to find module or name + KeyboardInterrupt + On user entry of the interrupt key (often `Control-C') + 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 + RuntimeError + Obsolete catch-all; define a suitable error instead + NotImplementedError [new in 1.5.2] + On method not implemented + SyntaxError + On parser encountering a syntax error + IndentationError + On parser encountering an indentation syntax error + TabError + On parser encountering an indentation syntax error + SystemError + On non-fatal interpreter error - bug - report it + TypeError + On passing inappropriate type to built-in op or func + ValueError + On arg error not covered by TypeError or more precise + + + +Standard methods & operators redefinition in classes + +Standard methods & operators map to special '__methods__' and thus may be + redefined (mostly in in user-defined classes), e.g.: + class x: + def __init__(self, v): self.value = v + def __add__(self, r): return self.value + r + a = x(3) # sort of like calling x.__init__(a, 3) + a + 4 # is equivalent to a.__add__(4) + +Special methods for any class + +(s: self, o: other) + __init__(s, args) instance initialization (on construction) + __del__(s) called on object demise (refcount becomes 0) + __repr__(s) repr() and `...` conversions + __str__(s) str() and 'print' statement + __cmp__(s, o) Compares s to o and returns <0, 0, or >0. + Implements >, <, == etc... + __hash__(s) Compute a 32 bit hash code; hash() and dictionary ops + __nonzero__(s) Returns 0 or 1 for truth value testing + __getattr__(s, name) called when attr lookup doesn't find <name> + __setattr__(s, name, val) called when setting an attr + (inside, don't use "self.name = value" + use "self.__dict__[name] = val") + __delattr__(s, name) called to delete attr <name> + __call__(self, *args) called when an instance is called as function. + +Operators + + See list in the operator module. Operator function names are provided with + 2 variants, with or without + ading & trailing '__' (eg. __add__ or add). + + Numeric operations special methods + (s: self, o: other) + + s+o = __add__(s,o) s-o = __sub__(s,o) + s*o = __mul__(s,o) s/o = __div__(s,o) + s%o = __mod__(s,o) divmod(s,o) = __divmod__(s,o) + s**o = __pow__(s,o) + s&o = __and__(s,o) + s^o = __xor__(s,o) s|o = __or__(s,o) + s<<o = __lshift__(s,o) s>>o = __rshift__(s,o) + nonzero(s) = __nonzero__(s) (used in boolean testing) + -s = __neg__(s) +s = __pos__(s) + abs(s) = __abs__(s) ~s = __invert__(s) (bitwise) + s+=o = __iadd__(s,o) s-=o = __isub__(s,o) + s*=o = __imul__(s,o) s/=o = __idiv__(s,o) + s%=o = __imod__(s,o) + s**=o = __ipow__(s,o) + s&=o = __iand__(s,o) + s^=o = __ixor__(s,o) s|=o = __ior__(s,o) + s<<=o = __ilshift__(s,o) s>>=o = __irshift__(s,o) + Conversions + int(s) = __int__(s) long(s) = __long__(s) + float(s) = __float__(s) complex(s) = __complex__(s) + oct(s) = __oct__(s) hex(s) = __hex__(s) + coerce(s,o) = __coerce__(s,o) + Right-hand-side equivalents for all binary operators exist; + are called when class instance is on r-h-s of operator: + a + 3 calls __add__(a, 3) + 3 + a calls __radd__(a, 3) + + All seqs and maps, general operations plus: + (s: self, i: index or key) + + len(s) = __len__(s) length of object, >= 0. Length 0 == false + s[i] = __getitem__(s,i) Element at index/key i, origin 0 + + Sequences, general methods, plus: + s[i]=v = __setitem__(s,i,v) + del s[i] = __delitem__(s,i) + s[i:j] = __getslice__(s,i,j) + s[i:j]=seq = __setslice__(s,i,j,seq) + del s[i:j] = __delslice__(s,i,j) == s[i:j] = [] + seq * n = __repeat__(seq, n) + s1 + s2 = __concat__(s1, s2) + i in s = __contains__(s, i) + Mappings, general methods, plus + hash(s) = __hash__(s) - hash value for dictionary references + s[k]=v = __setitem__(s,k,v) + del s[k] = __delitem__(s,k) + +Special informative state attributes for some types: + + Lists & Dictionaries: + __methods__ (list, R/O): list of method names of the object + + Modules: + __doc__ (string/None, R/O): doc string (<=> __dict__['__doc__']) + __name__(string, R/O): module name (also in __dict__['__name__']) + __dict__ (dict, R/O): module's name space + __file__(string/undefined, R/O): pathname of .pyc, .pyo or .pyd (undef for + modules statically linked to the interpreter) + __path__(string/undefined, R/O): fully qualified package name when applies. + + Classes: [in bold: writable since 1.5.2] + __doc__ (string/None, R/W): doc string (<=> __dict__['__doc__']) + __name__(string, R/W): class name (also in __dict__['__name__']) + __bases__ (tuple, R/W): parent classes + __dict__ (dict, R/W): attributes (class name space) + + Instances: + __class__ (class, R/W): instance's class + __dict__ (dict, R/W): attributes + User-defined functions: [bold: writable since 1.5.2] + __doc__ (string/None, R/W): doc string + __name__(string, R/O): function name + func_doc (R/W): same as __doc__ + func_name (R/O): same as __name__ + func_defaults (tuple/None, R/W): default args values if any + func_code (code, R/W): code object representing the compiled function body + func_globals (dict, R/O): ref to dictionary of func global variables + + User-defined Methods: + __doc__ (string/None, R/O): doc string + __name__(string, R/O): method name (same as im_func.__name__) + im_class (class, R/O): class defining the method (may be a base class) + im_self (instance/None, R/O): target instance object (None if unbound) + im_func (function, R/O): function object + Built-in Functions & methods: + __doc__ (string/None, R/O): doc string + __name__ (string, R/O): function name + __self__ : [methods only] target object + __members__ = list of attr names: ['__doc__','__name__','__self__']) + Codes: + co_name (string, R/O): function name + co_argcount (int, R/0): number of positional args + co_nlocals (int, R/O): number of local vars (including args) + co_varnames (tuple, R/O): names of local vars (starting with args) + co_code (string, R/O): sequence of bytecode instructions + co_consts (tuple, R/O): litterals used by the bytecode, 1st one is + fct doc (or None) + co_names (tuple, R/O): names used by the bytecode + co_filename (string, R/O): filename from which the code was compiled + co_firstlineno (int, R/O): first line number of the function + co_lnotab (string, R/O): string encoding bytecode offsets to line numbers. + co_stacksize (int, R/O): required stack size (including local vars) + co_firstlineno (int, R/O): first line number of the function + co_flags (int, R/O): flags for the interpreter + bit 2 set if fct uses "*arg" syntax + bit 3 set if fct uses '**keywords' syntax + Frames: + f_back (frame/None, R/O): previous stack frame (toward the caller) + f_code (code, R/O): code object being executed in this frame + f_locals (dict, R/O): local vars + f_globals (dict, R/O): global vars + f_builtins (dict, R/O): built-in (intrinsic) names + f_restricted (int, R/O): flag indicating whether fct is executed in + restricted mode + f_lineno (int, R/O): current line number + f_lasti (int, R/O): precise instruction (index into bytecode) + f_trace (function/None, R/W): debug hook called at start of each source line + f_exc_type (Type/None, R/W): Most recent exception type + f_exc_value (any, R/W): Most recent exception value + f_exc_traceback (traceback/None, R/W): Most recent exception traceback + Tracebacks: + tb_next (frame/None, R/O): next level in stack trace (toward the frame where + the exception occurred) + tb_frame (frame, R/O): execution frame of the current level + tb_lineno (int, R/O): line number where the exception occured + tb_lasti (int, R/O): precise instruction (index into bytecode) + + Slices: + start (any/None, R/O): lowerbound + stop (any/None, R/O): upperbound + step (any/None, R/O): step value + + Complex numbers: + real (float, R/O): real part + imag (float, R/O): imaginary part + XRanges: + tolist (Built-in method, R/O): ? + + +Important Modules + + sys + + Some sys variables + Variable Content +argv The list of command line arguments passed to aPython + script. sys.argv[0] is the script name. +builtin_module_names A list of strings giving the names of all moduleswritten + in C that are linked into this interpreter. +check_interval How often to check for thread switches or signals(measured + in number of virtual machine instructions) +exc_type, exc_value, Deprecated since release 1.5. Use exc_info() instead. +exc_traceback +exitfunc User can set to a parameterless fcn. It will getcalled + before interpreter exits. +last_type, Set only when an exception not handled andinterpreter +last_value, prints an error. Used by debuggers. +last_traceback +maxint maximum positive value for integers +modules Dictionary of modules that have already been loaded. +path Search path for external modules. Can be modifiedby + program. sys.path[0] == dir of script executing +platform The current platform, e.g. "sunos5", "win32" +ps1, ps2 prompts to use in interactive mode. + File objects used for I/O. One can redirect byassigning a +stdin, stdout, new file object to them (or any object:.with a method +stderr write(string) for stdout/stderr,.with a method readline() + for stdin) +version string containing version info about Python interpreter. + (and also: copyright, dllhandle, exec_prefix, prefix) +version_info tuple containing Python version info - (major, minor, + micro, level, serial). + + Some sys functions + Function Result +exit(n) Exits with status n. Raises SystemExit exception.(Hence can + be caught and ignored by program) +getrefcount(object Returns the reference count of the object. Generally 1 +) higherthan you might expect, because of object arg temp + reference. +setcheckinterval( Sets the interpreter's thread switching interval (in number +interval) ofvirtualcode instructions, default:10). +settrace(func) Sets a trace function: called before each line ofcode is + exited. +setprofile(func) Sets a profile function for performance profiling. + Info on exception currently being handled; this is atuple + (exc_type, exc_value, exc_traceback).Warning: assigning the +exc_info() traceback return value to a loca variable in a + functionhandling an exception will cause a circular + reference. +setdefaultencoding Change default Unicode encoding - defaults to 7-bit ASCII. +(encoding) +getrecursionlimit Retrieve maximum recursion depth. +() +setrecursionlimit Set maximum recursion depth. (Defaults to 1000.) +() + + + + os +"synonym" for whatever O/S-specific module is proper for current environment. +this module uses posix whenever possible. +(see also M.A. Lemburg's utility http://www.lemburg.com/files/python/ +platform.py) + + Some os variables + Variable Meaning +name name of O/S-specific module (e.g. "posix", "mac", "nt") +path O/S-specific module for path manipulations. + On Unix, os.path.split() <=> posixpath.split() +curdir string used to represent current directory ('.') +pardir string used to represent parent directory ('..') +sep string used to separate directories ('/' or '\'). Tip: use + os.path.join() to build portable paths. +altsep Alternate sep +if applicable (None +otherwise) +pathsep character used to separate search path components (as in + $PATH), eg. ';' for windows. +linesep line separator as used in binary files, ie '\n' on Unix, '\ + r\n' on Dos/Win, '\r' + + Some os functions + Function Result +makedirs(path[, Recursive directory creation (create required intermediary +mode=0777]) dirs); os.error if fails. +removedirs(path) Recursive directory delete (delete intermediary empty + dirs); if fails. +renames(old, new) Recursive directory or file renaming; os.error if fails. + + + + posix +don't import this module directly, import os instead ! +(see also module: shutil for file copy & remove fcts) + + posix Variables +Variable Meaning +environ dictionary of environment variables, e.g.posix.environ['HOME']. +error exception raised on POSIX-related error. + Corresponding value is tuple of errno code and perror() string. + + Some posix functions + Function Result +chdir(path) Changes current directory to path. +chmod(path, Changes the mode of path to the numeric mode +mode) +close(fd) Closes file descriptor fd opened with posix.open. +_exit(n) Immediate exit, with no cleanups, no SystemExit,etc. Should use + this to exit a child process. +execv(p, args) "Become" executable p with args args +getcwd() Returns a string representing the current working directory +getpid() Returns the current process id +fork() Like C's fork(). Returns 0 to child, child pid to parent.[Not + on Windows] +kill(pid, Like C's kill [Not on Windows] +signal) +listdir(path) Lists (base)names of entries in directory path, excluding '.' + and '..' +lseek(fd, pos, Sets current position in file fd to position pos, expressedas +how) an offset relative to beginning of file (how=0), tocurrent + position (how=1), or to end of file (how=2) +mkdir(path[, Creates a directory named path with numeric mode (default 0777) +mode]) +open(file, Like C's open(). Returns file descriptor. Use file object +flags, mode) fctsrather than this low level ones. +pipe() Creates a pipe. Returns pair of file descriptors (r, w) [Not on + Windows]. +popen(command, Opens a pipe to or from command. Result is a file object to +mode='r', read to orwrite from, as indicated by mode being 'r' or 'w'. +bufSize=0) Use it to catch acommand output ('r' mode) or to feed it ('w' + mode). +remove(path) See unlink. +rename(src, dst Renames/moves the file or directory src to dst. [error iftarget +) name already exists] +rmdir(path) Removes the empty directory path +read(fd, n) Reads n bytes from file descriptor fd and return as string. + Returns st_mode, st_ino, st_dev, st_nlink, st_uid,st_gid, +stat(path) st_size, st_atime, st_mtime, st_ctime.[st_ino, st_uid, st_gid + are dummy on Windows] +system(command) Executes string command in a subshell. Returns exitstatus of + subshell (usually 0 means OK). + Returns accumulated CPU times in sec (user, system, children's +times() user,children's sys, elapsed real time). [3 last not on + Windows] +unlink(path) Unlinks ("deletes") the file (not dir!) path. same as: remove +utime(path, ( Sets the access & modified time of the file to the given tuple +aTime, mTime)) of values. +wait() Waits for child process completion. Returns tuple ofpid, + exit_status [Not on Windows] +waitpid(pid, Waits for process pid to complete. Returns tuple ofpid, +options) exit_status [Not on Windows] +write(fd, str) Writes str to file fd. Returns nb of bytes written. + + + + posixpath +Do not import this module directly, import os instead and refer to this module +as os.path. (e.g. os.path.exists(p)) ! + + Some posixpath functions + Function Result +abspath(p) Returns absolute path for path p, taking current working dir in + account. +dirname/ +basename(p directory and name parts of the path p. See also split. +) +exists(p) True if string p is an existing path (file or directory) +expanduser Returns string that is (a copy of) p with "~" expansion done. +(p) +expandvars Returns string that is (a copy of) p with environment vars expanded. +(p) [Windows: case significant; must use Unix: $var notation, not %var%] +getsize( return the size in bytes of filename. raise os.error. +filename) +getmtime( return last modification time of filename (integer nb of seconds +filename) since epoch). +getatime( return last access time of filename (integer nb of seconds since +filename) epoch). +isabs(p) True if string p is an absolute path. +isdir(p) True if string p is a directory. +islink(p) True if string p is a symbolic link. +ismount(p) True if string p is a mount point [true for all dirs on Windows]. +join(p[,q Joins one or more path components intelligently. +[,...]]) + Splits p into (head, tail) where tail is lastpathname component and +split(p) <head> is everything leadingup to that. <=> (dirname(p), basename + (p)) +splitdrive Splits path p in a pair ('drive:', tail) [Windows] +(p) +splitext(p Splits into (root, ext) where last comp of root contains no periods +) and ext is empty or startswith a period. + Calls the function visit with arguments(arg, dirname, names) for + each directory recursively inthe directory tree rooted at p +walk(p, (including p itself if it's a dir)The argument dirname specifies the +visit, arg visited directory, the argumentnames lists the files in the +) directory. The visit function maymodify names to influence the set + of directories visited belowdirname, e.g., to avoid visiting certain + parts of the tree. + + + + shutil +high-level file operations (copying, deleting). + + Main shutil functions + Function Result +copy(src, dst) Copies the contents of file src to file dst, retaining file + permissions. +copytree(src, dst Recursively copies an entire directory tree rooted at src +[, symlinks]) into dst (which should not already exist). If symlinks is + true, links insrc are kept as such in dst. +rmtree(path[, Deletes an entire directory tree, ignoring errors if +ignore_errors[, ignore_errors true,or calling onerror(func, path, +onerror]]) sys.exc_info()) if supplied with + +(and also: copyfile, copymode, copystat, copy2) + +time + + Variables +Variable Meaning +altzone signed offset of local DST timezone in sec west of the 0th meridian. +daylight nonzero if a DST timezone is specified + + Functions + Function Result +time() return a float representing UTC time in seconds since the epoch. +gmtime(secs), return a tuple representing time : (year aaaa, month(1-12),day +localtime( (1-31), hour(0-23), minute(0-59), second(0-59), weekday(0-6, 0 is +secs) monday), Julian day(1-366), daylight flag(-1,0 or 1)) +asctime( +timeTuple), +strftime( +format, return a formated string representing time. +timeTuple) +mktime(tuple) inverse of localtime(). Return a float. +strptime( parse a formated string representing time, return tuple as in +string[, gmtime(). +format]) +sleep(secs) Suspend execution for <secs> seconds. <secs> can be a float. + +and also: clock, ctime. + + 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 - see Operations +on strings for details. + + Some string variables + Variable Meaning +digits The string '0123456789' +hexdigits, octdigits legal hexadecimal & octal digits +letters, uppercase, lowercase, Strings containing the appropriate +whitespace characters +index_error Exception raised by index() if substr not + found. + + Some string functions + Function Result +expandtabs(s, returns a copy of string <s> with tabs expanded. +tabSize) +find/rfind(s, sub Return the lowest/highest index in <s> where the substring +[, start=0[, end= <sub> is found such that <sub> is wholly contained ins +0]) [start:end]. Return -1 if <sub> not found. +ljust/rjust/center Return a copy of string <s> left/right justified/centerd in +(s, width) afield of given width, padded with spaces. <s> is + nevertruncated. +lower/upper(s) Return a string that is (a copy of) <s> in lowercase/ + uppercase +split(s[, sep= Return a list containing the words of the string <s>,using +whitespace[, the string <sep> as a separator. +maxsplit=0]]) +join(words[, sep=' Concatenate a list or tuple of words with +']) interveningseparators; inverse of split. +replace(s, old, Returns a copy of string <s> with all occurences of +new[, maxsplit=0] substring<old> replaced by <new>. Limits to <maxsplit> + firstsubstitutions if specified. +strip(s) Return a string that is (a copy of) <s> without leadingand + trailing whitespace. see also lstrip, rstrip. + + + + re (sre) + +Handles Unicode strings. Implemented in new module sre, re now a mere front-end +for compatibility. +Patterns are specified as strings. Tip: Use raw strings (e.g. r'\w*') to +litteralize backslashes. + + + Regular expression syntax + Form Description +. matches any character (including newline if DOTALL flag specified) +^ matches start of the string (of every line in MULTILINE mode) +$ matches end of the string (of every line in MULTILINE mode) +* 0 or more of preceding regular expression (as many as possible) ++ 1 or more of preceding regular expression (as many as possible) +? 0 or 1 occurence of preceding regular expression +*?, +?, ?? Same as *, + and ? but matches as few characters as possible +{m,n} matches from m to n repetitions of preceding RE +{m,n}? idem, attempting to match as few repetitions as possible +[ ] defines character set: e.g. '[a-zA-Z]' to match all letters(see also + \w \S) +[^ ] defines complemented character set: matches if char is NOT in set + escapes special chars '*?+&$|()' and introduces special sequences +\ (see below). Due to Python string rules, write as '\\' orr'\' in the + pattern string. +\\ matches a litteral '\'; due to Python string rules, write as '\\\\ + 'in pattern string, or better using raw string: r'\\'. +| specifies alternative: 'foo|bar' matches 'foo' or 'bar' +(...) matches any RE inside (), and delimits a group. +(?:...) idem but doesn't delimit a group. + matches if ... matches next, but doesn't consume any of the string +(?=...) e.g. 'Isaac (?=Asimov)' matches 'Isaac' only if followed by + 'Asimov'. +(?!...) matches if ... doesn't match next. Negative of (?=...) +(?P<name matches any RE inside (), and delimits a named group. (e.g. r'(?P +>...) <id>[a-zA-Z_]\w*)' defines a group named id) +(?P=name) matches whatever text was matched by the earlier group named name. +(?#...) A comment; ignored. +(?letter) letter is one of 'i','L', 'm', 's', 'x'. Set the corresponding flags + (re.I, re.L, re.M, re.S, re.X) for the entire RE. + + Special sequences +Sequence Description +number matches content of the group of the same number; groups are numbered + starting from 1 +\A matches only at the start of the string +\b empty str at beg or end of word: '\bis\b' matches 'is', but not 'his' +\B empty str NOT at beginning or end of word +\d any decimal digit (<=> [0-9]) +\D any non-decimal digit char (<=> [^O-9]) +\s any whitespace char (<=> [ \t\n\r\f\v]) +\S any non-whitespace char (<=> [^ \t\n\r\f\v]) +\w any alphaNumeric char (depends on LOCALE flag) +\W any non-alphaNumeric char (depends on LOCALE flag) +\Z matches only at the end of the string + + Variables +Variable Meaning +error Exception when pattern string isn't a valid regexp. + + Functions + Function Result + Compile a RE pattern string into a regular expression object. + Flags (combinable by |): + + I or IGNORECASE or (?i) + case insensitive matching +compile( L or LOCALE or (?L) +pattern[, make \w, \W, \b, \B dependent on thecurrent locale +flags=0]) M or MULTILINE or (?m) + matches every new line and not onlystart/end of the whole + string + S or DOTALL or (?s) + '.' matches ALL chars, including newline + X or VERBOSE or (?x) + Ignores whitespace outside character sets +escape(string) return (a copy of) string with all non-alphanumerics + backslashed. +match(pattern, if 0 or more chars at beginning of <string> match the RE pattern +string[, flags string,return a corresponding MatchObject instance, or None if +]) no match. +search(pattern scan thru <string> for a location matching <pattern>, return +, string[, acorresponding MatchObject instance, or None if no match. +flags]) +split(pattern, split <string> by occurrences of <pattern>. If capturing () are +string[, used inpattern, then occurrences of patterns or subpatterns are +maxsplit=0]) also returned. +findall( return a list of non-overlapping matches in <pattern>, either a +pattern, list ofgroups or a list of tuples if the pattern has more than 1 +string) group. + return string obtained by replacing the (<count> first) lefmost +sub(pattern, non-overlapping occurrences of <pattern> (a string or a RE +repl, string[, object) in <string>by <repl>; <repl> can be a string or a fct +count=0]) called with a single MatchObj arg, which must return the + replacement string. +subn(pattern, +repl, string[, same as sub(), but returns a tuple (newString, numberOfSubsMade) +count=0]) + +Regular Expression Objects + + +(RE objects are returned by the compile fct) + + re object attributes +Attribute Descrition +flags flags arg used when RE obj was compiled, or 0 if none provided +groupindex dictionary of {group name: group number} in pattern +pattern pattern string from which RE obj was compiled + + re object methods + Method Result + If zero or more characters at the beginning of string match this + regular expression, return a corresponding MatchObject instance. + Return None if the string does not match the pattern; note that + this is different from a zero-length match. + The optional second parameter pos gives an index in the string +match( where the search is to start; it defaults to 0. This is not +string[, completely equivalent to slicing the string; the '' pattern +pos][, character matches at the real beginning of the string and at +endpos]) positions just after a newline, but not necessarily at the index + where the search is to start. + The optional parameter endpos limits how far the string will be + searched; it will be as if the string is endpos characters long, so + only the characters from pos to endpos will be searched for a + match. + Scan through string looking for a location where this regular +search( expression produces a match, and return a corresponding MatchObject +string[, instance. Return None if no position in the string matches the +pos][, pattern; note that this is different from finding a zero-length +endpos]) match at some point in the string. + The optional pos and endpos parameters have the same meaning as for + the match() method. +split( +string[, Identical to the split() function, using the compiled pattern. +maxsplit= +0]) +findall( Identical to the findall() function, using the compiled pattern. +string) +sub(repl, +string[, Identical to the sub() function, using the compiled pattern. +count=0]) +subn(repl, +string[, Identical to the subn() function, using the compiled pattern. +count=0]) + +Match Objects + + +(Match objects are returned by the match & search functions) + + Match object attributes +Attribute Description +pos value of pos passed to search or match functions; index intostring at + which RE engine started search. +endpos value of endpos passed to search or match functions; index intostring + beyond which RE engine won't go. +re RE object whose match or search fct produced this MatchObj instance +string string passed to match() or search() + + Match object functions +Function Result + returns one or more groups of the match. If one arg, result is a +group([g1 string;if multiple args, result is a tuple with one item per arg. If +, g2, gi is 0,return value is entire matching string; if 1 <= gi <= 99, +...]) returnstring matching group #gi (or None if no such group); gi may + also bea group name. + returns a tuple of all groups of the match; groups not +groups() participatingto the match have a value of None. Returns a string + instead of tupleif len(tuple)=1 +start( +group), returns indices of start & end of substring matched by group (or +end(group Noneif group exists but doesn't contribute to the match) +) +span( returns the 2-tuple (start(group), end(group)); can be (None, None)if +group) group didn't contibute to the match. + + + + math + +Variables: +pi +e +Functions (see ordinary C man pages for info): +acos(x) +asin(x) +atan(x) +atan2(x, y) +ceil(x) +cos(x) +cosh(x) +exp(x) +fabs(x) +floor(x) +fmod(x, y) +frexp(x) -- Unlike C: (float, int) = frexp(float) +ldexp(x, y) +log(x) +log10(x) +modf(x) -- Unlike C: (float, float) = modf(float) +pow(x, y) +sin(x) +sinh(x) +sqrt(x) +tan(x) +tanh(x) + + getopt + +Functions: +getopt(list, optstr) -- Similar to C. <optstr> is option + letters to look for. Put ':' after letter + if option takes arg. E.g. + # invocation was "python test.py -c hi -a arg1 arg2" + opts, args = getopt.getopt(sys.argv[1:], 'ab:c:') + # opts would be + [('-c', 'hi'), ('-a', '')] + # args would be + ['arg1', 'arg2'] + + +List of modules and packages in base distribution + +(built-ins and content of python Lib directory) +(Python NT distribution, may be slightly different in other distributions) + + Standard library modules + Operation Result +aifc Stuff to parse AIFF-C and AIFF files. +anydbm Generic interface to all dbm clones. (dbhash, gdbm, + dbm,dumbdbm) +asynchat Support for 'chat' style protocols +asyncore Asynchronous File I/O (in select style) +atexit Register functions to be called at exit of Python interpreter. +audiodev Audio support for a few platforms. +base64 Conversions to/from base64 RFC-MIME transport encoding . +BaseHTTPServer Base class forhttp services. +Bastion "Bastionification" utility (control access to instance vars) +bdb A generic Python debugger base class. +binhex Macintosh binhex compression/decompression. +bisect List bisection algorithms. +calendar Calendar printing functions. +cgi Wraps the WWW Forms Common Gateway Interface (CGI). +CGIHTTPServer CGI http services. +cmd A generic class to build line-oriented command interpreters. +[DEL:cmp:DEL] [DEL:Efficiently compare files, boolean outcome only.:DEL] +[DEL:cmpcache: [DEL:Same, but caches 'stat' results for speed.:DEL] +DEL] +code Utilities needed to emulate Python's interactive interpreter +codecs Lookup existing Unicode encodings and register new ones. +colorsys Conversion functions between RGB and other color systems. +commands Tools for executing UNIX commands . +compileall Force "compilation" of all .py files in a directory. +ConfigParser Configuration file parser (much like windows .ini files) +copy Generic shallow and deep copying operations. +copy_reg Helper to provide extensibility for pickle/cPickle. +dbhash (g)dbm-compatible interface to bsdhash.hashopen. +dircache Sorted list of files in a dir, using a cache. +[DEL:dircmp:DEL] [DEL:Defines a class to build directory diff tools on.:DEL] +dis Bytecode disassembler. +distutils Package installation system. +dospath Common operations on DOS pathnames. +dumbdbm A dumb and slow but simple dbm clone. +[DEL:dump:DEL] [DEL:Print python code that reconstructs a variable.:DEL] +exceptions Class based built-in exception hierarchy. +filecmp File comparison. +fileinput Helper class to quickly write a loop over all standard input + files. +[DEL:find:DEL] [DEL:Find files directory hierarchy matching a pattern.:DEL] +fnmatch Filename matching with shell patterns. +formatter A test formatter. +fpformat General floating point formatting functions. +ftplib An FTP client class. Based on RFC 959. +gc Perform garbacge collection, obtain GC debug stats, and tune + GC parameters. +getopt Standard command line processing. See also ftp:// + www.pauahtun.org/pub/getargspy.zip +getpass Utilities to get a password and/or the current user name. +glob filename globbing. +gopherlib Gopher protocol client interface. +[DEL:grep:DEL] [DEL:'grep' utilities.:DEL] +gzip Read & write gzipped files. +htmlentitydefs Proposed entity definitions for HTML. +htmllib HTML parsing utilities. +httplib HTTP client class. +ihooks Hooks into the "import" mechanism. +imaplib IMAP4 client.Based on RFC 2060. +imghdr Recognizing image files based on their first few bytes. +imputil Privides a way of writing customised import hooks. +keyword List of Python keywords. +knee A Python re-implementation of hierarchical module import. +linecache Cache lines from files. +linuxaudiodev Lunix /dev/audio support. +locale Support for number formatting using the current locale + settings. +macpath Pathname (or related) operations for the Macintosh. +macurl2path Mac specific module for conversion between pathnames and URLs. +mailbox A class to handle a unix-style or mmdf-style mailbox. +mailcap Mailcap file handling (RFC 1524). +mhlib MH (mailbox) interface. +mimetools Various tools used by MIME-reading or MIME-writing programs. +mimetypes Guess the MIME type of a file. +MimeWriter Generic MIME writer. +mimify Mimification and unmimification of mail messages. +mmap Interface to memory-mapped files - they behave like mutable + strings./font> +multifile Class to make multi-file messages easier to handle. +mutex Mutual exclusion -- for use with module sched. +netrc +nntplib An NNTP client class. Based on RFC 977. +ntpath Common operations on DOS pathnames. +nturl2path Mac specific module for conversion between pathnames and URLs. +os Either mac, dos or posix depending system. +[DEL:packmail: [DEL:Create a self-unpacking shell archive.:DEL] +DEL] +pdb A Python debugger. +pickle Pickling (save and restore) of Python objects (a faster + Cimplementation exists in built-in module: cPickle). +pipes Conversion pipeline templates. +[DEL:poly:DEL] [DEL:Polynomials.:DEL] +popen2 variations on pipe open. +poplib A POP3 client class. Based on the J. Myers POP3 draft. +posixfile Extended (posix) file operations. +posixpath Common operations on POSIX pathnames. +pprint Support to pretty-print lists, tuples, & dictionaries + recursively. +profile Class for profiling python code. +pstats Class for printing reports on profiled python code. +pty Pseudo terminal utilities. +pyexpat Interface to the Expay XML parser. +py_compile Routine to "compile" a .py file to a .pyc file. +pyclbr Parse a Python file and retrieve classes and methods. +Queue A multi-producer, multi-consumer queue. +quopri Conversions to/from quoted-printable transport encoding. +rand Don't use unless you want compatibility with C's rand(). +random Random variable generators (obsolete, use whrandom) +re Regular Expressions. +reconvert Convert old ("regex") regular expressions to new syntax + ("re"). +regex_syntax Flags for regex.set_syntax(). +regexp Backward compatibility for module "regexp" using "regex". +regsub Regular expression subroutines. +repr Redo repr() but with limits on most sizes. +rexec Restricted execution facilities ("safe" exec, eval, etc). +rfc822 RFC-822 message manipulation class. +rlcompleter Word completion for GNU readline 2.0. +robotparser Parse robot.txt files, useful for web spiders. +sched A generally useful event scheduler class. +sgmllib A parser for SGML. +shelve Manage shelves of pickled objects. +shlex Lexical analyzer class for simple shell-like syntaxes. +shutil Utility functions usable in a shell-like program. +SimpleHTTPServer Simple extension to base http class +site Append module search paths for third-party packages to + sys.path. +smtplib SMTP Client class (RFC 821) +sndhdr Several routines that help recognizing sound. +SocketServer Generic socket server classes. +stat Constants and functions for interpreting stat/lstat struct. +statcache Maintain a cache of file stats. +statvfs Constants for interpreting statvfs struct as returned by + os.statvfs()and os.fstatvfs() (if they exist). +string A collection of string operations. +StringIO File-like objects that read/write a string buffer (a fasterC + implementation exists in built-in module: cStringIO). +sunau Stuff to parse Sun and NeXT audio files. +sunaudio Interpret sun audio headers. +symbol Non-terminal symbols of Python grammar (from "graminit.h"). +tabnanny,/font> Check Python source for ambiguous indentation. +telnetlib TELNET client class. Based on RFC 854. +tempfile Temporary file name allocation. +threading Proposed new higher-level threading interfaces +threading_api (doc of the threading module) +toaiff Convert "arbitrary" sound files to AIFF files . +token Tokens (from "token.h"). +tokenize Compiles a regular expression that recognizes Python tokens. +traceback Format and print Python stack traces. +tty Terminal utilities. +turtle LogoMation-like turtle graphics +types Define names for all type symbols in the std interpreter. +tzparse Parse a timezone specification. +unicodedata Interface to unicode properties. +urllib Open an arbitrary URL. +urlparse Parse URLs according to latest draft of standard. +user Hook to allow user-specified customization code to run. +UserDict A wrapper to allow subclassing of built-in dict class. +UserList A wrapper to allow subclassing of built-in list class. +UserString A wrapper to allow subclassing of built-in string class. +[DEL:util:DEL] [DEL:some useful functions that don't fit elsewhere !!:DEL] +uu UUencode/UUdecode. +wave Stuff to parse WAVE files. +webbrowser Platform independent URL launcher. +[DEL:whatsound: [DEL:Several routines that help recognizing sound files.:DEL] +DEL] +whichdb Guess which db package to use to open a db file. +whrandom Wichmann-Hill random number generator. +xdrlib Implements (a subset of) Sun XDR (eXternal Data + Representation) +xmllib A parser for XML, using the derived class as static DTD. +xml.dom Classes for processing XML using the Document Object Model. +xml.sax Classes for processing XML using the SAX API. +zipfile Read & write PK zipped files. +[DEL:zmod:DEL] [DEL:Demonstration of abstruse mathematical concepts.:DEL] + + + +(following list not revised) + +* Built-ins * + + sys Interpreter state vars and functions + __built-in__ Access to all built-in python identifiers + __main__ Scope of the interpreters main program, script or stdin + array Obj efficiently representing arrays of basic values + math Math functions of C standard + time Time-related functions + regex Regular expression matching operations + marshal Read and write some python values in binary format + struct Convert between python values and C structs + +* Standard * + + getopt Parse cmd line args in sys.argv. A la UNIX 'getopt'. + os A more portable interface to OS dependent functionality + re Functions useful for working with regular expressions + string Useful string and characters functions and exceptions + whrandom Wichmann-Hill pseudo-random number generator + thread Low-level primitives for working with process threads + threading idem, new recommanded interface. + +* Unix/Posix * + + dbm Interface to Unix ndbm database library + grp Interface to Unix group database + posix OS functionality standardized by C and POSIX standards + posixpath POSIX pathname functions + pwd Access to the Unix password database + select Access to Unix select multiplex file synchronization + socket Access to BSD socket interface + +* Tk User-interface Toolkit * + + tkinter Main interface to Tk + +* Multimedia * + + audioop Useful operations on sound fragments + imageop Useful operations on images + jpeg Access to jpeg image compressor and decompressor + rgbimg Access SGI imglib image files + +* Cryptographic Extensions * + + md5 Interface to RSA's MD5 message digest algorithm + mpz Interface to int part of GNU multiple precision library + rotor Implementation of a rotor-based encryption algorithm + +* Stdwin * Standard Window System + + stdwin Standard Window System interface + stdwinevents Stdwin event, command, and selection constants + rect Rectangle manipulation operations + +* SGI IRIX * (4 & 5) + + al SGI audio facilities + AL al constants + fl Interface to FORMS library + FL fl constants + flp Functions for form designer + fm Access to font manager library + gl Access to graphics library + GL Constants for gl + DEVICE More constants for gl + imgfile Imglib image file interface + +* Suns * + + sunaudiodev Access to sun audio interface + + +Workspace exploration and idiom hints + + dir(<module>) list functions, variables in <module> + dir() get object keys, defaults to local name space + X.__methods__ list of methods supported by X (if any) + X.__members__ List of X's data attributes + if __name__ == '__main__': main() invoke main if running as script + map(None, lst1, lst2, ...) merge lists + b = a[:] create copy of seq structure + _ in interactive mode, is last value printed + + + + + + + +Python Mode for Emacs + +(Not revised, possibly not up to date) +Type C-c ? when in python-mode for extensive help. +INDENTATION +Primarily for entering new code: + TAB indent line appropriately + LFD insert newline, then indent + DEL reduce indentation, or delete single character +Primarily for reindenting existing code: + C-c : guess py-indent-offset from file content; change locally + C-u C-c : ditto, but change globally + C-c TAB reindent region to match its context + C-c < shift region left by py-indent-offset + C-c > shift region right by py-indent-offset +MARKING & MANIPULATING REGIONS OF CODE +C-c C-b mark block of lines +M-C-h mark smallest enclosing def +C-u M-C-h mark smallest enclosing class +C-c # comment out region of code +C-u C-c # uncomment region of code +MOVING POINT +C-c C-p move to statement preceding point +C-c C-n move to statement following point +C-c C-u move up to start of current block +M-C-a move to start of def +C-u M-C-a move to start of class +M-C-e move to end of def +C-u M-C-e move to end of class +EXECUTING PYTHON CODE +C-c C-c sends the entire buffer to the Python interpreter +C-c | sends the current region +C-c ! starts a Python interpreter window; this will be used by + subsequent C-c C-c or C-c | commands +VARIABLES +py-indent-offset indentation increment +py-block-comment-prefix comment string used by py-comment-region +py-python-command shell command to invoke Python interpreter +py-scroll-process-buffer t means always scroll Python process buffer +py-temp-directory directory used for temp files (if needed) +py-beep-if-tab-change ring the bell if tab-width is changed + + +The Python Debugger + +(Not revised, possibly not up to date, see 1.5.2 Library Ref section 9.1; in 1.5.2, you may also use debugger integrated in IDLE) + +Accessing + +import pdb (it's a module written in Python) + -- defines functions : + run(statement[,globals[, locals]]) + -- execute statement string under debugger control, with optional + global & local environment. + runeval(expression[,globals[, locals]]) + -- same as run, but evaluate expression and return value. + runcall(function[, argument, ...]) + -- run function object with given arg(s) + pm() -- run postmortem on last exception (like debugging a core file) + post_mortem(t) + -- run postmortem on traceback object <t> + + -- defines class Pdb : + use Pdb to create reusable debugger objects. Object + preserves state (i.e. break points) between calls. + + runs until a breakpoint hit, exception, or end of program + If exception, variable '__exception__' holds (exception,value). + +Commands + +h, help + brief reminder of commands +b, break [<arg>] + if <arg> numeric, break at line <arg> in current file + if <arg> is function object, break on entry to fcn <arg> + if no arg, list breakpoints +cl, clear [<arg>] + if <arg> numeric, clear breakpoint at <arg> in current file + if no arg, clear all breakpoints after confirmation +w, where + print current call stack +u, up + move up one stack frame (to top-level caller) +d, down + move down one stack frame +s, step + advance one line in the program, stepping into calls +n, next + advance one line, stepping over calls +r, return + continue execution until current function returns + (return value is saved in variable "__return__", which + can be printed or manipulated from debugger) +c, continue + continue until next breakpoint +a, args + print args to current function +rv, retval + prints return value from last function that returned +p, print <arg> + prints value of <arg> in current stack frame +l, list [<first> [, <last>]] + List source code for the current file. + Without arguments, list 11 lines around the current line + or continue the previous listing. + With one argument, list 11 lines starting at that line. + With two arguments, list the given range; + if the second argument is less than the first, it is a count. +whatis <arg> + prints type of <arg> +! + executes rest of line as a Python statement in the current stack frame +q quit + immediately stop execution and leave debugger +<return> + executes last command again +Any input debugger doesn't recognize as a command is assumed to be a +Python statement to execute in the current stack frame, the same way +the exclamation mark ("!") command does. + +Example + +(1394) python +Python 1.0.3 (Sep 26 1994) +Copyright 1991-1994 Stichting Mathematisch Centrum, Amsterdam +>>> import rm +>>> rm.run() +Traceback (innermost last): + File "<stdin>", line 1 + File "./rm.py", line 7 + x = div(3) + File "./rm.py", line 2 + return a / r +ZeroDivisionError: integer division or modulo +>>> import pdb +>>> pdb.pm() +> ./rm.py(2)div: return a / r +(Pdb) list + 1 def div(a): + 2 -> return a / r + 3 + 4 def run(): + 5 global r + 6 r = 0 + 7 x = div(3) + 8 print x +[EOF] +(Pdb) print r +0 +(Pdb) q +>>> pdb.runcall(rm.run) +etc. + +Quirks + +Breakpoints are stored as filename, line number tuples. If a module is reloaded +after editing, any remembered breakpoints are likely to be wrong. + +Always single-steps through top-most stack frame. That is, "c" acts like "n". - @ * Standard * - getopt Parse cmd line args in sys.argv. A la UNIX 'getopt'. - os Portable interface to OS dependent functionality - pdb text-oriented debugger - rand Pseudo-random generator, like C rand() - regsub Functions useful for working with regular expressions - string Useful string and characters functions and exceptions - wdb window-oriented debugger - whrandom Wichmann-Hill pseudo-random number generator - - @ * Miscellaneous * - - dis Python disassembler - glob Filename globbing (a la unix shell) - grep File string search - posixpath Common operations on POSIX pathnames - profile Python code profiler - repr `...` repr operator with presentation constraints - string All of builtin 'strop', plus - tb Traceback browser and printer - tempfile Produce a temporary-file name - util Miscellaneous functions that don't belong elsewhere - - @ * Unix * - - dbm Dict/file-like interface to Unix ndbm database library - grp Interface to Unix group database - posix Standardized UNIX OS functionality - see 'os', above - posixpath POSIX pathname functions - see 'os', above - pwd Access to the Unix password database - select Access to Unix select multiplex file synchronization - socket Access to BSD socket interface - thread Low-level primitives for working with process threads - - @ * Multimedia * - - audioop Useful operations on sound fragments - imageop Useful operations on images - jpeg Access to jpeg image compressor and decompressor - rgbimg Access SGI imglib image files - - @ * Cryptographic Extensions * - - md5 Interface to RSA's MD5 message digest algorithm - mpz Interface to int part of GNU multiple precision library - rotor Implementation of a rotor-based encryption algorithm - - @ * Stdwin * Standard Window System - - stdwin Standard Window System interface - stdwinevents Stdwin event, command, and selection constants - rect Rectangle manipulation operations - - @ * SGI IRIX * (4 & 5) - - al SGI audio facilities - AL al constants - fl Interface to FORMS library - FL fl constants - flp Functions for form designer - fm Access to font manager library - gl Access to graphics library - GL Constants for gl - DEVICE More constants for gl - imgfile Imglib image file interface - - @ * Suns * - - sunaudiodev Access to sun audio interface - - @ * Contrib * - - syslog - - metalbase - - Idioms and hints - ================ - - Invoke main if running as script: if __name__ == '__main__': main() - - General object-type miscellany - What type is someobj; eg, a list: if type(someobj) == type([]): - Convert number to hex or octal string: hex(122) => '0x7a' - Convert string to number: eval('0x7a') => 122 - - Sequence Slice conceptualization: - +---+---+---+---+---+ Indices point ~between~ chars: - | s | t | u | f | f | - first char's left edge = 0, - +---+---+---+---+---+ - nth char's right edge = n. - 0 1 2 3 4 5 (Note that -0 == 0, so it does - -5 -4 -3 -2 -1 not count from right.) - - Sequences miscellany: - Create merge of lists: map(None, lst1, lst2, ...) - It's faster to list.append(elem) than to list[len(list):] = [elem] - Copy structure of seq a to b: b = a[:] - - Comma (tuple vs expression grouping) nuances: - to specify a tuple of one element: ('element',) - to specify a tuple containing 1 tuple: (('contained', 'tuple'),) - "TypeError: call of non-function" often means a list missing a comma - - Namespace and object surveillance: - get dictful object keys/key-vals: dir(), vars() - Current context globals: eval(__name__ + '.__dict__') - Current context locals: vars() - Methods supported by X (some objs): X.__methods__ - X's data attributes (some objs): X.__members__ |