v1.3; 1995/10/30, Author: Chris Hoffmann, choffman@vicorp.com
For:
python [-diuv] [-c command | script | - ] [args]
-d Turn on parser debugging output (for wizards only,
depending on compilation options).
-i When a script is passed as first argument or the -c
option is used, enter interactive mode after executing
the script or the command. It does not read the
$PYTHONSTARTUP file. This can be useful to inspect
global variables or a stack trace when a script raises
an exception.
-s Suppress auto-printing of expressions in interactive mode.
-u Force stdout and stderr to be totally unbuffered.
-v Print a message each time a module is initialized,
showing the place (filename or built-in module) from
which it is loaded.
-c command
Specify the command to execute (see next section).
This terminates the option list (following options are
passed as arguments to the command).
- anything afterward is passed as options to python script or
command, not interpreted as an option to interpreter itself.
script is the name of a python file to execute
args are passed to script or command (in "sys.argv")
If no script or command, Python enters interactive mode. Uses
"readline" package for input, if available.
and elif from lambda return
break else global not try
class except if or while
continue exec import pass
def finally in print
del for is raise
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.
\newline Ignored (escape newline)
\\ Backslash (\) \e Escape (ESC) \v Vertical Tab (VT)
\' Single quote (') \f Formfeed (FF) \0OO (zero) char with
\" Double quote (") \n Linefeed (LF) octal value OO
\a Bell (BEL) \r Carriage Return (CR) \xXX char with
\b Backspace (BS) \t Horizontal Tab (TAB) hex value XX
\ is left as-is
NULL byte (\000) is NOT an end-of-string marker; NULL's may be imbedded in strings
Strings (and tuples) are immutable: they cannot be modified.
long integer (unlimited precision): 1234567890L
octal integer: 0177, 0177777777777777777L hex integer: 0xFF, 0xFFFFFFFFFFFFFFFFFFL
float: 3.14e-10
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]
dictionary of length 0, 1, 2, etc:
{} {1 : 'first'} {1 : 'first', 'next': 'second'}
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.
< strictly less than
<= less than or equal
> strictly greater than
>= greater than or equal
== equal
!= not equal ( "<>" is also allowed)
is object identity (are _objects_ identical, not values)
is not negated object identity
X < Y < Z < W has expected meaning, unlike C
False values: None, numeric zeros, empty sequences and mappings
True values: all other values
not X: if X is false then 1, else 0
X or Y: if X is false then Y, else X
X and Y: if X is false then X, else Y
('or', 'and' evaluate second arg only if necessary to determine outcome)
Floats are implemented with C doubles.
Integers are implemented with C longs.
Long integers have unlimited size (only limit is system resources)
abs(x) 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 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)
pow(x, y) x to the power y
~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
len(s) length of s min(s) smallest item of s max(s) largest item of s 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 s[i:j] slice of s from i to j slice from index i up to but not including index j i defaults to 0, j to len(s) negative goes from right-end of sequence
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] delete slice (same as s[i:j] = []) s.append(x) add x to end of s s.count(x) return number of i's for which s[i] == x s.index(x) return smallest i such that s[i] == x1) s.insert(i, x) item i becomes x, old item i is now at i+1, etc. s.remove(x) same as del s[s.index(x)] s.reverse() reverses the items of s (in place) s.sort() sorts the list (in place) Optional parameter: function of two arguments returning -1, 0 or 1 depending on whether arg1 is >, ==, < arg2.IndexError is raised on out-of-range sequence subscript
len(a) the number of items in a a[k] the item of a with key k a[k] = x set a[k] to x del a[k] remove a[k] from a a.items() a copy of a's list of (key, value) pairs a.keys() a copy of a's list of keys a.values() a copy of a's list of values a.has_key(k) 1 if a has a key k, else 0TypeError is raised if key not acceptable
Supports: %, c, s, i, d, u, o, x, X, e, E, f, g, G.
Width and precision may be a * to specify that an integer argument specifies the actual width or precision.
The flag characters -, +, blank, # and 0 are understood.
%s will convert any type argument to string (uses str() function)
a = '%s has %03d quote types.' % ('Python', 2)
a ==> 'Python has 002 quote types.'
Right-hand-side can 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.)
f.close(x) close file f. f.fileno(x) get fileno (fd) for f. f.flush(x) flush file's internal buffer. f.isatty() 1 if file is connected to a tty-like dev, else 0 f.read([size]) read at most mostbytes from file and return as a string object. If omitted, read to EOF. f.readline() read one entire line from file f.readlines() read until EOF with readline() and return list of lines read. f.seek(offset, whence=0) set file's position, like "stdio's fseek()". whence == 0 then use absolute indexing whence == 1 then offset relative to current pos whence == 2 then offset relative to file end f.tell() return file's current position f.write(str) Write string to file. f.writelines(list) Write list of strings to file.
pass -- Null statement = -- Assignment operator. Can unpack tuples, lists, first, second = a[0:2]; [f, s] = range(2) del <id> -- Unbind name from object, or attributes from objects, etc. print [<c1> [, <c2> ]* [,] -- Writes to sys.stdout. 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. f(<value>,... [<id>=<value>]) -- Call function 'f' with parameters. Parameters can be passed by name or be omitted if function defines default values. E.g. for 'f' is defined as "def f(p1=1, p2=2)" "f()" <=> "f(1, 2)" "f(10)" <=> "f(10, 2)" "f(p2=99)" <=> "f(1, 99)"
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 <target> in <condition-list>: <suite> [else: <suite>] -- iterates over sequence "<condition-list>", assigning each element to "<target>". "else" suite executed at end unless loop exited with "break" break -- immediately exit "for" or "while" loop continue -- immediately do next iteration of "for" or "while" loop return [<result>] -- return from function (or method) and return "<result>". If no result given, then returns None.
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 them immediately reraises exception. raise <exception> [,<value> [,<traceback>]] -- raises <exception> with optional value <value>. Parameter <traceback> specifies a traceback object to use when printing the exception's backtrace. 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 Or, more complicated: class base_exception: pass class numeric_exception(base_exception): pass class text_exception(base_exception): pass try: if bad: raise text_exception() ## This is a shorthand for the form ## "raise <class>, <instance>" ## except base_exception: print 'Oops' ## This will be printed because ## text_exception is a subclass of base_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().
import <module_id1> [, <module_id2>]* -- imports modules. Members of module must be referred to by qualifying with module name: "import sys; print sys.argv: from <module_id> import <id1> [, <id2>]* -- imports names from module <module_id>. Names are not qualified: "from sys import argv; print argv" from <module_id> import * -- imports all names in module <module_id>, except those starting with "_": "from sys import *; print argv" global <id1> [,<id2>]* -- ids are from global scope (usually meaning from module) rather than local (usually meaning only in function). -- E,g, in fcn, no "global" statements, assume "a" is name that hasn't been used in fcn 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 fcn, but is in module, then Try to read from "a", gets value from module Try to write to "a", creates "a" local to fcn But note "a[0]=3" starts with search for "a", will use to global "a" if no local "a".
def <func_id> ([<param_list>]): <suite> -- creates a function object and assigns it name <func_id>. <param_list> ==> [<id> [, <id>]*] [<id> = <v> [, <id> = <v>]*] [*<id>] [**<id>] E.g. 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. (allows vararg functions). If list has "**<id>" then <id> is assigned a dictionary of all argumenst passed as keywords.
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.
E.g.
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.
By convention this is called "self".
Special method "__init__()" called when instance created.
Create instance by "calling" class object, possibly with args.
In current implementation, can't subclass off built-in
classes. But can "wrap" them, see __getattr__() below.
E.g.
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.
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".
lambda [<param_list>]: <condition> -- Create an anonymous function. <condition> 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.
abs(x) Return the absolute value of a number
apply(f, args)
Call func/method <f> with args <args>
callable(x) Returns 1 if x callable, else 0.
chr(i) Return one-character string whose ASCII code is
integer i
cmp(x,y) Return neg, zero, pos if x <, ==, > to y
coerce(x,y) Return a tuple of the two numeric arguments converted to
a common type.
compile(string, filename, kind)
Compile <string> into a code object.
<filename> is used in error message, can be
any string. <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'.
dir([object]) If no args, return the list of names in current local
symbol table. With a module, class or class instance
object as arg, return list of names in its attr dict.
divmod(a,b) Returns tuple of (a/b, a%b)
eval(s, globals, locals)
Eval string <s> in (optional) <globals>, <locals>.
<s> must have no NULL's or newlines. <s> can also be a
code object.
E.g.: x = 1; incr_x = eval('x + 1')
filter(function, list)
Construct a list from those elements of <list> for which
<function> returns true. <function> takes one parameter.
float(x) Convert a number to floating point.
getattr(object, name)
Get attr called <name> from <object>.
getattr(x, 'foobar') <=> x.foobar
globals() Returns a dictionary containing current global variables.
hasattr(object, name)
Returns true if <object> has attr called <name>.
hash(object) Return the hash value of the object (if it has one)
hex(x) Convert a number to a hexadecimal string.
id(object) Return a unique 'identity' integer for an object.
input([prompt]) Prints prompt, if given. Reads input and evaluates it.
int(x) Convert a number to a plain integer.
len(s) Return the length (the number of items) of an object.
local() Return a dictionary containing current local variables.
long(x) Convert a number to a long integer.
map(function, list, ...)
Apply <function> to every item of <list> and return a list
of the results. If additional arguments are passed,
<function> must take that many arguments and it is given
to <function> on each call.
max(s) Return the largest item of a non-empty sequence.
min(s) Return the smallest item of a non-empty sequence.
oct(x) Convert a number to an octal string.
open(filename [, mode='r', [bufsize=<implementation dependent>]])
Return a new file object. First two args are same as
those for C's "stdio open" function. <bufsize> is 0
for unbuffered, 1 for line-buffered, negative for
sys-default, all else, of (about) given size.
ord(c) Return integer ASCII value of <c> (str of len 1).
pow(x, y [, z]) Return x to power y [modulo z]
range(start [,end [, step]])
return list of ints from >= start and < end.
With 1 arg, list from 0..<arg>-1
With 2 args, list from <start>..<end>-1
With 3 args, list from <start> up to <end> by <step>
raw_input([prompt])
Print prompt if given, then read string from std
input.
reduce(f, list [, init])
Apply the binary function <f> to the items of
<list> so as to reduce the list to a single value.
If <init> given, it is "prepended" to <list>.
reload(module) Re-parse and re-initialize an already imported module.
Useful in interactive mode, if you want to reload a
module after fixing it. If module was synactically
correct but had an error in initialization, must
import it one more time before calling reload().
repr(object) Return a string containing a printable representation
of an object. Equivalent to `object` (using
backquotes).
round(x,n=0) Return the floating point value x rounded to n digits
after the decimal point.
setattr(object, name, value)
This is the counterpart of getattr().
setattr(o, 'foobar', 3) <=> o.foobar = 3
str(object) Return a string containing a nicely printable
representation of an object.
tuple(list) Creates a tuple with same elements as <list>
type(object) Return type of an object. E.g.,
if type(x) == type(''): print 'It is a string'
vars([object]) Without arguments, return a dictionary corresponding
to the current local symbol table. With a module,
class or class instance object as argument
returns a dictionary corresponding to the object's
symbol table. Useful with "%" formatting operator.
xrange(start [, end [, step]])
Like range(), but doesn't actually store entire list
all at once. Good to use in "for" loops when there is a
big range and little memory.
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)
__init__(s, args) object instantiation
__del__(s) called on object demise (refcount becomes 0)
__repr__(s) repr() and `...` conversions
__str__(s) str() and 'print' statement
__cmp__(s, o) implements <, ==, >, <=, <>, !=, >=, is [not]
__hash__(s) hash() and dictionary operations
__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.
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 = __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)
int(s) = __int__(s) long(s) = __long__(s)
float(s) = __float__(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)
len(s) = __len__(s) length of object, >= 0. Length 0 == false s[i] = __getitem__(s,i) Element at index/key i, origin 0
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] = []
hash(s) = __hash__(s) - hash value for dictionary references s[k]=v = __setitem__(s,k,v) del s[k] = __delitem__(s,k)
X.__dict__ dict used to store object's writeable attributes I.__methods__ list of I's methods; on many built-in types. I.__members__ lists of I's data attributes; on many built-in types I.__class__ class to which instance I belongs C.__bases__ r/o attr, tuple of class C's base classes M.__name__ r/o attr, module M's name as string
sys
Variables:
argv -- The list of command line arguments passed to a Python script. sys.argv[0] is the script name. builtin_module_names -- A list of strings giving the names of all modules written 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 exc_traceback -- Set when in an exception handler. Are last exception, last exception value, and traceback object of call stack when exception occured. exitfunc -- User can set to a parameterless fcn. It will get called before interpreter exits. last_type last_value last_traceback -- Set only when an exception not handled and interpreter prints an error. Used by debuggers. modules -- List of modules that have already been loaded. path -- Search path for external modules. Can be modified by program. platform -- The current platform, e.g. "sunos5" or "linux1" ps1 ps2 -- prompts to use in interactive mode. stdin stdout stderr -- File objects used for I/O. User can redirect by assigning a new file object to them (or any object with a method "write()" taking string argument). tracebacklimit -- Maximum levels of tb info printed on error.
Functions:
exit(n) -- Exit with status <n>. Raises SystemExit exception. (Hence can be caught and ignored by program) settrace(func) -- Sets a trace function: called before each line of code is exited. setprofile(func) -- Sets a profile function for performance profiling.
os
"synonym" for whatever O/S-specific module is proper for current environment. Uses "posix" whenever possible.Variables
name -- name of O/S-specific module (e.g. "posix" or "mac")
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 ('/')
posix
Variables:
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 Functions (see doc for more):
chdir(path) -- Go to <path>.
close(fd) -- Close file descriptor <fd>.
_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>
fork() -- Like C's fork(). Returns 0 to child, child pid to parent.
kill(pid, signal)
-- Like C's kill
listdir(path) -- List names of entries in directory <path>.
open(file, flags, mode)
-- Like C's open(). Returns file descriptor.
pipe() -- Creates pipe. Returns pair of file descriptors (r, w).
popen(command, mode='r', buffSize=0)
-- Open a pipe to or from <command>. Result is a file
object to read to or write from, as indicated by
<mode> being 'r' or 'w'.
read(fd, n) -- Read <n> bytes from <fd> and return as string.
stat(path) -- Returns st_mode, st_ino, st_dev, st_nlink, st_uid,
st_gid, st_size, st_atime, st_mtime, st_ctime.
system(command) -- Execute string <command> in a subhell. Returns exit
status of subshell.
unlink(path) -- Unlink ("delete") path/file.
wait() -- Wait for child process completion. Returns tuple of
pid, exit_status
waitpid(pid, options)
-- Wait for process pid to complete. Returns tuple of
pid, exit_status
write(fd, str) -- Write <str> to <fd>. Returns num bytes written.
posixpath
Some Functions (see doc for more):
exists(p) -- True if string <p> is an existing path expanduser(p) -- Returns string that is <p> with "~" expansion done. isabs(p) -- True if string <p> is an absolute path. isfile(p) -- True if string <p> is a regular file. isdir(p) -- True if string <p> is a directory. islink(p) -- True if string <p> is a symbolic link. isfile(p) -- True if string <p> is a regular file. ismount(p) -- True if string <p> is a mount point. split(p) -- Splits into (head, tail) where <tail> is last pathname component and <head> is everything leading up to that. splitext(p) -- Splits into (root, ext) where last comp of <root> contains no periods and <ext> is empty or starts with a period. walk(p, visit, arg) -- Calls the function <visit> with arguments (<arg>, <dirname>, <names>) for each directory in the directory tree rooted at <p> The argument <dirname> specifies the visited directory, the argument <names> lists the files in the directory. The <visit> function may modify <names> to influence the set of directories visited below <dirname>, e.g., to avoid visiting certain parts of the tree.
math
Variables:
pi eFunctions (see ordinary C man pages for info):
acos(x) asin(x) atan(x) atan2(x, y) ceil(x) cos(x) cosh(x) exp(x) fabs(x) floor(x) fmod(x, y) frexp(x) -- Unlike C: (float, int) = frexp(float) ldexp(x, y) log(x) log10(x) modf(x) -- Unlike C: (float, float) = modf(float) pow(x, y) sin(x) sinh(x) sqrt(x) tan(x) tanh(x)
getopt
Functions:
getopt(list, optstr) -- Similar to C. <optstr> is option letters to look for. Put ':' after letter if option takes arg. E.g. # invocation was "python test.py -c hi -a arg1 arg2" opts, args = getopt.getopt(sys.argv[1:], 'ab:c:') # opts would be [('-c', 'hi'), ('-a', '')] # args would be ['arg1', 'arg2']
string
Some Variables:
digits -- The string '0123456789' uppercase lowercase whitespace -- Strings containing the appropriate characters index_error -- Exception raised by index() if substr not found.Some Functions:
index(s, sub, i=0) -- Return the lowest index in <s> not smaller than <i> where the substring <sub> is found. lower(s) -- Return a string that is <s> in lowercase splitfields(s, sep) -- Returns a list containing the fields of the string <s>, using the string <sep> as a separator. joinfields(words, sep) -- Concatenate a list or tuple of words with intervening separators. strip(s) -- Return a string that is <s> without leading and trailing whitespace. upper(s) -- Return a string that is <s> in uppercase
regex
Patterns are specified as strings. Default syntax is emacs-style.Special Characters (using default syntax):
. matches any character * 0 or more of preceeding regular expresssion + 1 or more of preceeding regular expresssion ? 0 or 1 of preceeding regular expresssion [ ] defines character set: '[a-zA-Z]' to match all letters [^ ] defines complemented character set: matches if char is NOT in set ^ matches empty str at beginning of line $ matches empty str at end of line \ quoting char: \[ matches char '[' \\ matches '\'; due to Python string rules, write as '\\\\' in the pattern string. \| specifies alternative: 'foo\|bar' matches 'foo' or 'bar' \( \) grouping (for \|, or complicated expr, or substr for future reference by \D character or group() method) \D D is digit: matches substr matched by D'th \( \) in pattern \` empty str at beginning of file \' empty str at end of file \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 \< empty str at beginning of word \> empty str at end of word \w any word constituent \W any non-word constituentVariables:
error -- Exception when pattern string isn't valid regexp.Functions:
match(pattern, string) -- Return how many characters at the beginning of <string> match regexp <pattern> or -1 if none. search(pattern, string [, pos]) -- Return the first position in <string> that matches regexp <pattern>. Return -1 if none. [starting at <pos>.] compile(pattern [,translate]) -- Create regexp object that has methods match() and search() working as above. Also group(i1, [,i2]*). Also regs, tuple of positions matched; regs[0] is whole match, next are subexpressions. E.g. p = compile('id\([a-z]\)\([a-z]\)') p.match('idab') ==> 4 p.group(1, 2) ==> ('a', 'b') p.regs ==> ((0, 4), (2, 3), (3, 4), ...) set_syntax(flag) -- Set syntax flags for future calls to match(), search() and compile(). Returns current value. Flags in module regex_syntax. symcomp(pattern [,translate]) -- Like compile but with symbolic group names. Names in angle brackets. Access through group method. E.g. p = symcomp('id\(<l1>[a-z]\)\(<l2>[a-z]\)') p.match('idab') ==> 4 p.group('l1') ==> 'a'
regex_syntax
Flags for regex.set_syntax(). BitOr the flags you want together and pass to function.Variables:
RE_NO_BK_PARENS -- if set, ( means grouping, \( is literal "(" if not, vice versa RE_NO_BK_VBAR -- if set, | means or, \| is literal "|" if not, vice versa RE_BK_PLUS_QM -- if set, + or ? are operator, \+, \? are literal if not, vice versa RE_TIGHT_VBAR -- if set, | binds tighter than ^ or $ if not, vice versa RE_NEWLINE_OR -- if set, \n is an OR operator if not, it is a normal char RE_CONTEXT_INDEP_OPS -- if not set, special chars always have special meaning if set, depends on context: # ^ - only special at the beginning, or after ( or | # $ - only special at the end, or before ) or | # *, +, ? - only special when not after the beginning, (, or | RE_SYNTAX_AWK = (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS) RE_SYNTAX_EGREP = (RE_SYNTAX_AWK | RE_NEWLINE_OR) RE_SYNTAX_GREP = (RE_BK_PLUS_QM | RE_NEWLINE_OR) RE_SYNTAX_EMACS = 0
reg_sub
Functions:
sub(pattern, rep, str) -- Replace 1st occur of <pattern> in <str> by <rep> and return this. gsub(pattern, rep, str) -- Replace _all_ occurances of <pattern> in <str> by <rep> and return this. split(str, pattern) -- Split <str> into fields seperated by delimiters matching <pattern> and return as list of strings.
Some Other Modules In Base Distribution
* Built-ins *
sys Interpreter state vars and functions __built-in__ Access to all built-in python identifiers __main__ Scope of the interpreters main program, script or stdin array Obj efficiently representing arrays of basic values math Math functions of C standard time Time-related functions regex Regular expression matching operations marshal Read and write some python values in binary format struct Convert between python values and C structs* Standard *
getopt Parse cmd line args in sys.argv. A la UNIX 'getopt'. os A more portable interface to OS dependent functionality rand Pseudo-random generator, like C rand() regsub Functions useful for working with regular expressions string Useful string and characters functions and exceptions whrandom Wichmann-Hill pseudo-random number generator* Unix *
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 thread Low-level primitives for working with process threads* Tk User-interface Toolkit *
tkinter Main interface to Tk* Multimedia *
audioop Useful operations on sound fragments imageop Useful operations on images jpeg Access to jpeg image compressor and decompressor rgbimg Access SGI imglib image files* Cryptographic Extensions *
md5 Interface to RSA's MD5 message digest algorithm mpz Interface to int part of GNU multiple precision library rotor Implementation of a rotor-based encryption algorithm* Stdwin * Standard Window System
stdwin Standard Window System interface stdwinevents Stdwin event, command, and selection constants rect Rectangle manipulation operations* SGI IRIX * (4 & 5)
al SGI audio facilities AL al constants fl Interface to FORMS library FL fl constants flp Functions for form designer fm Access to font manager library gl Access to graphics library GL Constants for gl DEVICE More constants for gl imgfile Imglib image file interface* Suns *
sunaudiodev Access to sun audio interfacePartial Contents of Lib directory
BaseHTTPServer -- Base class forhttp services. CGIHTTPServer -- CGI http services. Complex -- Complex numbers as instances of the class Complex. Queue -- A multi-producer, multi-consumer queue. SimpleHTTPServer-- Simple extension to base http class StringIO -- File-like objects that read/write a string buffer. SocketServer -- Generic socket server classes. UserDict -- A wrapper to allow subclassing of built-in dict class. UserList -- A wrapper to allow subclassing of built-in list class. addpack -- Support for "packages", groups of related modules. aifc -- Stuff to parse AIFF-C and AIFF files. anydbm -- Generic interface to all dbm clones. audiodev -- Audio support for a few platforms. 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. calendar -- Calendar printing functions. cgi -- Wraps the WWW Forms Common Gateway Interface (CGI). cmd -- A generic class to build line-oriented command interpreters. cmp -- Efficiently compare files, boolean outcome only. cmpcache -- Same, but caches 'stat' results for speed. codehack -- Extract a function name from a code object. 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. copy -- Generic shallow and deep copying operations. dircache -- Sorted list of files in a dir, using a cache. dircmp -- Defines a class to build directory diff tools on. dis -- Bytecode disassembler. dospath -- Common operations on DOS pathnames. dumbdbm -- A dumb and slow but simple dbm clone. dump -- Print python code that reconstructs a variable. emacs -- Execute Emacs code from a Python interpreter. find -- Find files directory hierarcy matching a pattern. fnmatch -- Filename matching with shell patterns. fpformat -- General floating point formatting functions. ftplib -- An FTP client class. Based on RFC 959. getopt -- Standard command line processing. glob -- filename globbing. gopherlib -- Gopher protocol client interface. grep -- 'grep' utilities. htmlentitydefs -- Proposed entity definitions for HTML. htmllib -- HTML parsing utilities. httplib -- HTTP client class. ihooks -- Hooks into the "import" mechanism. imghdr -- Recognizing image files based on their first few bytes. importall -- Utility module to import all modules in the path. linecache -- Cache lines from files. lockfile -- Implements file locking. maccache -- Mac cache listdir(), isdir(), isfile() or exists(). macpath -- Pathname (or related) operations for the Macintosh. mailbox -- A class to handle a unix-style or mmdf-style mailbox. mhlib -- MH (mailbox) interface. mimetools -- Various tools used by MIME-reading or MIME-writing programs. multifile -- Class to make multi-file messages easier to handle. mutex -- Mutual exclusion -- for use with module sched. newdir -- New dir() function. ni -- New import scheme with package support. nntplib -- An NNTP client class. Based on RFC 977. ntpath -- Common operations on DOS pathnames. os -- Either mac, dos or posix depending system. packmail -- Create a self-unpacking shell archive. pdb -- A Python debugger. persist -- Implement limited persistence. pickle -- Pickling (save and restor) of Python objects. pipes -- Conversion pipeline templates. poly -- Polynomials. posixfile -- Extended (posix) file operations. posixpath -- Common operations on POSIX pathnames. profile -- Class for profiling python code. pstats -- Class for printing reports on profiled python code. pty -- Pseudo terminal utilities. py_compile -- Routine to "compile" a .py file to a .pyc file. pyclbr -- Parse a Python file and retrieve classes and methods. quopri -- Conversions to/from quoted-printable transport encoding. rand -- Don't use unless you want compatibility with C's rand(). random -- Random variable generators. 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. sched -- A generally useful event scheduler class. sgmllib -- A parser for SGML. shelve -- Manage shelves of pickled objects. shutil -- Utility functions usable in a shell-like program. sndhdr -- Several routines that help recognizing sound. stat -- Constants and functions for interpreting stat/lstat struct. statcache -- Maintain a cache of file stats. 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"). tb -- Print tracebacks, with a dump of local variables. tempfile -- Temporary file name allocation. 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. types -- Define names for all type symbols in the std interpreter. tzparse -- Parse a timezone specification. urllib -- Open an arbitrary URL. urlparse -- Parse URLs according to latest draft of standard. uu -- UUencode/UUdecode. wave -- Stuff to parse WAVE files. whatsound -- Several routines that help recognizing sound files. whrandom -- Wichmann-Hill random number generator. zmod -- Demonstration of abstruse mathematical concepts.
Workspace exploration and idiom hints
dir(<module>) list functions, variables in <module> dir() get object keys, defaults to local name space X.__methods__ list of methods supported by X (if any) X.__members__ List of X's data attributes if __name__ == '__main__': main() invoke main if running as script map(None, lst1, lst2, ...) merge lists b = a[:] create copy of seq structure _ in interactive mode, is last value printed
Python Mode for Emacs
Type C-c ? when in python-mode for extensive help. INDENTATION Primarily for entering new code: TAB indent line appropriately LFD insert newline, then indent DEL reduce indentation, or delete single character Primarily for reindenting existing code: C-c : guess py-indent-offset from file content; change locally C-u C-c : ditto, but change globally C-c TAB reindent region to match its context C-c < shift region left by py-indent-offset C-c > shift region right by py-indent-offset MARKING & MANIPULATING REGIONS OF CODE C-c C-b mark block of lines M-C-h mark smallest enclosing def C-u M-C-h mark smallest enclosing class C-c # comment out region of code C-u C-c # uncomment region of code MOVING POINT C-c C-p move to statement preceding point C-c C-n move to statement following point C-c C-u move up to start of current block M-C-a move to start of def C-u M-C-a move to start of class M-C-e move to end of def C-u M-C-e move to end of class EXECUTING PYTHON CODE C-c C-c sends the entire buffer to the Python interpreter C-c | sends the current region C-c ! starts a Python interpreter window; this will be used by subsequent C-c C-c or C-c | commands VARIABLES py-indent-offset indentation increment py-block-comment-prefix comment string used by py-comment-region py-python-command shell command to invoke Python interpreter py-scroll-process-buffer t means always scroll Python process buffer py-temp-directory directory used for temp files (if needed) py-beep-if-tab-change ring the bell if tab-width is changed
The Python Debugger
Accessing
import pdb (it's a module written in Python) -- defines functions run(string) -- interpret string in the debugger runctx(string, globals, locals) -- interpret string using globals and locals for namespace runcall(fun, arg1, arg2, ...) -- run function object <fun> with args 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. Pdb defines methods run(string) -- interpret string in the debugger runctx(string, globals, locals) -- interpret string using globals and locals for namespace runcall(fun, arg1, arg2, ...) -- run function object with args runs until a breakpoint hit, exception, or end of program If exception, variable '__exception__' holds (exception,value).Commands
h, help brief reminder of commands b, break [<arg>] if <arg> numeric, break at line <arg> in current file if <arg> is function object, break on entry to fcn <arg> if no arg, list breakpoints cl, clear [<arg>] if <arg> numeric, clear breakpoint at <arg> in current file if no arg, clear all breakpoints after confirmation w, where print current call stack u, up move up one stack frame (to top-level caller) d, down move down one stack frame s, step advance one line in the program, stepping into calls n, next advance one line, stepping over calls r, return continue execution until current function returns (return value is saved in variable "__return__", which can be printed or manipulated from debugger) c, continue continue until next breakpoint a, args print args to current function rv, retval prints return value from last function that returned p, print <arg> prints value of <arg> in current stack frame l, list [<first> [, <last>]] List source code for the current file. Without arguments, list 11 lines around the current line or continue the previous listing. With one argument, list 11 lines starting at that line. With two arguments, list the given range; if the second argument is less than the first, it is a count. whatis <arg> prints type of <arg> ! executes rest of line as a Python statement in the current stack frame q quit immediately stop execution and leave debugger <return> executes last command again Any input debugger doesn't recognize as a command is assumed to be a Python statement to execute in the current stack frame, the same way the exclamation mark ("!") command does.Example
(1394) python Python 1.0.3 (Sep 26 1994) Copyright 1991-1994 Stichting Mathematisch Centrum, Amsterdam >>> import rm >>> rm.run() Traceback (innermost last): File "<stdin>", line 1 File "./rm.py", line 7 x = div(3) File "./rm.py", line 2 return a / r ZeroDivisionError: integer division or modulo >>> import pdb >>> pdb.pm() > ./rm.py(2)div: return a / r (Pdb) list 1 def div(a): 2 -> return a / r 3 4 def run(): 5 global r 6 r = 0 7 x = div(3) 8 print x [EOF] (Pdb) print r 0 (Pdb) q >>> pdb.runcall(rm.run) etc.Quirks
Breakpoints are stored as filename, line number tuples. If a module is reloaded after editing, any remembered breakpoints are likely to be wrong.
Always single-steps through top-most stack frame. That is, "c" acts like "n".