542 lines
22 KiB
Plaintext
542 lines
22 KiB
Plaintext
A Python Bestiary
|
|
Itemizing Python Objects and Nuances
|
|
|
|
$Revision$ $Date$ ken.manheimer@nist.gov
|
|
|
|
Notable lexical entities
|
|
========================
|
|
|
|
Keywords
|
|
|
|
access and break class
|
|
continue def del elif
|
|
else except exec finally
|
|
for from global if
|
|
import in is lambda
|
|
not or pass print
|
|
raise return try while
|
|
|
|
String Literal Escapes
|
|
|
|
\newline Ignored (escape newline)
|
|
\\ Backslash (\) \e Escape (ESC) \v Vertical Tab (VT)
|
|
\' Single quote (') \f Formfeed (FF) \0XX char with
|
|
\" Double quote (") \n Linefeed (LF) octal value XX
|
|
\a Bell (BEL) \r Carriage Return (CR) \xXX char with
|
|
\b Backspace (BS) \t Horizontal Tab (TAB) hex value XX
|
|
|
|
Illegitimate Tokens (only valid in strings): @ $ ?
|
|
|
|
Operating environment (Unix)
|
|
|
|
Shell environment vars:
|
|
|
|
PYTHONPATH: dirs to be prepended to module search path; a la shell PATH
|
|
PYTHONSTARTUP: names path of file to be loaded on interactive startup
|
|
|
|
Internal (module sys) vars ('import sys' to refer to them):
|
|
|
|
argv - list of command and arguments passed to python script
|
|
builtin_module_names - list of names of modules compiled in to python
|
|
( exc_* values are set only during handling of a raised exception)
|
|
exc_type - type of exception being handled
|
|
exc_value - exception's parameter ('raise's 2nd arg)
|
|
exc_traceback - exception's traceback obj
|
|
exit(N) - exit from python with status N, by raising SystemExit
|
|
exitfunc - function hook, to be called on exit if set
|
|
last_type - type of last unhandled exception
|
|
last_value - value of last unhandled exception
|
|
last_traceback - traceback of last unhandled exception
|
|
modules - list of modules already loaded
|
|
path - list of strings specifying module-load search path
|
|
ps1='>>>' - string specifying primary prompt, iff interactive
|
|
ps2='...' - string specifying secondary prompt, iff interactive
|
|
settrace - system trace function, used by debuggers, etc
|
|
setprofile - system profile function
|
|
stdin - standard input file object
|
|
stdout - standard output file object
|
|
stderr - standard error file object
|
|
tracebacklimit=1000 - maximum number of traceback levels to print
|
|
|
|
|
|
Objects - behaviors, special attributes, operations, statements, etc
|
|
====================================================================
|
|
|
|
General object aspects
|
|
|
|
Boolean values and operators
|
|
|
|
False values: None, numeric zeros, empty sequences and mappings
|
|
True values: all other values
|
|
|
|
not X: if X is false then 1, else 0
|
|
( 'or', 'and' evaluate second arg only if necessary to determine outcome)
|
|
X or Y: if X is false then Y, else X
|
|
X and Y: if X is false then X, else Y
|
|
|
|
Special methods for any type (s: self)
|
|
|
|
id(obj) unique identifier for object (currently, its address)
|
|
__init__(s, args) object instantiation - see Classes, below
|
|
__del__(s) object demise
|
|
__repr__(s) repr() and `...` conversions
|
|
__str__(s) str() and 'print' statement
|
|
__cmp__(s) implements <, ==, >, <=, <>, !=, >=, is [not]
|
|
__hash__(s) hash() and dictionary operations
|
|
|
|
Special informative state attributes for some types:
|
|
|
|
X.__dict__ dict used to store object's writeable attributes
|
|
X.__methods__ list of X's methods; on many built-in types.
|
|
X.__members__ lists of X's data attributes
|
|
X.__class__ class to which X belongs
|
|
X.__bases__ tuple of X base classes
|
|
|
|
General Name Space behavior and binding
|
|
|
|
Name space search order: local, global, builtin
|
|
|
|
"global" name space = file = module
|
|
"local" name space = function or method
|
|
|
|
Code Block scopes (ns = name space, cb = containing block)
|
|
|
|
( global ns generally is containing module, unless overriden by args)
|
|
|
|
Code block type Local ns Notes
|
|
--------------- -------- -----
|
|
Module same as global ns
|
|
Script same as global ns global ns is __main__
|
|
Interactive cmd same as global ns global ns is __main__
|
|
Class def new ns
|
|
Function body new ns
|
|
'exec' string local ns of cb (or args)
|
|
'eval' string local ns of caller (or args)
|
|
'execfile' file local ns of caller (or args)
|
|
'input' expr local ns of caller
|
|
|
|
Binding operations and exceptions:
|
|
|
|
~ SyntaxError: on attempt to bind to literals or other non-bindables
|
|
~ NameError: on attempt to evaluate unbound atom
|
|
|
|
( for object attribute functions, obj: object, nm: string, val: any value)
|
|
getattr(obj, nm) get value of obj.nm
|
|
hasattr(obj, nm) true if obj has nm attribute
|
|
setattr(obj, nm, val) set obj.nm to val
|
|
|
|
assignment statement: targ1, targ2, ,,, = obj1, obj2, ,,,
|
|
deletion statement: del obj1, obj2, ...
|
|
for loop target identifiers, 'except' clauses (see Statements, below)
|
|
formal params (see Callables, below)
|
|
import statement (see Modules objects, below)
|
|
class and func defs (see Callables, below)
|
|
|
|
Name space linkage
|
|
|
|
global statement: global var, ... # Interpret 'var's as globals
|
|
X access statement: access ... # control inst and class vars access
|
|
|
|
@ Built-in Exceptions
|
|
|
|
AttributeError On attribute reference or assignment failure
|
|
EOFError Immediate end-of-file hit by input() or raw_input()
|
|
IOError I/O-related I/O operation failure
|
|
ImportError On failure of `import' to find module or name
|
|
IndexError On out-of-range sequence subscript
|
|
KeyError On reference to a non-existent mapping (dict) key
|
|
KeyboardInterrupt On user entry of the interrupt key (often `Control-C')
|
|
MemoryError On recoverable memory exhaustion
|
|
NameError On failure to find a local or global (unqualified) name
|
|
OverflowError On excessively large arithmetic operation
|
|
RuntimeError Obsolete catch-all; define a suitable error instead
|
|
SyntaxError On parser encountering a syntax error
|
|
SystemError On non-fatal interpreter error - bug - report it
|
|
SystemExit On `sys.exit()'
|
|
TypeError On passing inappropriate type to built-in op or func
|
|
ValueError On arg error not covered by TypeError or more precise
|
|
ZeroDivisionError On division or modulo operation with 0 as 2nd arg
|
|
|
|
**** Numbers ****
|
|
|
|
@ Integers: 'C' long, >= 32 bits precision; OverflowError if bounds exceeded
|
|
@ Long Integers: unlimited precision - '2147483648L'
|
|
@ Floating point: machine double-precision floating point - '2147483648.0'
|
|
|
|
Numeric operations vs special methods (s = self, o = other)
|
|
|
|
s+o = __add__(s,o) s-o = __sub__(s,o)
|
|
s*o = __mul__(s,o) s/o = __div__(s,o)
|
|
s%o = __mod__(s,o) divmod(s,o) = __divmod__(s,o)
|
|
pow(s,o) = __pow__(s,o)
|
|
s&o = __and__(s,o)
|
|
s^o = __xor__(s,o) s|o = __xor__(s,o)
|
|
s<<o = __lshift__(s,o) s>>o = __rshift__(s,o)
|
|
nonzero(s) = __nonzero__(s) coerce(s,o) = __coerce__(s,o)
|
|
-s = __neg__(s) +s = __pos__(s)
|
|
abs(s) = __abs__(s) ~s = __invert__(s) (bitwise)
|
|
int(s) = __int__(s) long(s) = __long__(s)
|
|
float(s) = __float__(s)
|
|
oct(s) = __oct__(s) hex(s) = __hex__(s)
|
|
|
|
Numeric functions:
|
|
|
|
range(start=0,end,step=1) create arithmetic progression list
|
|
round(x, n=0) round floating point x to n decimal places
|
|
xrange(start=0,end,step=1) create virtual arithmetic progressions tuple
|
|
|
|
Numeric exceptions:
|
|
|
|
~ TypeError: raised on application of arithemetic opertion to non-number
|
|
~ OverflowError: numeric bounds exceeded
|
|
~ ZeroDivisionError: raised when zero second argument of div or modulo op
|
|
|
|
**** Collections - Sequences and Mappings ****
|
|
|
|
Collections general operations vs methods (s: self, i: index or key)
|
|
|
|
len(s) = __len__(s) length of object, >= 0. Length 0 == false
|
|
s[i] = __getitem__(s,i) Element at index/key i, origin 0
|
|
|
|
Sequences
|
|
|
|
@ String (immutable sequence): 'string contents'
|
|
|
|
'this is a string'
|
|
"and so is this"
|
|
''' and this begins a 'multi-line' string with embedded quotes...
|
|
and this is the end of that string.'''
|
|
|
|
`expr` = __repr__(expr), converts arbitrary expr to string
|
|
chr(int) string of ascii letter at ordinate in (0 <= int < 256)
|
|
ord(string) ascii ordinate of string (string must be length 1)
|
|
string % arg format operator, a la C sprintf
|
|
arg for single directive can be any (suitable) type
|
|
arg for multiple directives must be tuple or dict
|
|
dict (mapping) arg uses parenthesized directives that are keys into it
|
|
supports %, c, s, i, d, u, o, x, X, e, E, f, g, G directives
|
|
* can be width and precision; directs use of corresponding (int) args
|
|
* can not be used with dict args
|
|
flag characters -, +, blank, #, and 0 understood.
|
|
%s conversion takes any python object, converts using `str()'
|
|
ANSI directives %p and %n not supported
|
|
%s conversions do *not* take \000 as end of string
|
|
|
|
@ Tuples (immutable sequence): (oneelem, another, etc)
|
|
|
|
parens may be left off all but empty tuples
|
|
singletons represented by affixing a comma to an expr
|
|
empty tuple represented using empty parens
|
|
|
|
@ Lists (mutable sequence): [oneelem, another, etc]
|
|
|
|
assignment - must be 1-1 map of items in target and object sequences
|
|
deletion - similar rules as for assignment
|
|
|
|
List special methods: see mutable sequence ops vs methods, below
|
|
|
|
Sequences general ops vs methods (s: self, i,j: indices, v: val)
|
|
|
|
All collections general methods, plus:
|
|
s[i:j] __getslice__(s,i,j), all s[k] s.t. i <= k < j
|
|
min(s) smallest item of s
|
|
max(s) largest item of s
|
|
v [not] in s 1 if v [not] equal to an item in s, else 0
|
|
s + seq concatenation of s and seq
|
|
s * num num copies of s concatenated, also, `num * s'
|
|
|
|
Immutable sequence ops vs methods (s: self, i,j: indices, v: val)
|
|
|
|
All collections and sequences general methods, plus:
|
|
s[i:j] __getslice__(s,i,j), all s[k] s.t. i <= k < j
|
|
( For s[i:j], len(self) is intrinsically added to i, j < 0)
|
|
( Complex elems of immutable seqs may be mutable, see dictionaries, below)
|
|
|
|
Mutable sequence ops vs methods (s: self, i,j: indices, v: val)
|
|
|
|
All sequences' general methods, plus:
|
|
( for non-slice refs, i < 0 intrinsically has len(s) added)
|
|
( For slice refs, len(s) *is not* intrinsically added to i, j < 0)
|
|
( for assignment/deletion, index refs must point to existing items
|
|
s[i]=v = __setitem__(s,i,v)
|
|
del s[i] = __delitem__(s,i)
|
|
s[i:j] = __getslice__(s,i,j)
|
|
s[i:j]=seq = __setslice__(s,i,j,seq)
|
|
del s[i:j] = __delslice__(s,i,j) == s[i:j] = []
|
|
s.append(seq) == `s[len(seq):len(seq)] = seq' (but faster)
|
|
s.count(v) number of i's for which `s[i] == v'
|
|
s.index(v) first i such that `s[i] == v', or IndexError if none
|
|
s.insert(i, v) == `s[i:i] = [v]'
|
|
s.remove(v) == `del s[s.index(v)]', or IndexError if v not in s
|
|
s.reverse() reverse the items of s in place
|
|
s.sort() permute s items so s[i] <= s[j], for i < j
|
|
|
|
Mappings
|
|
|
|
@ Dictionaries: {key1: val1, key2: val2, ...}
|
|
|
|
built-in types as keys must be unalterable: obj & all contents immutable
|
|
User-defined classes as keys must have __hash__() and __cmp__() methods
|
|
~ TypeError is raised if key not acceptable
|
|
~ KeyError is raised if reference made using non-existent key
|
|
key types may vary (contrary to ref man)
|
|
|
|
Dictionaries ops vs methods (s: self, k: key, v: val)
|
|
|
|
all collections general ops, plus:
|
|
hash(s) = __hash__(s) - hash value for dictionary references
|
|
s[k]=v = __setitem__(s,k,v)
|
|
del s[k] = __delitem__(s,k)
|
|
s.items() = a list copy of s's (key, item) pairs
|
|
s.keys() = a list copy of s's keys
|
|
s.values() = a list copy of s's values
|
|
s.has_keys(k) = 1 if s has key k, else 0
|
|
( s.items, .keys, and .values yield random but mutually consistent order)
|
|
|
|
**** Callables ****
|
|
|
|
@ User defined functions: 'def name (param-list): suite'
|
|
|
|
suite is not evaluated at statement execution, but at function invocation
|
|
function parameters, comma separated on param-list:
|
|
func_code: special attr, code object representing compiled function body
|
|
func_globals: special attr, ref to global dict of funcs definition module
|
|
func(arg-list) invocation
|
|
|
|
@ User defined methods: like functions, with extra implicit arg
|
|
|
|
Same as functions, but passed class instance as additional first argument
|
|
im_self: special attr, method's class instance object
|
|
im_func: special attr, function object
|
|
mthd(args) invocation, same as mthd.im_func(mthd.im_self, args)
|
|
|
|
@ Classes: 'class name[ (inheritance)]: suite'
|
|
|
|
inheritance list is evaluated, if any, to identify base classes for name
|
|
suite is executed in new local name space, which goes to the class object
|
|
class name is bound in encompassing local name space
|
|
container for dictionary containing class's ns dictionary
|
|
__dict__: ro attr, class ns as dictionary object
|
|
__bases__: ro attr, class' base classes in tuple
|
|
__init__(self, args..): implements object instantiation
|
|
__del__(self): implements impending object deletion
|
|
|
|
@ Class instances
|
|
|
|
__dict__: ro attr, class' attribute dictionary
|
|
__class__: ro attr, instance's class object
|
|
|
|
Callables special method vs ops (f: function)
|
|
|
|
apply(f, args-tuple) call f with args-tuple as arg list
|
|
compile(str, flnm, kind) compile string into exectuable code object
|
|
eval(str, glbls=, lcls=) evaluate string as expression (cond_list)
|
|
filter(f, seq) => seq of seq elems for which f is true
|
|
map(f, lst, [lst2, ...]) => list of f applied to succesive lsts elems
|
|
reduce(f, lst, initlzr) => value of f applied to elems and cume result
|
|
|
|
@ **** Null object: `None' ****
|
|
|
|
@ **** Type objects, print as: <type 'int'> ****
|
|
( '<...>' form is only for printing - cannot be entered that way,
|
|
|
|
accessed via built-in func 'type()'
|
|
( equal only when identical (same id()),
|
|
so can't just use the string name, must use object with the same str val)
|
|
|
|
@ **** Modules ****
|
|
|
|
functions and methods in a module share module's ("global") namespace
|
|
function uses "global" statement to instantiate var in global context
|
|
Modules use "import" to incorp other module's names - see Name Spaces
|
|
|
|
Special attrs, methods, and operations
|
|
|
|
__dict__: attr, module's ns as dictionary; can modify vals but not sruct
|
|
__name__: ro attr, module's name as string
|
|
import Instantiate module or module components within another
|
|
reload(amod) Reread an imported module
|
|
|
|
@ **** Files ****
|
|
|
|
wrapper around a C stdio file pointer
|
|
sys.stdin, sys.stdout, sys.stderr are standard io-stream file objects
|
|
|
|
File operations:
|
|
|
|
open(nm, mode='r', bufsize=sysdef) return new file object
|
|
close() A closed file cannot be read or written anymore.
|
|
flush() Flush the internal buffer, like stdio's `fflush()'.
|
|
isatty() 1 if file connected to a tty(-like) device, else 0.
|
|
read(SIZE) Read up to SIZE bytes frm file, less on EOF or no data
|
|
readline() Read one entire line from the file.
|
|
readlines() `readline()' til EOF and return list of lines read.
|
|
seek(OFFSET,WHENCE) Set file's current position, like stdio's `fseek()'
|
|
tell() Return file's current position, like stdio's `ftell()'.
|
|
write(STR) Write a string to the file. There is no return value.
|
|
|
|
File functions:
|
|
|
|
input(prompt='') like raw input but accept '\' line continuations
|
|
print exp, exp2, ... Write values to stdout
|
|
raw_input(prompt='') prompt then read single line of input
|
|
|
|
**** Internal types ****
|
|
|
|
@ Code objects - represent exectuable code - function obj sans context
|
|
@ Frame objects - represent executable frames - may occur in traceback objs
|
|
@ Traceback objects - stack trace of an exception
|
|
|
|
Control statements
|
|
==================
|
|
|
|
* Calls and Evaluation *
|
|
|
|
( See also Callables, in Objects section above, for ops and methods.)
|
|
|
|
exec: exec expr [ in expr2 [, expr3]] # Dynamic execution of python code
|
|
return: return [expr] # Leave current func call with expr value
|
|
|
|
* Conditionals and Loops *
|
|
( See also Boolean values, above)
|
|
|
|
break: break # Terminate nearest enclosing loop
|
|
continue: continue # Continue next cycle of enclosing loop
|
|
if: if cond: suite [\n elif cond: suite \n ...] [\n else: suite]
|
|
for: for targs in conds: suite [ \n else: suite ]
|
|
while: while cond: suite [ \n else : suite ]
|
|
|
|
* Exceptions *
|
|
|
|
raise: raise expr [, expr2] # Raise exception expr, passing expr2 if any
|
|
try... # Handle exceptions:
|
|
try: suite [\n except [cond [, targ]]: suite \n ... \n] [else: suite]
|
|
try: suite \n finally: suite # Specify a 'cleanup' handler
|
|
( two 'try' forms cannot be mixed together)
|
|
|
|
System modules
|
|
==============
|
|
@ * Built-ins *
|
|
|
|
sys Interpreter state (see Operating Environment, above)
|
|
__builtin__ Access to all built-in python identifiers
|
|
__main__ Scope of the interpreters main program, script or stdin
|
|
array Obj efficiently representing arrays of basic values
|
|
math Math functions of C standard
|
|
time Time-related functions
|
|
regex Regular expression matching operations
|
|
marshal Read and write some python values in binary format
|
|
strop Miscellaneous string operations
|
|
struct Convert between python values and C structs
|
|
|
|
@ * Standard *
|
|
|
|
getopt Parse cmd line args in sys.argv. A la UNIX 'getopt'.
|
|
os Portable interface to OS dependent functionality
|
|
pdb text-oriented debugger
|
|
rand Pseudo-random generator, like C rand()
|
|
regsub Functions useful for working with regular expressions
|
|
string Useful string and characters functions and exceptions
|
|
wdb window-oriented debugger
|
|
whrandom Wichmann-Hill pseudo-random number generator
|
|
|
|
@ * Miscellaneous *
|
|
|
|
dis Python disassembler
|
|
glob Filename globbing (a la unix shell)
|
|
grep File string search
|
|
posixpath Common operations on POSIX pathnames
|
|
profile Python code profiler
|
|
repr `...` repr operator with presentation constraints
|
|
string All of builtin 'strop', plus
|
|
tb Traceback browser and printer
|
|
tempfile Produce a temporary-file name
|
|
util Miscellaneous functions that don't belong elsewhere
|
|
|
|
@ * Unix *
|
|
|
|
dbm Dict/file-like interface to Unix ndbm database library
|
|
grp Interface to Unix group database
|
|
posix Standardized UNIX OS functionality - see 'os', above
|
|
posixpath POSIX pathname functions - see 'os', above
|
|
pwd Access to the Unix password database
|
|
select Access to Unix select multiplex file synchronization
|
|
socket Access to BSD socket interface
|
|
thread Low-level primitives for working with process threads
|
|
|
|
@ * Multimedia *
|
|
|
|
audioop Useful operations on sound fragments
|
|
imageop Useful operations on images
|
|
jpeg Access to jpeg image compressor and decompressor
|
|
rgbimg Access SGI imglib image files
|
|
|
|
@ * Cryptographic Extensions *
|
|
|
|
md5 Interface to RSA's MD5 message digest algorithm
|
|
mpz Interface to int part of GNU multiple precision library
|
|
rotor Implementation of a rotor-based encryption algorithm
|
|
|
|
@ * Stdwin * Standard Window System
|
|
|
|
stdwin Standard Window System interface
|
|
stdwinevents Stdwin event, command, and selection constants
|
|
rect Rectangle manipulation operations
|
|
|
|
@ * SGI IRIX * (4 & 5)
|
|
|
|
al SGI audio facilities
|
|
AL al constants
|
|
fl Interface to FORMS library
|
|
FL fl constants
|
|
flp Functions for form designer
|
|
fm Access to font manager library
|
|
gl Access to graphics library
|
|
GL Constants for gl
|
|
DEVICE More constants for gl
|
|
imgfile Imglib image file interface
|
|
|
|
@ * Suns *
|
|
|
|
sunaudiodev Access to sun audio interface
|
|
|
|
@ * Contrib *
|
|
|
|
syslog
|
|
|
|
metalbase
|
|
|
|
Idioms and hints
|
|
================
|
|
|
|
Invoke main if running as script: if __name__ == '__main__': main()
|
|
|
|
General object-type miscellany
|
|
What type is someobj; eg, a list: if type(someobj) == type([]):
|
|
Convert number to hex or octal string: hex(122) => '0x7a'
|
|
Convert string to number: eval('0x7a') => 122
|
|
|
|
Sequence Slice conceptualization:
|
|
+---+---+---+---+---+ Indices point ~between~ chars:
|
|
| s | t | u | f | f | - first char's left edge = 0,
|
|
+---+---+---+---+---+ - nth char's right edge = n.
|
|
0 1 2 3 4 5 (Note that -0 == 0, so it does
|
|
-5 -4 -3 -2 -1 not count from right.)
|
|
|
|
Sequences miscellany:
|
|
Create merge of lists: map(None, lst1, lst2, ...)
|
|
It's faster to list.append(elem) than to list[len(list):] = [elem]
|
|
Copy structure of seq a to b: b = a[:]
|
|
|
|
Comma (tuple vs expression grouping) nuances:
|
|
to specify a tuple of one element: ('element',)
|
|
to specify a tuple containing 1 tuple: (('contained', 'tuple'),)
|
|
"TypeError: call of non-function" often means a list missing a comma
|
|
|
|
Namespace and object surveillance:
|
|
get dictful object keys/key-vals: dir(), vars()
|
|
Current context globals: eval(__name__ + '.__dict__')
|
|
Current context locals: vars()
|
|
Methods supported by X (some objs): X.__methods__
|
|
X's data attributes (some objs): X.__members__
|