Update cheatsheet to 2.0 from Brunning/Gruet's quick reference
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
+ Python 2.0 Quick Reference
- $Revision$ $Date$ ken.manheimer@nist.gov
- Notable lexical entities
- ========================
- Keywords
+ 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
- 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
+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
+ \\ 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
- Illegitimate Tokens (only valid in strings): @ $ ?
+ * 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.
- Operating environment (Unix)
+Numbers
- Shell environment vars:
+ 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)
- PYTHONPATH: dirs to be prepended to module search path; a la shell PATH
- PYTHONSTARTUP: names path of file to be loaded on interactive startup
+Sequences
- Internal (module sys) vars ('import sys' to refer to them):
+ * 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]
- 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
+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'.
- Objects - behaviors, special attributes, operations, statements, etc
- ====================================================================
+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.
- General object aspects
+Dictionaries (Mappings)
- Boolean values and operators
+ Dictionary of length 0, 1, 2, etc:
+ {} {1 : 'first'} {1 : 'first', 'next': 'second'}
- False values: None, numeric zeros, empty sequences and mappings
- True values: all other values
+Operators and their evaluation order
- 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
+ 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
- Special methods for any type (s: self)
+Alternate names are defined in module operator (e.g. __add__ and add for +)
+Most operators are overridable
- 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:
+Basic Types and Their Operations
- 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
+Comparisons (defined between *any* types)
- General Name Space behavior and binding
+ 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).
- Name space search order: local, global, builtin
+ 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.)
+()
- "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)
+ 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)
- 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
+ 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'
- Binding operations and exceptions:
+ 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.
- ~ 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)
+ posix
+don't import this module directly, import os instead !
+(see also module: shutil for file copy & remove fcts)
- Name space linkage
+ 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.
- global statement: global var, ... # Interpret 'var's as globals
- X access statement: access ... # control inst and class vars access
+ 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.
- @ 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 ****
+ posixpath
+Do not import this module directly, import os instead and refer to this module
+as os.path. (e.g. os.path.exists(p)) !
- @ Integers: 'C' long, >= 32 bits precision; OverflowError if bounds exceeded
- @ Long Integers: unlimited precision - '2147483648L'
- @ Floating point: machine double-precision floating point - '2147483648.0'
+ 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.
- 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:
+ shutil
+high-level file operations (copying, deleting).
- 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
+ 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
- Numeric exceptions:
+(and also: copyfile, copymode, copystat, copy2)
- ~ 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
+time
- **** Collections - Sequences and Mappings ****
+ 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
- Collections general operations vs methods (s: self, i: index or key)
+ 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.
- len(s) = __len__(s) length of object, >= 0. Length 0 == false
- s[i] = __getitem__(s,i) Element at index/key i, origin 0
+and also: clock, ctime.
- Sequences
+ string
- @ String (immutable sequence): 'string contents'
+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.
- '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.'''
+ 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.
- `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
+ 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.
- @ 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]
+ re (sre)
- assignment - must be 1-1 map of items in target and object sequences
- deletion - similar rules as for assignment
+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.
- List special methods: see mutable sequence ops vs methods, below
- Sequences general ops vs methods (s: self, i,j: indices, v: val)
+ 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.
- 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'
+ 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
- Immutable sequence ops vs methods (s: self, i,j: indices, v: val)
+ Variables
+Variable Meaning
+error Exception when pattern string isn't a valid regexp.
- 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)
+ Functions
+ Function Result
+ Compile a RE pattern string into a regular expression object.
+ Flags (combinable by |):
- Mutable sequence ops vs methods (s: self, i,j: indices, v: val)
+ 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])
- 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
+Regular Expression Objects
- Mappings
- @ Dictionaries: {key1: val1, key2: val2, ...}
+(RE objects are returned by the compile fct)
- 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)
+ 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
- Dictionaries ops vs methods (s: self, k: key, v: val)
+ 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])
- 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)
+Match Objects
- **** Callables ****
- @ User defined functions: 'def name (param-list): suite'
+(Match objects are returned by the match & search functions)
- 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
+ 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()
- @ User defined methods: like functions, with extra implicit arg
+ 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.
- 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
+ math
- @ Class instances
+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)
- __dict__: ro attr, class' attribute dictionary
- __class__: ro attr, instance's class object
+ getopt
- Callables special method vs ops (f: function)
+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']
- 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' ****
+List of modules and packages in base distribution
- @ **** Type objects, print as: <type 'int'> ****
- ( '<...>' form is only for printing - cannot be entered that way,
+(built-ins and content of python Lib directory)
+(Python NT distribution, may be slightly different in other distributions)
- 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)
+ 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]
- @ **** 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
+(following list not revised)
- __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
+* Built-ins *
- @ **** Files ****
+ 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
- wrapper around a C stdio file pointer
- sys.stdin, sys.stdout, sys.stderr are standard io-stream file objects
+* Standard *
- File operations:
+ 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.
- 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.
+* Unix/Posix *
- File functions:
+ 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
- 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
+* Tk User-interface Toolkit *
- **** Internal types ****
+ tkinter Main interface to Tk
- @ 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
+* Multimedia *
- Control statements
- ==================
+ 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
- * Calls and Evaluation *
+* Cryptographic Extensions *
- ( See also Callables, in Objects section above, for ops and methods.)
+ 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
- exec: exec expr [ in expr2 [, expr3]] # Dynamic execution of python code
- return: return [expr] # Leave current func call with expr value
+* Stdwin * Standard Window System
- * Conditionals and Loops *
- ( See also Boolean values, above)
+ stdwin Standard Window System interface
+ stdwinevents Stdwin event, command, and selection constants
+ rect Rectangle manipulation operations
- 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 ]
+* SGI IRIX * (4 & 5)
- * Exceptions *
+ 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
- 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)
+* Suns *
- System modules
- ==============
- @ * Built-ins *
+ sunaudiodev Access to sun audio interface
- 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
- @ * Standard *
+Workspace exploration and idiom hints
- 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
+ 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
- @ * 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 *
+Python Mode for Emacs
- 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
+(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
- @ * Stdwin * Standard Window System
- stdwin Standard Window System interface
- stdwinevents Stdwin event, command, and selection constants
- rect Rectangle manipulation operations
+The Python Debugger
- @ * SGI IRIX * (4 & 5)
+(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)
- 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
+Accessing
- @ * Suns *
+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>
- sunaudiodev Access to sun audio interface
+ -- defines class Pdb :
+ use Pdb to create reusable debugger objects. Object
+ preserves state (i.e. break points) between calls.
- @ * Contrib *
+ runs until a breakpoint hit, exception, or end of program
+ If exception, variable '__exception__' holds (exception,value).
- syslog
+Commands
- metalbase
+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.
- Idioms and hints
- ================
+Example
- Invoke main if running as script: if __name__ == '__main__': main()
+(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.
- 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
+Quirks
- 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.)
+Breakpoints are stored as filename, line number tuples. If a module is reloaded
+after editing, any remembered breakpoints are likely to be wrong.
- 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[:]
+Always single-steps through top-most stack frame. That is, "c" acts like "n".
- 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__