VISIT…

Python 2.5 Reference Card 1.3 Dictionaries (Mappings) padding: center(w,c), ljust(w,c), lstrip(cs),
d={'x':42, 'y':3.14, 'z':7} dict creation rjust(w,c), rstrip(cs), strip(cs), zfill(w),
(c) 2009 Michael Goerz <goerz@physik.fu-berlin.de>
http://www.physik.fu-berlin.de/~goerz/ d['x'] get entry for 'x' expandtabs(ts)
This work is licensed under the Creative Commons Attribution-Noncommercial-Share Alike 3.0 License. len(d) number of keys checking: isalnum, isalpha, isdigit, islower, isspace,
To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/ istitle, isupper
del(d['x']) delete entry from dict
d.copy() create shallow copy String Constants: import string
1 Variable Types d.has_key(k) does key exist? digits, hexdigits, letters, lowercase, octdigits,
printable, punctuation, uppercase, whitespace
1.1 Numbers d.items() list of all items
42 052 0x2A 42L 052L 0x2AL d.keys() list of all keys Regexes: import re
42 (dec, oct, hex, short/long)
d.values() list of all values r=re.compile(r'rx',re.ILMSUX) comile 'rx' as regex
0.2 .8 4. 1.e10 1.0e-7 floating point value
i=d.iteritems(); i.next() iterator over items (?P<id>...) named group
z = 5.0 – 2.0J; complex number
i=d.iterkeys(); i.next() iterator over keys m=r.match(s,b,e) full match
z = complex(real, imag) complex number
i=d.itervalues(); i.next() iterator over values re.match(r'(?iLmsux)rx',s) direct regex usage
z.real; z.imag real and imag part of z
d.get(k,x) get entry for k, or return x m=r.search(s,b,e) partial match
True; False constants for boolean values
d.clear() remove all items l=r.split(s,ms) split and return list
abs(n) absolute value of n
d.setdefault(k,x) return d[k] or set d[k]=x l=r.findall(string) list of all matched groups
divmod(x, y) (x/y, x%y)
hex(n) d.popitem() return and delete an item s=r.sub(s,r,c) replace c counts of s with r
create hex string
oct(n) 1.4 Sets (s,n)=r.subn(s,r,c) n is number of replacements
create octal string
ord(c) s=re.escape(s) escape all non-alphanumerics
unicode code point of char s=set(s); fs=frozenset(s) create set
round(x,n) m.start(g);m.span(g);m.end(g) group-match delimiters
round x to n decimal places fs.issubset(t); s<=t all s in t?
cmp(x,y) m.expand(s) replace \1 etc. with matches
x<y: -1, x==y: 0, x>y: 1 fs.issuperset(t); s>=t all t in s?
m.group(g); m.group("name") matched group no. g
coerce(x, y) (x,y), make same type fs.union(t); s|t all elements from s and t m.groups() list of groups
pow(x,y,z) (x**y) % z fs.intersection(t); s&t elements both in s and t m.groupdict() dict of named groups
float("3.14") float from string fs.difference(t); s-t all s not in t
int("42", base) int from string fs.symmetric_difference(t);s^t all either s or t
import math; import cmath more math functions
import random; random number generators
fs.copy() shallow copy of s 2 Basic Syntax
s.update(t); s|=t add elements of t if expr: statements conditional
1.2 Sequences (lists are mutable, tuples and strings are immutable) s.intersection_update(t); s&=t keep only what is also in t elif expr: statements
s=l=[1, "bla", [1+2J, 1.4], 4] list creation s.difference_update(t); s-=t remove elements of t else: statements
s=t=(1, "bla", [1+2J, 1.4], 4) tuple creation s.symmetric_differ...(t); s^=t keep only symm. difference if a is b : ... object identity
l=list(t); t=tuple(l) list/tuple conversion s.add(x) add x to fs if a == 1 value identity
l=range(1000) list of integers (0-999) s.remove(x); fs.discard(x); remove x (/ with exception) while expr: statements while loop
s=xrange(1000) immut. xrange-sequence s.pop(); return and remove any elem. else: statements run else on normal exit
i=iter(s); i.next() iterator from sequence s.clear(); remove all elements while True: ... if cond: break do... while equivalent
s[2][0] get list element (1+2J) 1.5 Strings and Regular Expressions for target in iter: statements for loop
s[-2][-1] get list element (1.4) else: statements
"bla"; 'hello "world"' string (of bytes)
s1+s1 sequence concat for key,value in d.items():... multiple identifiers
"""bla""", '''bla''' triple quotes for multiline
n*s1 repeat s1 n times break, continue end loop / jump to next
\ \\ \0 cont., backslash, null char
s[i:j]; s[i:]; s[:j] slicing (i incl., j excl.) \N{id} \uhhhh \Uhhhhhhhh print "hello world", print without newline
unicode char
s[i:j:k] slice with stride k \xhh \ooo hex, octal byte [ expr for x in seq lc ] list comprehension
s[::2]; s[::-1] every 2nd Element / reverse s u"Ünic\u00F8de"; u"\xF8" unicode string (of characters) lc = for x in seq / if expr with lc-clauses
x in s; x not in s is x a member of s? r"C:\new\text.dat"; ur"\\Ü" raw string (unicode) pass empty statement
len(s) number of elements str(3.14); str(42) string conversion def f(params): statements function definition
min(s); max(s) min/max "%s-%s-%s" % (42,3.14,[1,2,3]) string formatting def f(x, y=0): return x+y optional parameter
l[i:j]=['a','b','c','d'] replace slice '\t'.join(seq) join sequences with separator def f(*a1, **a2): statements additional list of unnamed,
l[i:i]=['a','b'] insert before position i s.decode('utf-8') latin-1 string to unicode string dict of named paramters
l.count(x) number of occurances of x u.encode('utf-8') unicode string to utf-8 string def f(): f.variable = 1 ... function attribute
l.index(x) first index of x, or error chr(i), unichr(i) char from code point return expression return from function
l.append(x) append x at end of l str(x) string from number/object yield expression make function a generator
x=l.pop() pop off last element Other String Methods: f(1,1), f(2), f(y=3, x=4) function calls
l.extend(l2) append l2 at end of l search and replace: find(s,b,e), rfind(s,b,e), global v bind to global variable
l.insert(i,x) instert x at pos. i index(s,b,e), rindex(s,b,e), count(s,b,e), def make_adder_2(a): closure
l.remove(x) delete first x endswith(s,b,e), startswith(s,b,e), replace(o,n,m) def add(b): return a+b
l.reverse() reverse l formatting: capitalize, lower, upper, swapcase, title return add
l.sort(f) sort using f (default f =cmp) splitting: partition(s), rpartition(s), split(s,m), lambda x: x+a lambda expression
zip(s,t,...) [(s[0],t[0],...),..] rsplit(s,m), splitlines(ke) compile(string,filename,kind) compile string into code object
eval(expr,globals,locals)
exec code in gldict, lcdict
execfile(file,globals,locals)
raw_input(prompt)
input(prompt)
3 Object Orientation and Modules
import module as alias
from module import name1,name2 load attr. into own namespace os.startfile(f)
from __future__ import *
reload module
module.__all__
module.__name__
module.__dict__
__import__("name",glb,loc,fl) import module by name
class name (superclass,...):
data = value
def method(self,...): ... methods
def __init__(self, x):
Super.__init__(self) call superclass constructor
self.member = x
def __del__(self): ...
__str__, __len__, __cmp__,__
__iter__(self): return self
__call__
__dict__
__getattr__(self, name),
__setattr__(self, name, value) set any attribute
callable(object)
delattr(object, "name")
del(object)
dir(object)
getattr(object, "name", def)
hasattr(object, "name")
hash(object)
id(object)
isinstance(object,
classOrType)
issubclass(class1, class2)
iter(object, sentinel)
locals()
repr(object), str(object)
vars(object)
None
if __name__ == "__main__":
4 Exception Handling
try: ...
except ExceptionName:
except (Ex1, ...), data:
print data
raise
else: ...
finally: ...
assert expression
evaluate expression
compile and execute code
execute file
input from stdin
input and evaluate
import module
activate all new features
reinitialize module
exported attributes
module name / "__main__"
module namespace
class definition
shared class data
constructor
per-instance data
destructor
some operator overloaders
use next method for iterator isdir, isfile, islink, ismout, join, lexists,
call interceptor
instance-attribute dictionary samefile, sameopenfile, samestat, sep, split,
get an unknown attribute
1 if callable, 0 otherwise
delete name-attr. from object
unreference object/var
list of attr. assoc. with object
get name-attr. from object
check if object has attr.
return hash for object
unique integer (mem address)
check for type
class2 subclass of class1?
return iterator for object
dict of local vars of caller
return string-representation
return __dict__
the NULL object
make modul executable
Try-block
catch exception
multiple, with data
exception handling
pass up (re-raise) exception
if no exception occurred
in any case
debug assertion
class MyExcept(Exception): ... define user exception
raise MyExcept(data) raise user exception
7 Standard Library (almost complete)
String Services: string, re, struct, difflib, StringIO,
cStringIO, textwrap, codecs, unicodedata, stringprep,
5 System Interaction fpformat
sys.path module search path File/Directory Access: os.path, fileinput, stat, statvfs,
sys.platform operating system filecmp, tempfile, glob, fnmatch, linecache, shutil,
sys.stdout, stdin, stderr standard input/output/error dircache
sys.argv[1:] command line parameters Generic OS services: os, time, optparse, getopt, logging,
os.system(cmd) system call getpass, curses, platform, errno, ctypes
open file with assoc. program Optional OS services: select, thread, threading,
os.popen(cmd, r|w, bufsize) open pipe (file object) dummy_thread, dummy_threading, mmap, readline,
os.popen2(cmd, bufsize, b|t) (stdin, stdout) fileobjects rlcompleter
os.popen3(cmd, bufsize, b|t) (stdin, stdout,stderr) Data Types: datetime, calendar, collections, heapq,
os.environ['VAR']; os.putenv[] read/write environment vars bisect, array, sets, sched, mutex, Queue, weakref,
glob.glob('*.txt') wildcard search UserDict, UserList, UserString, types, new, copy,
Filesystem Operations pprint, repr
os module: access, chdir, chmod, chroot, getcwd, getenv, Numeric and Math Modules: math, cmath, decimal, random,
listdir, mkdir, remove, unlink, removedirs, rename, itertools, functools, operator
rmdir, pipe, ... Internet Data Handling: email, mailcap, mailbox, mhlib,
mimetools, mimetypes, MimeWriter, mimify, multifile,
shutil module: copy, copy2, copyfile, copyfileobj,
rfc822, base64, binhex, binascii, quopri, uu
copymode, copystat, copytree, rmtree
os.path module: abspath, altsep, basename, commonprefix, Structured Markup Processing Tools: HTMLParser, sgmllib,
htmllib, htmlentitydefs, xml.parsers.expat, xml.dom.*,
curdir, defpath, dirname, exists, expanduser,
expandvar, extsep, get[acm]time, getsize, isabs, xml.sax.*, xml.etree.ElementTree
File Formats: csv, ConfigParser, robotparser, netrc,
normcase, normpath, pardir, pathsep, realpath, xdrlib
Crypto Services: hashlib, hmac, md5, sha
splitdrive, splitext, stat, walk Compression: zlib, gzip, bz2, zipfile, tarfile
command line argument parsing: Persistence: pickle, cPickle, copy_reg, shelve, marshal,
restlist, opts = \ anydbm, whichdb, dbm, gdbm, dbhash, bsddb, dumbdbm,
getopt.getopt(sys.argv[l:],\ sqlite3
"s:oh",\ Unix specific: posix, pwd, spwd, grp, crypt, dl, termios,
["spam=", "other", "help"]) tty, pty, fcntl, posixfile, resource, nis, syslog,
for o, a in opts: commands
if o in ("-s", "--lol"): spam = a IPC/Networking: subprocess, socket, signal, popen2,
if o in ("-h", "--help"): show_help() asyncore, asynchat
Internet: webbrowser, cgi, scitb, wsgiref, urllib,
httplib, ftplib, imaplib, nntplib, ...lib, smtpd,
6 Input/Output uuid, urlparse, SocketServer, ...Server,, cookielib,
f=codecs.open(if,"rb","utf-8") open file with encoding Cookie, xmlrpclib
file = open(infilename, "wb") open file without encoding Multimedia: audioop, imageop, aifc, sunau, wave, chunk,
codecs.EncodedFile(...) wrap file into encoding colorsys, rgbimg, imghdr, sndhdr, ossaudiodev
r, w, a, r+ read, write, append, random Tk: Tkinter, Tix, ScrolledText, turtle
rb, wb, ab, r+b modes without eol conversion Internationalization: gettext, locale
file.read(N) N bytes ( entire file if no N ) Program Frameworks: cmd, shlex
file.readline() the next linestring Development: pydoc, doctest, unittest, test
file.readlines() list of linestring Runtime: sys, warnings, contextlib, atexit, traceback,
file.write(string) write string to file qc, inspect, site, user, fpectl
file.writelines(list) write list of linestrings Custom Interpreters: code, codeop
file.close() close file Restricted Execution: rexec, Bastion
file.tell() current file position Importing: imp, zipimport, pkgutil, modulefinder, runpy
file.seek(offset, whence) jump to file position Language: parser, symbol, token, keyword, tokenize,
os.truncate(size) limit output to size tabnanny, pyclbr, py_compile, compileall, dis,
os.tmpfile() open anon temporary file pickletools, distutils
pickle.dump(x, file) make object persistent Windows: msilib, msvcrt, _winreq, winsound
x = pickle.load(file) load object from file Misc: formatter