mirrors/cpython
mirrors/cpython
0
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2024-11-24 17:47:13 +01:00
Code Issues Releases Activity
43baef41fd
cpython/Misc/cheatsheet
Georg Brandl 029986af24 Fix old urllib/urllib2/urlparse usage.
2008-06-23 11:44:14 +00:00

2182 lines
98 KiB
Plaintext
Raw Blame History

Python 2.3 Quick Reference
25 Jan 2003 upgraded by Raymond Hettinger for Python 2.3
16 May 2001 upgraded by Richard Gruet and Simon Brunning for Python 2.0
2000/07/18 upgraded by Richard Gruet, rgruet@intraware.com for Python 1.5.2
from V1.3 ref
1995/10/30, by Chris Hoffmann, choffman@vicorp.com
Based on:
Python Bestiary, Author: Ken Manheimer, ken.manheimer@nist.gov
Python manuals, Authors: Guido van Rossum and Fred Drake
What's new in Python 2.0, Authors: A.M. Kuchling and Moshe Zadka
python-mode.el, Author: Tim Peters, tim_one@email.msn.com
and the readers of comp.lang.python
Python's nest: http://www.python.org Developement: http://
python.sourceforge.net/ ActivePython : http://www.ActiveState.com/ASPN/
Python/
newsgroup: comp.lang.python Help desk: help@python.org
Resources: http://starship.python.net/
http://www.vex.net/parnassus/
http://aspn.activestate.com/ASPN/Cookbook/Python
FAQ: http://www.python.org/cgi-bin/faqw.py
Full documentation: http://www.python.org/doc/
Excellent reference books:
Python Essential Reference by David Beazley (New Riders)
Python Pocket Reference by Mark Lutz (O'Reilly)
Invocation Options
python [-diOStuUvxX?] [-c command | script | - ] [args]
Invocation Options
Option Effect
-c cmd program passed in as string (terminates option list)
-d Outputs parser debugging information (also PYTHONDEBUG=x)
-E ignore environment variables (such as PYTHONPATH)
-h print this help message and exit
-i Inspect interactively after running script (also PYTHONINSPECT=x) and
force prompts, even if stdin appears not to be a terminal
-m mod run library module as a script (terminates option list
-O optimize generated bytecode (a tad; also PYTHONOPTIMIZE=x)
-OO remove doc-strings in addition to the -O optimizations
-Q arg division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew
-S Don't perform 'import site' on initialization
-u Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x).
-v Verbose (trace import statements) (also PYTHONVERBOSE=x)
-W arg : warning control (arg is action:message:category:module:lineno)
-x Skip first line of source, allowing use of non-unix Forms of #!cmd
-? 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 yield
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) \OOO char with octal value OOO
\" Double quote (") \n Linefeed (LF)
\a Bell (BEL) \r Carriage Return (CR) \xHH char with hex value HH
\b Backspace (BS) \t Horizontal Tab (TAB)
\uHHHH unicode char with hex value HHHH, can only be used in unicode string
\UHHHHHHHH unicode char with hex value HHHHHHHH, can only be used in unicode string
\AnyOtherChar is left as-is
* NUL byte (\000) is NOT an end-of-string marker; NULs may be embedded in
strings.
* Strings (and tuples) are immutable: they cannot be modified.
Numbers
Decimal integer: 1234, 1234567890546378940L (or l)
Octal integer: 0177, 0177777777777777777 (begin with a 0)
Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFF (begin with 0x or 0X)
Long integer (unlimited precision): 1234567890123456
Float (double precision): 3.14e-10, .001, 10., 1E3
Complex: 1J, 2+3J, 4+5j (ends with J or j, + separates (float) real and
imaginary parts)
Sequences
* String of length 0, 1, 2 (see above)
'', '1', "12", 'hello\n'
* Tuple of length 0, 1, 2, etc:
() (1,) (1,2) # parentheses are optional if len > 0
* List of length 0, 1, 2, etc:
[] [1] [1,2]
Indexing is 0-based. Negative indices (usually) mean count backwards from end
of sequence.
Sequence slicing [starting-at-index : but-less-than-index]. Start defaults to
'0'; End defaults to 'sequence-length'.
a = (0,1,2,3,4,5,6,7)
a[3] ==> 3
a[-1] ==> 7
a[2:4] ==> (2, 3)
a[1:] ==> (1, 2, 3, 4, 5, 6, 7)
a[:3] ==> (0, 1, 2)
a[:] ==> (0,1,2,3,4,5,6,7) # makes a copy of the sequence.
Dictionaries (Mappings)
{} # Zero length empty dictionary
{1 : 'first'} # Dictionary with one (key, value) pair
{1 : 'first', 'next': 'second'}
dict([('one',1),('two',2)]) # Construct a dict from an item list
dict('one'=1, 'two'=2) # Construct a dict using keyword args
dict.fromkeys(['one', 'keys']) # Construct a dict from a sequence
Operators and their evaluation order
Operators and their evaluation order
Highest Operator Comment
(...) [...] {...} `...` Tuple, list & dict. creation; string
conv.
s[i] s[i:j] s.attr f(...) indexing & slicing; attributes, fct
calls
+x, -x, ~x Unary operators
x**y Power
x*y x/y x%y x//y mult, division, modulo, floor division
x+y x-y addition, subtraction
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 is y x is not y membership
x in s x not in s
not x boolean negation
x and y boolean and
x or y boolean or
Lowest lambda args: expr anonymous function
Alternate names are defined in module operator (e.g. __add__ and add for +)
Most operators are overridable.
Many binary operators also support augmented assignment:
x += 1 # Same as x = x + 1
Basic Types and Their Operations
Comparisons (defined between *any* types)
Comparisons
Comparison Meaning Notes
< strictly less than (1)
<= less than or equal to
> strictly greater than
>= greater than or equal to
== equal to
!= 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__.
The above comparisons return True or False which are of type bool
(a subclass of int) and behave exactly as 1 or 0 except for their type and
that they print as True or False instead of 1 or 0.
(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 __bool__.
(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 and integers.
Floats are implemented with C doubles.
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
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
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
FloatingPointError
raised when a floating point operation fails
Operations on all sequence types (lists, tuples, strings)
Operations on all sequence types
Operation Result Notes
x in s True if an item of s is equal to x, else False
x not in s False if an item of s is equal to x, else True
for x in s: loops over the sequence
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)
iter(s) returns an iterator over s. iterators define __iter__ and next()
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.count(x) return number of i's for which s[i] == x
s.extend(x) same as s[len(s):len(s)]= 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.pop([i]) same as x = s[i]; del s[i]; return x (4)
s.remove(x) same as del s[s.index(x)] (1)
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 optional argument i defaults to -1, so that by default the last
item is removed and returned.
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.get(k,defaultval) the item of d with key k (4)
d.has_key(k) True if d has key k, else False
d.items() a copy of d's list of (key, item) pairs (2)
d.iteritems() an iterator over (key, value) pairs (7)
d.iterkeys() an iterator over the keys of d (7)
d.itervalues() an iterator over the values of d (7)
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.pop(k) remove d[k] and return its value
d.popitem() remove and return an arbitrary (6)
(key, item) pair
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.
(6) Raises a KeyError if the dictionary is emtpy.
(7) While iterating over a dictionary, the values may be updated but
the keys cannot be changed.
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.decode(([ return a decoded version of s. (3)
encoding
[,errors]])
s.encode([ return an encoded version of s. Default encoding is the
encoding current default string encoding. (3)
[,errors]])
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.
s.zfill(width) return a string padded with zeroes on the left side and
sliding a minus sign left if necessary. never truncates.
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 hexadecimal (lowercase).
X Unsigned hexadecimal (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() True if file f is connected to a tty-like dev, else False.
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.
OSError
OS system call failed.
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.
yield result -- Freezes the execution frame of a generator and returns the result
to the iterator's .__next__() method. Upon the next call to __next__(),
resumes execution at the frozen point with all of the local variables
still intact.
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 Exception, itself
derived from BaseException.
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() 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.
bool(x) Returns True when the argument x is true and False otherwise.
buffer(obj) Creates a buffer reference to an object.
chr(i) Returns one-character string whose ASCII code isinteger i
classmethod(f) Converts a function f, into a method with the class as the
first argument. Useful for creating alternative constructors.
cmp(x,y) Returns negative, 0, positive if x <, ==, > to y
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
that evaluate 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
dict([items]) Create a new dictionary from the specified item list.
dir([object]) local symbol table. With a module, class or class
instance object as arg, returns list of names in its attr.
dict.
divmod(a,b) Returns tuple of (a/b, a%b)
enumerate(seq) Return a iterator giving: (0, seq[0]), (1, seq[1]), ...
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')
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,
raises AttributeError 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)
help(f) Display documentation on object f.
hex(x) Converts a number x to a hexadecimal string.
id(object) Returns a unique 'identity' integer for an object.
int(x[, base]) base paramenter specifies base from which to convert string
values.
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
iter(collection) Returns an iterator over the collection.
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.
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.
object() Create a base type. Used as a superclass for new-style objects.
open(name Open a file.
[, mode
[, buffering]])
pow(x, y [, z]) Returns x to power y [modulo z]. See also ** operator.
property() Created a property with access controlled by functions.
range(start [,end Returns list of ints from >= start and < end. With 1 arg,
[, step]]) list from 0..arg-1. With 2 args, list from start..end-1.
With 3 args, list from start up to end by step
after fixing it.
repr(object) Returns a string containing a printable and if possible
evaluable representation of an object.
Class redefinable (__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 = 3. Creates attribute if it doesn't exist!
slice([start,] stop Returns a slice object representing a range, with R/
[, step]) O attributes: start, stop, step.
staticmethod() Convert a function to method with no self or class
argument. Useful for methods associated with a class that
do not need access to an object's internal state.
str(object) Returns a string containing a nicely
printable representation of an object. Class overridable
(__str__).See also repr().
super(type) Create an unbound super object. Used to call cooperative
superclass methods.
sum(sequence, Add the values in the sequence and return the sum.
[start])
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.
zip(seq1[, seq2, Returns an iterator 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()'
StopIteration
Signal the end from iterator.__next__()
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
Warning
UserWarning
DeprecationWarning
PendingDeprecationWarning
SyntaxWarning
RuntimeWarning
FutureWarning
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
__bool__(s) Returns False or True 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)
bool(s) = __bool__(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)
float(s) = __float__(s) complex(s) = __complex__(s)
oct(s) = __oct__(s) hex(s) = __hex__(s)
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:
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)
Classes: [in bold: writable since 1.5.2]
__doc__ (string/None, R/W): doc string (<=> __dict__['__doc__'])
__module__ is the module name in which the class was defined
__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
func_dict (dict, R/W): same as __dict__ contains the namespace supporting
arbitrary function attributes
func_closure (R/O): None or a tuple of cells that contain bindings
for the function's free 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
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_cellvars (tuple, R/O)) the names of local variables referenced by
nested functions
co_freevars (tuple, R/O)) names of free variables
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_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
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 occurred
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
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)
last_type, Set only when an exception not handled andinterpreter
last_value, prints an error. Used by debuggers.
last_traceback
maxint maximum positive value for integers
modules Dictionary of modules that have already been loaded.
path Search path for external modules. Can be modifiedby
program. sys.path[0] == dir of script executing
platform The current platform, e.g. "sunos5", "win32"
ps1, ps2 prompts to use in interactive mode.
File objects used for I/O. One can redirect byassigning a
stdin, stdout, new file object to them (or any object:.with a method
stderr write(string) for stdout/stderr,.with a method readline()
for stdin)
version string containing version info about Python interpreter.
(and also: copyright, dllhandle, exec_prefix, prefix)
version_info tuple containing Python version info - (major, minor,
micro, level, serial).
Some sys functions
Function Result
exit(n) Exits with status n. Raises SystemExit exception.(Hence can
be caught and ignored by program)
getrefcount(object Returns the reference count of the object. Generally one
) higher than you might expect, because of object arg temp
reference.
setcheckinterval( Sets the interpreter's thread switching interval (in number
interval) of virtual code instructions, default:100).
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 local variable in a
function handling an exception will cause a circular
reference.
setdefaultencoding Change default Unicode encoding - defaults to 7-bit ASCII.
(encoding)
getrecursionlimit Retrieve maximum recursion depth.
()
setrecursionlimit Set maximum recursion depth. (Defaults to 1000.)
()
os
"synonym" for whatever O/S-specific module is proper for current environment.
this module uses posix whenever possible.
(see also M.A. Lemburg's utility http://www.lemburg.com/files/python/
platform.py)
Some os variables
Variable Meaning
name name of O/S-specific module (e.g. "posix", "mac", "nt")
path O/S-specific module for path manipulations.
On Unix, os.path.split() <=> posixpath.split()
curdir string used to represent current directory ('.')
pardir string used to represent parent directory ('..')
sep string used to separate directories ('/' or '\'). Tip: use
os.path.join() to build portable paths.
altsep Alternate sep
if applicable (None
otherwise)
pathsep character used to separate search path components (as in
$PATH), eg. ';' for windows.
linesep line separator as used in binary files, ie '\n' on Unix, '\
r\n' on Dos/Win, '\r'
Some os functions
Function Result
makedirs(path[, Recursive directory creation (create required intermediary
mode=0777]) dirs); os.error if fails.
removedirs(path) Recursive directory delete (delete intermediary empty
dirs); if fails.
renames(old, new) Recursive directory or file renaming; os.error if fails.
posix
don't import this module directly, import os instead !
(see also module: shutil for file copy & remove fcts)
posix Variables
Variable Meaning
environ dictionary of environment variables, e.g.posix.environ['HOME'].
error exception raised on POSIX-related error.
Corresponding value is tuple of errno code and perror() string.
Some posix functions
Function Result
chdir(path) Changes current directory to path.
chmod(path, Changes the mode of path to the numeric mode
mode)
close(fd) Closes file descriptor fd opened with posix.open.
_exit(n) Immediate exit, with no cleanups, no SystemExit,etc. Should use
this to exit a child process.
execv(p, args) "Become" executable p with args args
getcwd() Returns a string representing the current working directory
getpid() Returns the current process id
fork() Like C's fork(). Returns 0 to child, child pid to parent.[Not
on Windows]
kill(pid, Like C's kill [Not on Windows]
signal)
listdir(path) Lists (base)names of entries in directory path, excluding '.'
and '..'
lseek(fd, pos, Sets current position in file fd to position pos, expressedas
how) an offset relative to beginning of file (how=0), tocurrent
position (how=1), or to end of file (how=2)
mkdir(path[, Creates a directory named path with numeric mode (default 0777)
mode])
open(file, Like C's open(). Returns file descriptor. Use file object
flags, mode) fctsrather than this low level ones.
pipe() Creates a pipe. Returns pair of file descriptors (r, w) [Not on
Windows].
popen(command, Opens a pipe to or from command. Result is a file object to
mode='r', read to orwrite from, as indicated by mode being 'r' or 'w'.
bufSize=0) Use it to catch acommand output ('r' mode) or to feed it ('w'
mode).
remove(path) See unlink.
rename(src, dst Renames/moves the file or directory src to dst. [error iftarget
) name already exists]
rmdir(path) Removes the empty directory path
read(fd, n) Reads n bytes from file descriptor fd and return as string.
Returns st_mode, st_ino, st_dev, st_nlink, st_uid,st_gid,
stat(path) st_size, st_atime, st_mtime, st_ctime.[st_ino, st_uid, st_gid
are dummy on Windows]
system(command) Executes string command in a subshell. Returns exitstatus of
subshell (usually 0 means OK).
Returns accumulated CPU times in sec (user, system, children's
times() user,children's sys, elapsed real time). [3 last not on
Windows]
unlink(path) Unlinks ("deletes") the file (not dir!) path. same as: remove
utime(path, ( Sets the access & modified time of the file to the given tuple
aTime, mTime)) of values.
wait() Waits for child process completion. Returns tuple ofpid,
exit_status [Not on Windows]
waitpid(pid, Waits for process pid to complete. Returns tuple ofpid,
options) exit_status [Not on Windows]
write(fd, str) Writes str to file fd. Returns nb of bytes written.
posixpath
Do not import this module directly, import os instead and refer to this module
as os.path. (e.g. os.path.exists(p)) !
Some posixpath functions
Function Result
abspath(p) Returns absolute path for path p, taking current working dir in
account.
dirname/
basename(p directory and name parts of the path p. See also split.
)
exists(p) True if string p is an existing path (file or directory)
expanduser Returns string that is (a copy of) p with "~" expansion done.
(p)
expandvars Returns string that is (a copy of) p with environment vars expanded.
(p) [Windows: case significant; must use Unix: $var notation, not %var%]
getsize( return the size in bytes of filename. raise os.error.
filename)
getmtime( return last modification time of filename (integer nb of seconds
filename) since epoch).
getatime( return last access time of filename (integer nb of seconds since
filename) epoch).
isabs(p) True if string p is an absolute path.
isdir(p) True if string p is a directory.
islink(p) True if string p is a symbolic link.
ismount(p) True if string p is a mount point [true for all dirs on Windows].
join(p[,q Joins one or more path components intelligently.
[,...]])
Splits p into (head, tail) where tail is lastpathname component and
split(p) <head> is everything leadingup to that. <=> (dirname(p), basename
(p))
splitdrive Splits path p in a pair ('drive:', tail) [Windows]
(p)
splitext(p Splits into (root, ext) where last comp of root contains no periods
) and ext is empty or startswith a period.
Calls the function visit with arguments(arg, dirname, names) for
each directory recursively inthe directory tree rooted at p
walk(p, (including p itself if it's a dir)The argument dirname specifies the
visit, arg visited directory, the argumentnames lists the files in the
) directory. The visit function maymodify names to influence the set
of directories visited belowdirname, e.g., to avoid visiting certain
parts of the tree.
shutil
high-level file operations (copying, deleting).
Main shutil functions
Function Result
copy(src, dst) Copies the contents of file src to file dst, retaining file
permissions.
copytree(src, dst Recursively copies an entire directory tree rooted at src
[, symlinks]) into dst (which should not already exist). If symlinks is
true, links insrc are kept as such in dst.
rmtree(path[, Deletes an entire directory tree, ignoring errors if
ignore_errors[, ignore_errors true,or calling onerror(func, path,
onerror]]) sys.exc_info()) if supplied with
(and also: copyfile, copymode, copystat, copy2)
time
Variables
Variable Meaning
altzone signed offset of local DST timezone in sec west of the 0th meridian.
daylight nonzero if a DST timezone is specified
Functions
Function Result
time() return a float representing UTC time in seconds since the epoch.
gmtime(secs), return a tuple representing time : (year aaaa, month(1-12),day
localtime( (1-31), hour(0-23), minute(0-59), second(0-59), weekday(0-6, 0 is
secs) monday), Julian day(1-366), daylight flag(-1,0 or 1))
asctime(
timeTuple),
strftime(
format, return a formated string representing time.
timeTuple)
mktime(tuple) inverse of localtime(). Return a float.
strptime( parse a formated string representing time, return tuple as in
string[, gmtime().
format])
sleep(secs) Suspend execution for <secs> seconds. <secs> can be a float.
and also: clock, ctime.
string
As of Python 2.0, much (though not all) of the functionality provided by the
string module have been superseded by built-in string methods - see Operations
on strings for details.
Some string variables
Variable Meaning
digits The string '0123456789'
hexdigits, octdigits legal hexadecimal & octal digits
letters, uppercase, lowercase, Strings containing the appropriate
whitespace characters
index_error Exception raised by index() if substr not
found.
Some string functions
Function Result
expandtabs(s, returns a copy of string <s> with tabs expanded.
tabSize)
find/rfind(s, sub Return the lowest/highest index in <s> where the substring
[, start=0[, end= <sub> is found such that <sub> is wholly contained ins
0]) [start:end]. Return -1 if <sub> not found.
ljust/rjust/center Return a copy of string <s> left/right justified/centerd in
(s, width) afield of given width, padded with spaces. <s> is
nevertruncated.
lower/upper(s) Return a string that is (a copy of) <s> in lowercase/
uppercase
split(s[, sep= Return a list containing the words of the string <s>,using
whitespace[, the string <sep> as a separator.
maxsplit=0]])
join(words[, sep=' Concatenate a list or tuple of words with
']) interveningseparators; inverse of split.
replace(s, old, Returns a copy of string <s> with all occurrences of
new[, maxsplit=0] substring<old> replaced by <new>. Limits to <maxsplit>
firstsubstitutions if specified.
strip(s) Return a string that is (a copy of) <s> without leadingand
trailing whitespace. see also lstrip, rstrip.
re (sre)
Handles Unicode strings. Implemented in new module sre, re now a mere front-end
for compatibility.
Patterns are specified as strings. Tip: Use raw strings (e.g. r'\w*') to
litteralize backslashes.
Regular expression syntax
Form Description
. matches any character (including newline if DOTALL flag specified)
^ matches start of the string (of every line in MULTILINE mode)
$ matches end of the string (of every line in MULTILINE mode)
* 0 or more of preceding regular expression (as many as possible)
+ 1 or more of preceding regular expression (as many as possible)
? 0 or 1 occurrence of preceding regular expression
*?, +?, ?? Same as *, + and ? but matches as few characters as possible
{m,n} matches from m to n repetitions of preceding RE
{m,n}? idem, attempting to match as few repetitions as possible
[ ] defines character set: e.g. '[a-zA-Z]' to match all letters(see also
\w \S)
[^ ] defines complemented character set: matches if char is NOT in set
escapes special chars '*?+&$|()' and introduces special sequences
\ (see below). Due to Python string rules, write as '\\' orr'\' in the
pattern string.
\\ matches a litteral '\'; due to Python string rules, write as '\\\\
'in pattern string, or better using raw string: r'\\'.
| specifies alternative: 'foo|bar' matches 'foo' or 'bar'
(...) matches any RE inside (), and delimits a group.
(?:...) idem but doesn't delimit a group.
matches if ... matches next, but doesn't consume any of the string
(?=...) e.g. 'Isaac (?=Asimov)' matches 'Isaac' only if followed by
'Asimov'.
(?!...) matches if ... doesn't match next. Negative of (?=...)
(?P<name matches any RE inside (), and delimits a named group. (e.g. r'(?P
>...) <id>[a-zA-Z_]\w*)' defines a group named id)
(?P=name) matches whatever text was matched by the earlier group named name.
(?#...) A comment; ignored.
(?letter) letter is one of 'i','L', 'm', 's', 'x'. Set the corresponding flags
(re.I, re.L, re.M, re.S, re.X) for the entire RE.
Special sequences
Sequence Description
number matches content of the group of the same number; groups are numbered
starting from 1
\A matches only at the start of the string
\b empty str at beg or end of word: '\bis\b' matches 'is', but not 'his'
\B empty str NOT at beginning or end of word
\d any decimal digit (<=> [0-9])
\D any non-decimal digit char (<=> [^O-9])
\s any whitespace char (<=> [ \t\n\r\f\v])
\S any non-whitespace char (<=> [^ \t\n\r\f\v])
\w any alphaNumeric char (depends on LOCALE flag)
\W any non-alphaNumeric char (depends on LOCALE flag)
\Z matches only at the end of the string
Variables
Variable Meaning
error Exception when pattern string isn't a valid regexp.
Functions
Function Result
Compile a RE pattern string into a regular expression object.
Flags (combinable by |):
I or IGNORECASE or (?i)
case insensitive matching
compile( L or LOCALE or (?L)
pattern[, make \w, \W, \b, \B dependent on thecurrent locale
flags=0]) M or MULTILINE or (?m)
matches every new line and not onlystart/end of the whole
string
S or DOTALL or (?s)
'.' matches ALL chars, including newline
X or VERBOSE or (?x)
Ignores whitespace outside character sets
escape(string) return (a copy of) string with all non-alphanumerics
backslashed.
match(pattern, if 0 or more chars at beginning of <string> match the RE pattern
string[, flags string,return a corresponding MatchObject instance, or None if
]) no match.
search(pattern scan thru <string> for a location matching <pattern>, return
, string[, acorresponding MatchObject instance, or None if no match.
flags])
split(pattern, split <string> by occurrences of <pattern>. If capturing () are
string[, used inpattern, then occurrences of patterns or subpatterns are
maxsplit=0]) also returned.
findall( return a list of non-overlapping matches in <pattern>, either a
pattern, list ofgroups or a list of tuples if the pattern has more than 1
string) group.
return string obtained by replacing the (<count> first) lefmost
sub(pattern, non-overlapping occurrences of <pattern> (a string or a RE
repl, string[, object) in <string>by <repl>; <repl> can be a string or a fct
count=0]) called with a single MatchObj arg, which must return the
replacement string.
subn(pattern,
repl, string[, same as sub(), but returns a tuple (newString, numberOfSubsMade)
count=0])
Regular Expression Objects
(RE objects are returned by the compile fct)
re object attributes
Attribute Descrition
flags flags arg used when RE obj was compiled, or 0 if none provided
groupindex dictionary of {group name: group number} in pattern
pattern pattern string from which RE obj was compiled
re object methods
Method Result
If zero or more characters at the beginning of string match this
regular expression, return a corresponding MatchObject instance.
Return None if the string does not match the pattern; note that
this is different from a zero-length match.
The optional second parameter pos gives an index in the string
match( where the search is to start; it defaults to 0. This is not
string[, completely equivalent to slicing the string; the '' pattern
pos][, character matches at the real beginning of the string and at
endpos]) positions just after a newline, but not necessarily at the index
where the search is to start.
The optional parameter endpos limits how far the string will be
searched; it will be as if the string is endpos characters long, so
only the characters from pos to endpos will be searched for a
match.
Scan through string looking for a location where this regular
search( expression produces a match, and return a corresponding MatchObject
string[, instance. Return None if no position in the string matches the
pos][, pattern; note that this is different from finding a zero-length
endpos]) match at some point in the string.
The optional pos and endpos parameters have the same meaning as for
the match() method.
split(
string[, Identical to the split() function, using the compiled pattern.
maxsplit=
0])
findall( Identical to the findall() function, using the compiled pattern.
string)
sub(repl,
string[, Identical to the sub() function, using the compiled pattern.
count=0])
subn(repl,
string[, Identical to the subn() function, using the compiled pattern.
count=0])
Match Objects
(Match objects are returned by the match & search functions)
Match object attributes
Attribute Description
pos value of pos passed to search or match functions; index intostring at
which RE engine started search.
endpos value of endpos passed to search or match functions; index intostring
beyond which RE engine won't go.
re RE object whose match or search fct produced this MatchObj instance
string string passed to match() or search()
Match object functions
Function Result
returns one or more groups of the match. If one arg, result is a
group([g1 string;if multiple args, result is a tuple with one item per arg. If
, g2, gi is 0,return value is entire matching string; if 1 <= gi <= 99,
...]) returnstring matching group #gi (or None if no such group); gi may
also bea group name.
returns a tuple of all groups of the match; groups not
groups() participatingto the match have a value of None. Returns a string
instead of tupleif len(tuple)=1
start(
group), returns indices of start & end of substring matched by group (or
end(group Noneif group exists but doesn't contribute to the match)
)
span( returns the 2-tuple (start(group), end(group)); can be (None, None)if
group) group didn't contibute to the match.
math
Variables:
pi
e
Functions (see ordinary C man pages for info):
acos(x)
asin(x)
atan(x)
atan2(x, y)
ceil(x)
cos(x)
cosh(x)
degrees(x)
exp(x)
fabs(x)
floor(x)
fmod(x, y)
frexp(x) -- Unlike C: (float, int) = frexp(float)
ldexp(x, y)
log(x [,base])
log10(x)
modf(x) -- Unlike C: (float, float) = modf(float)
pow(x, y)
radians(x)
sin(x)
sinh(x)
sqrt(x)
tan(x)
tanh(x)
getopt
Functions:
getopt(list, optstr) -- Similar to C. <optstr> is option
letters to look for. Put ':' after letter
if option takes arg. E.g.
# invocation was "python test.py -c hi -a arg1 arg2"
opts, args = getopt.getopt(sys.argv[1:], 'ab:c:')
# opts would be
[('-c', 'hi'), ('-a', '')]
# args would be
['arg1', 'arg2']
List of modules and packages in base distribution
(built-ins and content of python Lib directory)
(Python NT distribution, may be slightly different in other distributions)
Standard library modules
Operation Result
aifc Stuff to parse AIFF-C and AIFF files.
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.
base64 Conversions to/from base64 RFC-MIME transport encoding .
bdb A generic Python debugger base class.
binhex Macintosh binhex compression/decompression.
bisect List bisection algorithms.
bz2 Support for bz2 compression/decompression.
calendar Calendar printing functions.
cgi Wraps the WWW Forms Common Gateway Interface (CGI).
cgitb Utility for handling CGI tracebacks.
cmd A generic class to build line-oriented command interpreters.
datetime Basic date and time types.
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.
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.
copyreg Helper to provide extensibility for pickle/cPickle.
csv Read and write files with comma separated values.
dbm Generic interface to all dbm clones (dbm.bsd, dbm.gnu,
dbm.ndbm, dbm.dumb).
dircache Sorted list of files in a dir, using a cache.
difflib Tool for creating delta between sequences.
dis Bytecode disassembler.
distutils Package installation system.
doctest Tool for running and verifying tests inside doc strings.
dospath Common operations on DOS pathnames.
email Comprehensive support for internet email.
filecmp File comparison.
fileinput Helper class to quickly write a loop over all standard input
files.
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.
gzip Read & write gzipped files.
heapq Priority queue implemented using lists organized as heaps.
hmac Keyed-Hashing for Message Authentication -- RFC 2104.
html.entities HTML entity definitions.
html.parser A parser for HTML and XHTML.
http.client HTTP client class.
http.server HTTP server services.
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.
inspect Tool for probing live Python objects.
keyword List of Python keywords.
linecache Cache lines from files.
locale Support for number formatting using the current locale
settings.
logging Python logging facility.
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.
mimetypes Guess the MIME type of a file.
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.
optparse A comprehensive tool for processing command line options.
os Either mac, dos or posix depending system.
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.
pkgunil Utilities for working with Python packages.
poplib A POP3 client class. Based on the J. Myers POP3 draft.
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.
pydoc Utility for generating documentation from source files.
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.
random Random variable generators
re Regular Expressions.
reprlib Redo repr() but with limits on most sizes.
rlcompleter Word completion for GNU readline 2.0.
sched A generally useful event scheduler class.
shelve Manage shelves of pickled objects.
shlex Lexical analyzer class for simple shell-like syntaxes.
shutil Utility functions usable in a shell-like program.
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.
statvfs Constants for interpreting statvfs struct as returned by
os.statvfs()and os.fstatvfs() (if they exist).
string A collection of string operations.
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 Check Python source for ambiguous indentation.
tarfile Facility for reading and writing to the *nix tarfile format.
telnetlib TELNET client class. Based on RFC 854.
tempfile Temporary file name allocation.
textwrap Object for wrapping and filling text.
threading Proposed new higher-level threading interfaces
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.parse Parse URLs according to latest draft of standard.
urllib.request Open an arbitrary URL.
urllib.robotparser Parse robots.txt files, useful for web spiders.
user Hook to allow user-specified customization code to run.
uu UUencode/UUdecode.
unittest Utilities for implementing unit testing.
wave Stuff to parse WAVE files.
weakref Tools for creating and managing weakly referenced objects.
webbrowser Platform independent URL launcher.
xdrlib Implements (a subset of) Sun XDR (eXternal Data
Representation).
xml.dom Classes for processing XML using the Document Object Model.
xml.sax Classes for processing XML using the SAX API.
xmlrpc.client Support for remote procedure calls using XML.
xmlrpc.server Create XMLRPC servers.
zipfile Read & write PK zipped files.
* Built-ins *
sys Interpreter state vars and functions
__built-in__ Access to all built-in python identifiers
__main__ Scope of the interpreters main program, script or stdin
array Obj efficiently representing arrays of basic values
math Math functions of C standard
time Time-related functions (also the newer datetime module)
marshal Read and write some python values in binary format
struct Convert between python values and C structs
* Standard *
getopt Parse cmd line args in sys.argv. A la UNIX 'getopt'.
os A more portable interface to OS dependent functionality
re Functions useful for working with regular expressions
string Useful string and characters functions and exceptions
random Mersenne Twister pseudo-random number generator
_thread Low-level primitives for working with process threads
threading idem, new recommended interface.
* Unix/Posix *
dbm Interface to Unix dbm databases
grp Interface to Unix group database
posix OS functionality standardized by C and POSIX standards
posixpath POSIX pathname functions
pwd Access to the Unix password database
select Access to Unix select multiplex file synchronization
socket Access to BSD socket interface
* Tk User-interface Toolkit *
tkinter Main interface to Tk
* Multimedia *
audioop Useful operations on sound fragments
imageop Useful operations on images
jpeg Access to jpeg image compressor and decompressor
rgbimg Access SGI imglib image files
* Cryptographic Extensions *
md5 Interface to RSA's MD5 message digest algorithm
sha Interface to the SHA message digest algorithm
HMAC Keyed-Hashing for Message Authentication -- RFC 2104.
* SGI IRIX * (4 & 5)
al SGI audio facilities
AL al constants
fl Interface to FORMS library
FL fl constants
flp Functions for form designer
fm Access to font manager library
gl Access to graphics library
GL Constants for gl
DEVICE More constants for gl
imgfile Imglib image file interface
Workspace exploration and idiom hints
dir(<module>) list functions, variables in <module>
dir() get object keys, defaults to local name space
if __name__ == '__main__': main() invoke main if running as script
map(None, lst1, lst2, ...) merge lists
b = a[:] create copy of seq structure
_ in interactive mode, is last value printed
Python Mode for Emacs
(Not revised, possibly not up to date)
Type C-c ? when in python-mode for extensive help.
INDENTATION
Primarily for entering new code:
TAB indent line appropriately
LFD insert newline, then indent
DEL reduce indentation, or delete single character
Primarily for reindenting existing code:
C-c : guess py-indent-offset from file content; change locally
C-u C-c : ditto, but change globally
C-c TAB reindent region to match its context
C-c < shift region left by py-indent-offset
C-c > shift region right by py-indent-offset
MARKING & MANIPULATING REGIONS OF CODE
C-c C-b mark block of lines
M-C-h mark smallest enclosing def
C-u M-C-h mark smallest enclosing class
C-c # comment out region of code
C-u C-c # uncomment region of code
MOVING POINT
C-c C-p move to statement preceding point
C-c C-n move to statement following point
C-c C-u move up to start of current block
M-C-a move to start of def
C-u M-C-a move to start of class
M-C-e move to end of def
C-u M-C-e move to end of class
EXECUTING PYTHON CODE
C-c C-c sends the entire buffer to the Python interpreter
C-c | sends the current region
C-c ! starts a Python interpreter window; this will be used by
subsequent C-c C-c or C-c | commands
C-c C-w runs PyChecker
VARIABLES
py-indent-offset indentation increment
py-block-comment-prefix comment string used by py-comment-region
py-python-command shell command to invoke Python interpreter
py-scroll-process-buffer t means always scroll Python process buffer
py-temp-directory directory used for temp files (if needed)
py-beep-if-tab-change ring the bell if tab-width is changed
The Python Debugger
(Not revised, possibly not up to date, see 1.5.2 Library Ref section 9.1; in 1.5.2, you may also use debugger integrated in IDLE)
Accessing
import pdb (it's a module written in Python)
-- defines functions :
run(statement[,globals[, locals]])
-- execute statement string under debugger control, with optional
global & local environment.
runeval(expression[,globals[, locals]])
-- same as run, but evaluate expression and return value.
runcall(function[, argument, ...])
-- run function object with given arg(s)
pm() -- run postmortem on last exception (like debugging a core file)
post_mortem(t)
-- run postmortem on traceback object <t>
-- defines class Pdb :
use Pdb to create reusable debugger objects. Object
preserves state (i.e. break points) between calls.
runs until a breakpoint hit, exception, or end of program
If exception, variable '__exception__' holds (exception,value).
Commands
h, help
brief reminder of commands
b, break [<arg>]
if <arg> numeric, break at line <arg> in current file
if <arg> is function object, break on entry to fcn <arg>
if no arg, list breakpoints
cl, clear [<arg>]
if <arg> numeric, clear breakpoint at <arg> in current file
if no arg, clear all breakpoints after confirmation
w, where
print current call stack
u, up
move up one stack frame (to top-level caller)
d, down
move down one stack frame
s, step
advance one line in the program, stepping into calls
n, next
advance one line, stepping over calls
r, return
continue execution until current function returns
(return value is saved in variable "__return__", which
can be printed or manipulated from debugger)
c, continue
continue until next breakpoint
j, jump lineno
Set the next line that will be executed
a, args
print args to current function
rv, retval
prints return value from last function that returned
p, print <arg>
prints value of <arg> in current stack frame
l, list [<first> [, <last>]]
List source code for the current file.
Without arguments, list 11 lines around the current line
or continue the previous listing.
With one argument, list 11 lines starting at that line.
With two arguments, list the given range;
if the second argument is less than the first, it is a count.
whatis <arg>
prints type of <arg>
!
executes rest of line as a Python statement in the current stack frame
q quit
immediately stop execution and leave debugger
<return>
executes last command again
Any input debugger doesn't recognize as a command is assumed to be a
Python statement to execute in the current stack frame, the same way
the exclamation mark ("!") command does.
Example
(1394) python
Python 1.0.3 (Sep 26 1994)
Copyright 1991-1994 Stichting Mathematisch Centrum, Amsterdam
>>> import rm
>>> rm.run()
Traceback (innermost last):
File "<stdin>", line 1
File "./rm.py", line 7
x = div(3)
File "./rm.py", line 2
return a / r
ZeroDivisionError: integer division or modulo
>>> import pdb
>>> pdb.pm()
> ./rm.py(2)div: return a / r
(Pdb) list
1 def div(a):
2 -> return a / r
3
4 def run():
5 global r
6 r = 0
7 x = div(3)
8 print x
[EOF]
(Pdb) print r
0
(Pdb) q
>>> pdb.runcall(rm.run)
etc.
Quirks
Breakpoints are stored as filename, line number tuples. If a module is reloaded
after editing, any remembered breakpoints are likely to be wrong.
Always single-steps through top-most stack frame. That is, "c" acts like "n".
View Git Blame Copy Permalink