Python 2.5 Quick Reference Card - Michigan State University

Python 2.5 Reference Card

(c) 2007 Michael Goerz Information taken liberally from the python documentation and various other sources.

You may freely modify and distribute this document.

1.3 Dictionaries (Mappings)

d={'x':42, 'y':3.14, 'z':7} d['x'] len(d) del(d['x'])

dict creation get entry for 'x'

number of keys delete entry from dict

padding: center(w,c), ljust(w,c), lstrip(cs), rjust(w,c), rstrip(cs), strip(cs), zfill(w), expandtabs(ts)

checking: isalnum, isalpha, isdigit, islower, isspace, istitle, isupper

1 Variable Types

d.copy() d.has_key(k)

create shallow copy does key exist?

String Constants: import string digits, hexdigits, letters, lowercase, octdigits,

1.1 Numbers

d.items()

list of all items

printable, punctuation, uppercase, whitespace

42 052 0x2A 42L 052L 0x2AL

42 (dec, oct, hex, short/long) d.keys()

list of all keys

Regexes: import re

0.2 .8 4. 1.e10 1.0e-7

floating point value

d.values()

list of all values

r=pile(r'rx',re.ILMSUX) comile 'rx' as regex

z = 5.0 ? 2.0J;

complex number

i=d.iteritems(); i.next()

iterator over items

(?P...)

named group

z = complex(real, imag)

complex number

i=d.iterkeys(); i.next()

iterator over keys

m=r.match(s,b,e)

full match

z.real; z.imag

real and imag part of z

i=d.itervalues(); i.next()

iterator over values

re.match(r'(?iLmsux)rx',s)

direct regex usage

True; False

constants for boolean values d.get(k,x)

get entry for k, or return x

m=r.search(s,b,e)

partial match

abs(n)

absolute value of n

d.clear()

remove all items

l=r.split(s,ms)

split and return list

divmod(x, y)

(x/y, x%y)

d.setdefault(k,x)

return d[k] or set d[k]=x

l=r.findall(string)

list of all matched groups

hex(n)

create hex string

d.popitem()

return and delete an item

s=r.sub(s,r,c)

replace c counts of s with r

oct(n)

create octal string

1.4 Sets

(s,n)=r.subn(s,r,c)

n is number of replacements

ord(c) round(x,n) cmp(x,y)

coerce(x, y)

pow(x,y,z) float("3.14")

unicode code point of char round x to n decimal places

xy: 1 (x,y), make same type (x**y) % z float from string

s=set(s); fs=frozenset(s) fs.issubset(t); s=t fs.union(t); s|t fs.intersection(t); s&t fs.difference(t); s-t

create set

all s in t? all t in s? all elements from s and t elements both in s and t all s not in t

s=re.escape(s) m.start(g);m.span(g);m.end(g) m.expand(s) m.group(g); m.group("name") m.groups() m.groupdict()

escape all non-alphanumerics group-match delimiters

replace \1 etc. with matches matched group no. g

list of groups dict of named groups

int("42", base)

int from string

import math; import cmath

more math functions

import random;

random number generators

1.2 Sequences (lists are mutable, tuples and strings are immutable)

s=l=[1, "bla", [1+2J, 1.4], 4] list creation

s=t=(1, "bla", [1+2J, 1.4], 4) tuple creation

l=list(t); t=tuple(l)

list/tuple conversion

l=range(1000)

list of integers (0-999)

s=xrange(1000)

immut. xrange-sequence

i=iter(s); i.next()

iterator from sequence

s[2][0]

get list element (1+2J)

s[-2][-1]

get list element (1.4)

s1+s1

sequence concat

n*s1

repeat s1 n times

s[i:j]; s[i:]; s[:j]

slicing (i incl., j excl.)

s[i:j:k]

slice with stride k

s[::2]; s[::-1]

every 2nd Element / reverse s

x in s; x not in s

is x a member of s?

len(s)

number of elements

min(s); max(s)

min/max

l[i:j]=['a','b','c','d']

replace slice

l[i:i]=['a','b']

insert before position i

l.count(x)

number of occurances of x

fs.symmetric_difference(t);s^t all either s or t

fs.copy()

shallow copy of s

2 Basic Syntax

s.update(t); s|=t

add elements of t

s.intersection_update(t); s&=t keep only what is also in t

if expr: statements elif expr: statements

s.difference_update(t); s-=t remove elements of t

else: statements

s.symmetric_differ...(t); s^=t keep only symm. difference if a is b : ...

s.add(x)

add x to fs

if a == 1

s.remove(x); fs.discard(x);

remove x (/ with exception) while expr: statements

s.pop();

return and remove any elem. else: statements

s.clear();

remove all elements

while True: ... if cond: break

1.5 Strings and Regular Expressions

for target in iter: statements

"bla"; 'hello "world"' """bla""", '''bla'''

string (of bytes) triple quotes for multiline

else: statements for key,value in d.items():...

\ \\ \0

cont., backslash, null char

break, continue

\N{id} \uhhhh \Uhhhhhhhh

unicode char

print "hello world",

\xhh \ooo

hex, octal byte

[ expr for x in seq lc ]

u"?nic\u00F8de"; u"\xF8" r"C:\new\text.dat"; ur"\\?"

unicode string (of characters)

lc = for x in seq / if expr

raw string (unicode)

pass

str(3.14); str(42)

string conversion

def f(params): statements

"%s-%s-%s" % (42,3.14,[1,2,3]) string formatting

def f(x, y=0): return x+y

'\t'.join(seq)

join sequences with separator def f(*a1, **a2): statements

s.decode('utf-8') u.encode('utf-8')

latin-1 string to unicode string unicode string to utf-8 string def f(): f.variable = 1 ...

conditional

object identity value identity while loop run else on normal exit do... while equivalent for loop

multiple identifiers end loop / jump to next print without newline list comprehension with lc-clauses empty statement function definition optional parameter additional list of unnamed, dict of named paramters 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) l.insert(i,x) l.remove(x) l.reverse() l.sort(f) zip(s,t,...)

append l2 at end of l

search and replace: find(s,b,e), rfind(s,b,e),

global v

instert x at pos. i

index(s,b,e), rindex(s,b,e), count(s,b,e),

def make_adder_2(a):

delete first x

endswith(s,b,e), startswith(s,b,e), replace(o,n,m)

reverse l

formatting: capitalize, lower, upper, swapcase, title

sort using f (default f =cmp) splitting: partition(s), rpartition(s), split(s,m),

[(s[0],t[0],...),..]

rsplit(s,m), splitlines(ke)

def add(b): return a+b return add lambda x: x+a compile(string,filename,kind)

bind to global variable closure

lambda expression compile string into code object

eval(expr,globals,locals) exec code in gldict, lcdict execfile(file,globals,locals) raw_input(prompt) input(prompt)

evaluate expression compile and execute code

execute file input from stdin

input and evaluate

class MyExcept(Exception): ... define user exception

raise MyExcept , data

raise user exception

5 System Interaction

sys.path

module search path

7 Standard Library (almost complete)

String Services: string, re, struct, difflib, StringIO, cStringIO, textwrap, codecs, unicodedata, stringprep, fpformat File/Directory Access: os.path, fileinput, stat, statvfs,

sys.platform

operating system

filecmp, tempfile, glob, fnmatch, linecache, shutil,

3 Object Orientation and Modules

import module as alias

import module

from module import name1,name2 load attr. into own namespace

from __future__ import *

activate all new features

reload module

reinitialize module

module.__all__

exported attributes

module.__name__ module.__dict__

module name / "__main__" module namespace

__import__("name",glb,loc,fl) import module by name

class name (superclass,...): class definition

data = value def method(self,...): ... def __init__(self, x):

Super.__init__(self) self.member = x def __del__(self): ...

shared class data methods constructor call superclass constructor per-instance data destructor

__str__, __len__, __cmp__,__ some operator overloaders

__iter__(self): return self

use next method for iterator

__call__

call interceptor

__dict__

instance-attribute dictionary

__getattr__(self, name),

get an unknown attribute

__setattr__(self, name, value) set any attribute

callable(object)

1 if callable, 0 otherwise

delattr(object, "name")

delete name-attr. from object

del(object)

unreference object/var

dir(object)

list of attr. assoc. with object

getattr(object, "name", def) get name-attr. from object

hasattr(object, "name")

check if object has attr.

hash(object) id(object)

return hash for object unique integer (mem address)

isinstance(object,

check for type

classOrType)

issubclass(class1, class2)

class2 subclass of class1?

iter(object, sentinel)

return iterator for object

locals()

dict of local vars of caller

repr(object), str(object)

return string-representation

vars(object) None

return __dict__ the NULL object

if __name__ == "__main__":

make modul executable

4 Exception Handling

try: ... except ExceptionName: except (Ex1, ...), data:

print data raise

Try-block catch exception multiple, with data exception handling pass up (re-raise) exception

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

os.startfile(f)

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,

shutil module: copy, copy2, copyfile, copyfileobj,

mimetools, mimetypes, MimeWriter, mimify, multifile,

copymode, copystat, copytree, rmtree

rfc822, base64, binhex, binascii, quopri, uu

os.path module: abspath, altsep, basename, commonprefix, Structured Markup Processing Tools: HTMLParser, sgmllib,

curdir, defpath, dirname, exists, expanduser,

htmllib, htmlentitydefs, xml.parsers.expat, xml.dom.*,

expandvar, extsep, get[acm]time, getsize, isabs,

xml.sax.*, xml.etree.ElementTree

isdir, isfile, islink, ismout, join, lexists,

File Formats: csv, ConfigParser, robotparser, netrc,

normcase, normpath, pardir, pathsep, realpath,

xdrlib

samefile, sameopenfile, samestat, sep, split,

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,

6 Input/Output

f=codecs.open(if,"rb","utf-8") file = open(infilename, "wb") codecs.EncodedFile(...) r, w, a, r+ rb, wb, ab, r+b file.read(N) file.readline() file.readlines() file.write(string) file.writelines(list) file.close() file.tell() file.seek(offset, whence) os.truncate(size) os.tmpfile()

httplib, ftplib, imaplib, nntplib, ...lib, smtpd,

open file with encoding

open file without encoding wrap file into encoding

read, write, append, random modes without eol conversion

N bytes ( entire file if no N ) the next linestring

list of linestring write string to file

write list of linestrings close file

current file position jump to file position

uuid, urlparse, SocketServer, ...Server,, cookielib, Cookie, xmlrpclib Multimedia: audioop, imageop, aifc, sunau, wave, chunk, colorsys, rgbimg, imghdr, sndhdr, ossaudiodev Tk: Tkinter, Tix, ScrolledText, turtle Internationalization: gettext, locale Program Frameworks: cmd, shlex Development: pydoc, doctest, unittest, test Runtime: sys, warnings, contextlib, atexit, traceback, qc, inspect, site, user, fpectl Custom Interpreters: code, codeop Restricted Execution: rexec, Bastion Importing: imp, zipimport, pkgutil, modulefinder, runpy

limit output to size

Language: parser, symbol, token, keyword, tokenize,

open anon temporary file

tabnanny, pyclbr, py_compile, compileall, dis,

else: ...

if no exception occurred

pickle.dump(x, file)

make object persistent

pickletools, distutils

finally: ...

in any case

x = pickle.load(file)

load object from file

Windows: msilib, msvcrt, _winreq, winsound

assert expression

debug assertion

Misc: formatter

 ................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download