/Misc/cheatsheet

http://unladen-swallow.googlecode.com/ · #! · 2273 lines · 2013 code · 260 blank · 0 comment · 0 complexity · 6d0877ea0a3c35766882171baeedf190 MD5 · raw file

Large files are truncated click here to view the full file

  1. Python 2.3 Quick Reference
  2. 25 Jan 2003 upgraded by Raymond Hettinger for Python 2.3
  3. 16 May 2001 upgraded by Richard Gruet and Simon Brunning for Python 2.0
  4. 2000/07/18 upgraded by Richard Gruet, rgruet@intraware.com for Python 1.5.2
  5. from V1.3 ref
  6. 1995/10/30, by Chris Hoffmann, choffman@vicorp.com
  7. Based on:
  8. Python Bestiary, Author: Ken Manheimer, ken.manheimer@nist.gov
  9. Python manuals, Authors: Guido van Rossum and Fred Drake
  10. What's new in Python 2.0, Authors: A.M. Kuchling and Moshe Zadka
  11. python-mode.el, Author: Tim Peters, tim_one@email.msn.com
  12. and the readers of comp.lang.python
  13. Python's nest: http://www.python.org Developement: http://
  14. python.sourceforge.net/ ActivePython : http://www.ActiveState.com/ASPN/
  15. Python/
  16. newsgroup: comp.lang.python Help desk: help@python.org
  17. Resources: http://starship.python.net/
  18. http://www.vex.net/parnassus/
  19. http://aspn.activestate.com/ASPN/Cookbook/Python
  20. FAQ: http://www.python.org/cgi-bin/faqw.py
  21. Full documentation: http://www.python.org/doc/
  22. Excellent reference books:
  23. Python Essential Reference by David Beazley (New Riders)
  24. Python Pocket Reference by Mark Lutz (O'Reilly)
  25. Invocation Options
  26. python [-diOStuUvxX?] [-c command | script | - ] [args]
  27. Invocation Options
  28. Option Effect
  29. -c cmd program passed in as string (terminates option list)
  30. -d Outputs parser debugging information (also PYTHONDEBUG=x)
  31. -E ignore environment variables (such as PYTHONPATH)
  32. -h print this help message and exit
  33. -i Inspect interactively after running script (also PYTHONINSPECT=x) and
  34. force prompts, even if stdin appears not to be a terminal
  35. -m mod run library module as a script (terminates option list
  36. -O optimize generated bytecode (a tad; also PYTHONOPTIMIZE=x)
  37. -OO remove doc-strings in addition to the -O optimizations
  38. -Q arg division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew
  39. -S Don't perform 'import site' on initialization
  40. -t Issue warnings about inconsistent tab usage (-tt: issue errors)
  41. -u Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x).
  42. -v Verbose (trace import statements) (also PYTHONVERBOSE=x)
  43. -W arg : warning control (arg is action:message:category:module:lineno)
  44. -x Skip first line of source, allowing use of non-unix Forms of #!cmd
  45. -? Help!
  46. -3 warn about Python 3.x incompatibilities
  47. -c Specify the command to execute (see next section). This terminates the
  48. command option list (following options are passed as arguments to the command).
  49. the name of a python file (.py) to execute read from stdin.
  50. script Anything afterward is passed as options to python script or command,
  51. not interpreted as an option to interpreter itself.
  52. args passed to script or command (in sys.argv[1:])
  53. If no script or command, Python enters interactive mode.
  54. * Available IDEs in std distrib: IDLE (tkinter based, portable), Pythonwin
  55. (Windows).
  56. Environment variables
  57. Environment variables
  58. Variable Effect
  59. PYTHONHOME Alternate prefix directory (or prefix;exec_prefix). The
  60. default module search path uses prefix/lib
  61. Augments the default search path for module files. The format
  62. is the same as the shell's $PATH: one or more directory
  63. pathnames separated by ':' or ';' without spaces around
  64. (semi-)colons!
  65. PYTHONPATH On Windows first search for Registry key HKEY_LOCAL_MACHINE\
  66. Software\Python\PythonCore\x.y\PythonPath (default value). You
  67. may also define a key named after your application with a
  68. default string value giving the root directory path of your
  69. app.
  70. If this is the name of a readable file, the Python commands in
  71. PYTHONSTARTUP that file are executed before the first prompt is displayed in
  72. interactive mode (no default).
  73. PYTHONDEBUG If non-empty, same as -d option
  74. PYTHONINSPECT If non-empty, same as -i option
  75. PYTHONSUPPRESS If non-empty, same as -s option
  76. PYTHONUNBUFFERED If non-empty, same as -u option
  77. PYTHONVERBOSE If non-empty, same as -v option
  78. PYTHONCASEOK If non-empty, ignore case in file/module names (imports)
  79. Notable lexical entities
  80. Keywords
  81. and del for is raise
  82. assert elif from lambda return
  83. break else global not try
  84. class except if or while
  85. continue exec import pass yield
  86. def finally in print
  87. * (list of keywords in std module: keyword)
  88. * Illegitimate Tokens (only valid in strings): @ $ ?
  89. * A statement must all be on a single line. To break a statement over
  90. multiple lines use "\", as with the C preprocessor.
  91. Exception: can always break when inside any (), [], or {} pair, or in
  92. triple-quoted strings.
  93. * More than one statement can appear on a line if they are separated with
  94. semicolons (";").
  95. * Comments start with "#" and continue to end of line.
  96. Identifiers
  97. (letter | "_") (letter | digit | "_")*
  98. * Python identifiers keywords, attributes, etc. are case-sensitive.
  99. * Special forms: _ident (not imported by 'from module import *'); __ident__
  100. (system defined name);
  101. __ident (class-private name mangling)
  102. Strings
  103. "a string enclosed by double quotes"
  104. 'another string delimited by single quotes and with a " inside'
  105. '''a string containing embedded newlines and quote (') marks, can be
  106. delimited with triple quotes.'''
  107. """ may also use 3- double quotes as delimiters """
  108. u'a unicode string' U"Another unicode string"
  109. r'a raw string where \ are kept (literalized): handy for regular
  110. expressions and windows paths!'
  111. R"another raw string" -- raw strings cannot end with a \
  112. ur'a unicode raw string' UR"another raw unicode"
  113. Use \ at end of line to continue a string on next line.
  114. adjacent strings are concatened, e.g. 'Monty' ' Python' is the same as
  115. 'Monty Python'.
  116. u'hello' + ' world' --> u'hello world' (coerced to unicode)
  117. String Literal Escapes
  118. \newline Ignored (escape newline)
  119. \\ Backslash (\) \e Escape (ESC) \v Vertical Tab (VT)
  120. \' Single quote (') \f Formfeed (FF) \OOO char with octal value OOO
  121. \" Double quote (") \n Linefeed (LF)
  122. \a Bell (BEL) \r Carriage Return (CR) \xHH char with hex value HH
  123. \b Backspace (BS) \t Horizontal Tab (TAB)
  124. \uHHHH unicode char with hex value HHHH, can only be used in unicode string
  125. \UHHHHHHHH unicode char with hex value HHHHHHHH, can only be used in unicode string
  126. \AnyOtherChar is left as-is
  127. * NUL byte (\000) is NOT an end-of-string marker; NULs may be embedded in
  128. strings.
  129. * Strings (and tuples) are immutable: they cannot be modified.
  130. Numbers
  131. Decimal integer: 1234, 1234567890546378940L (or l)
  132. Octal integer: 0177, 0177777777777777777 (begin with a 0)
  133. Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFF (begin with 0x or 0X)
  134. Long integer (unlimited precision): 1234567890123456
  135. Float (double precision): 3.14e-10, .001, 10., 1E3
  136. Complex: 1J, 2+3J, 4+5j (ends with J or j, + separates (float) real and
  137. imaginary parts)
  138. Sequences
  139. * String of length 0, 1, 2 (see above)
  140. '', '1', "12", 'hello\n'
  141. * Tuple of length 0, 1, 2, etc:
  142. () (1,) (1,2) # parentheses are optional if len > 0
  143. * List of length 0, 1, 2, etc:
  144. [] [1] [1,2]
  145. Indexing is 0-based. Negative indices (usually) mean count backwards from end
  146. of sequence.
  147. Sequence slicing [starting-at-index : but-less-than-index]. Start defaults to
  148. '0'; End defaults to 'sequence-length'.
  149. a = (0,1,2,3,4,5,6,7)
  150. a[3] ==> 3
  151. a[-1] ==> 7
  152. a[2:4] ==> (2, 3)
  153. a[1:] ==> (1, 2, 3, 4, 5, 6, 7)
  154. a[:3] ==> (0, 1, 2)
  155. a[:] ==> (0,1,2,3,4,5,6,7) # makes a copy of the sequence.
  156. Dictionaries (Mappings)
  157. {} # Zero length empty dictionary
  158. {1 : 'first'} # Dictionary with one (key, value) pair
  159. {1 : 'first', 'next': 'second'}
  160. dict([('one',1),('two',2)]) # Construct a dict from an item list
  161. dict('one'=1, 'two'=2) # Construct a dict using keyword args
  162. dict.fromkeys(['one', 'keys']) # Construct a dict from a sequence
  163. Operators and their evaluation order
  164. Operators and their evaluation order
  165. Highest Operator Comment
  166. (...) [...] {...} `...` Tuple, list & dict. creation; string
  167. conv.
  168. s[i] s[i:j] s.attr f(...) indexing & slicing; attributes, fct
  169. calls
  170. +x, -x, ~x Unary operators
  171. x**y Power
  172. x*y x/y x%y x//y mult, division, modulo, floor division
  173. x+y x-y addition, subtraction
  174. x<<y x>>y Bit shifting
  175. x&y Bitwise and
  176. x^y Bitwise exclusive or
  177. x|y Bitwise or
  178. x<y x<=y x>y x>=y x==y x!=y Comparison,
  179. x<>y identity,
  180. x is y x is not y membership
  181. x in s x not in s
  182. not x boolean negation
  183. x and y boolean and
  184. x or y boolean or
  185. Lowest lambda args: expr anonymous function
  186. Alternate names are defined in module operator (e.g. __add__ and add for +)
  187. Most operators are overridable.
  188. Many binary operators also support augmented assignment:
  189. x += 1 # Same as x = x + 1
  190. Basic Types and Their Operations
  191. Comparisons (defined between *any* types)
  192. Comparisons
  193. Comparison Meaning Notes
  194. < strictly less than (1)
  195. <= less than or equal to
  196. > strictly greater than
  197. >= greater than or equal to
  198. == equal to
  199. != or <> not equal to
  200. is object identity (2)
  201. is not negated object identity (2)
  202. Notes :
  203. Comparison behavior can be overridden for a given class by defining special
  204. method __cmp__.
  205. The above comparisons return True or False which are of type bool
  206. (a subclass of int) and behave exactly as 1 or 0 except for their type and
  207. that they print as True or False instead of 1 or 0.
  208. (1) X < Y < Z < W has expected meaning, unlike C
  209. (2) Compare object identities (i.e. id(object)), not object values.
  210. Boolean values and operators
  211. Boolean values and operators
  212. Value or Operator Returns Notes
  213. None, numeric zeros, empty sequences and False
  214. mappings
  215. all other values True
  216. not x True if x is False, else
  217. True
  218. x or y if x is False then y, else (1)
  219. x
  220. x and y if x is False then x, else (1)
  221. y
  222. Notes :
  223. Truth testing behavior can be overridden for a given class by defining
  224. special method __nonzero__.
  225. (1) Evaluate second arg only if necessary to determine outcome.
  226. None
  227. None is used as default return value on functions. Built-in single object
  228. with type NoneType.
  229. Input that evaluates to None does not print when running Python
  230. interactively.
  231. Numeric types
  232. Floats, integers and long integers.
  233. Floats are implemented with C doubles.
  234. Integers are implemented with C longs.
  235. Long integers have unlimited size (only limit is system resources)
  236. Operators on all numeric types
  237. Operators on all numeric types
  238. Operation Result
  239. abs(x) the absolute value of x
  240. int(x) x converted to integer
  241. long(x) x converted to long integer
  242. float(x) x converted to floating point
  243. -x x negated
  244. +x x unchanged
  245. x + y the sum of x and y
  246. x - y difference of x and y
  247. x * y product of x and y
  248. x / y quotient of x and y
  249. x % y remainder of x / y
  250. divmod(x, y) the tuple (x/y, x%y)
  251. x ** y x to the power y (the same as pow(x, y))
  252. Bit operators on integers and long integers
  253. Bit operators
  254. Operation >Result
  255. ~x the bits of x inverted
  256. x ^ y bitwise exclusive or of x and y
  257. x & y bitwise and of x and y
  258. x | y bitwise or of x and y
  259. x << n x shifted left by n bits
  260. x >> n x shifted right by n bits
  261. Complex Numbers
  262. * represented as a pair of machine-level double precision floating point
  263. numbers.
  264. * The real and imaginary value of a complex number z can be retrieved through
  265. the attributes z.real and z.imag.
  266. Numeric exceptions
  267. TypeError
  268. raised on application of arithmetic operation to non-number
  269. OverflowError
  270. numeric bounds exceeded
  271. ZeroDivisionError
  272. raised when zero second argument of div or modulo op
  273. FloatingPointError
  274. raised when a floating point operation fails
  275. Operations on all sequence types (lists, tuples, strings)
  276. Operations on all sequence types
  277. Operation Result Notes
  278. x in s True if an item of s is equal to x, else False
  279. x not in s False if an item of s is equal to x, else True
  280. for x in s: loops over the sequence
  281. s + t the concatenation of s and t
  282. s * n, n*s n copies of s concatenated
  283. s[i] i'th item of s, origin 0 (1)
  284. s[i:j] slice of s from i (included) to j (excluded) (1), (2)
  285. len(s) length of s
  286. min(s) smallest item of s
  287. max(s) largest item of (s)
  288. iter(s) returns an iterator over s. iterators define __iter__ and next()
  289. Notes :
  290. (1) if i or j is negative, the index is relative to the end of the string,
  291. ie len(s)+ i or len(s)+j is
  292. substituted. But note that -0 is still 0.
  293. (2) The slice of s from i to j is defined as the sequence of items with
  294. index k such that i <= k < j.
  295. If i or j is greater than len(s), use len(s). If i is omitted, use
  296. len(s). If i is greater than or
  297. equal to j, the slice is empty.
  298. Operations on mutable (=modifiable) sequences (lists)
  299. Operations on mutable sequences
  300. Operation Result Notes
  301. s[i] =x item i of s is replaced by x
  302. s[i:j] = t slice of s from i to j is replaced by t
  303. del s[i:j] same as s[i:j] = []
  304. s.append(x) same as s[len(s) : len(s)] = [x]
  305. s.count(x) return number of i's for which s[i] == x
  306. s.extend(x) same as s[len(s):len(s)]= x
  307. s.index(x) return smallest i such that s[i] == x (1)
  308. s.insert(i, x) same as s[i:i] = [x] if i >= 0
  309. s.pop([i]) same as x = s[i]; del s[i]; return x (4)
  310. s.remove(x) same as del s[s.index(x)] (1)
  311. s.reverse() reverse the items of s in place (3)
  312. s.sort([cmpFct]) sort the items of s in place (2), (3)
  313. Notes :
  314. (1) raise a ValueError exception when x is not found in s (i.e. out of
  315. range).
  316. (2) The sort() method takes an optional argument specifying a comparison
  317. fct of 2 arguments (list items) which should
  318. return -1, 0, or 1 depending on whether the 1st argument is
  319. considered smaller than, equal to, or larger than the 2nd
  320. argument. Note that this slows the sorting process down considerably.
  321. (3) The sort() and reverse() methods modify the list in place for economy
  322. of space when sorting or reversing a large list.
  323. They don't return the sorted or reversed list to remind you of this
  324. side effect.
  325. (4) [New 1.5.2] The optional argument i defaults to -1, so that by default the last
  326. item is removed and returned.
  327. Operations on mappings (dictionaries)
  328. Operations on mappings
  329. Operation Result Notes
  330. len(d) the number of items in d
  331. d[k] the item of d with key k (1)
  332. d[k] = x set d[k] to x
  333. del d[k] remove d[k] from d (1)
  334. d.clear() remove all items from d
  335. d.copy() a shallow copy of d
  336. d.get(k,defaultval) the item of d with key k (4)
  337. d.has_key(k) True if d has key k, else False
  338. d.items() a copy of d's list of (key, item) pairs (2)
  339. d.iteritems() an iterator over (key, value) pairs (7)
  340. d.iterkeys() an iterator over the keys of d (7)
  341. d.itervalues() an iterator over the values of d (7)
  342. d.keys() a copy of d's list of keys (2)
  343. d1.update(d2) for k, v in d2.items(): d1[k] = v (3)
  344. d.values() a copy of d's list of values (2)
  345. d.pop(k) remove d[k] and return its value
  346. d.popitem() remove and return an arbitrary (6)
  347. (key, item) pair
  348. d.setdefault(k,defaultval) the item of d with key k (5)
  349. Notes :
  350. TypeError is raised if key is not acceptable
  351. (1) KeyError is raised if key k is not in the map
  352. (2) Keys and values are listed in random order
  353. (3) d2 must be of the same type as d1
  354. (4) Never raises an exception if k is not in the map, instead it returns
  355. defaultVal.
  356. defaultVal is optional, when not provided and k is not in the map,
  357. None is returned.
  358. (5) Never raises an exception if k is not in the map, instead it returns
  359. defaultVal, and adds k to map with value defaultVal. defaultVal is
  360. optional. When not provided and k is not in the map, None is returned and
  361. added to map.
  362. (6) Raises a KeyError if the dictionary is emtpy.
  363. (7) While iterating over a dictionary, the values may be updated but
  364. the keys cannot be changed.
  365. Operations on strings
  366. Note that these string methods largely (but not completely) supersede the
  367. functions available in the string module.
  368. Operations on strings
  369. Operation Result Notes
  370. s.capitalize() return a copy of s with only its first character
  371. capitalized.
  372. s.center(width) return a copy of s centered in a string of length width (1)
  373. .
  374. s.count(sub[ return the number of occurrences of substring sub in (2)
  375. ,start[,end]]) string s.
  376. s.decode(([ return a decoded version of s. (3)
  377. encoding
  378. [,errors]])
  379. s.encode([ return an encoded version of s. Default encoding is the
  380. encoding current default string encoding. (3)
  381. [,errors]])
  382. s.endswith(suffix return true if s ends with the specified suffix, (2)
  383. [,start[,end]]) otherwise return False.
  384. s.expandtabs([ return a copy of s where all tab characters are (4)
  385. tabsize]) expanded using spaces.
  386. s.find(sub[,start return the lowest index in s where substring sub is (2)
  387. [,end]]) found. Return -1 if sub is not found.
  388. s.index(sub[ like find(), but raise ValueError when the substring is (2)
  389. ,start[,end]]) not found.
  390. s.isalnum() return True if all characters in s are alphanumeric, (5)
  391. False otherwise.
  392. s.isalpha() return True if all characters in s are alphabetic, (5)
  393. False otherwise.
  394. s.isdigit() return True if all characters in s are digit (5)
  395. characters, False otherwise.
  396. s.islower() return True if all characters in s are lowercase, False (6)
  397. otherwise.
  398. s.isspace() return True if all characters in s are whitespace (5)
  399. characters, False otherwise.
  400. s.istitle() return True if string s is a titlecased string, False (7)
  401. otherwise.
  402. s.isupper() return True if all characters in s are uppercase, False (6)
  403. otherwise.
  404. s.join(seq) return a concatenation of the strings in the sequence
  405. seq, separated by 's's.
  406. s.ljust(width) return s left justified in a string of length width. (1),
  407. (8)
  408. s.lower() return a copy of s converted to lowercase.
  409. s.lstrip() return a copy of s with leading whitespace removed.
  410. s.replace(old, return a copy of s with all occurrences of substring (9)
  411. new[, maxsplit]) old replaced by new.
  412. s.rfind(sub[ return the highest index in s where substring sub is (2)
  413. ,start[,end]]) found. Return -1 if sub is not found.
  414. s.rindex(sub[ like rfind(), but raise ValueError when the substring (2)
  415. ,start[,end]]) is not found.
  416. s.rjust(width) return s right justified in a string of length width. (1),
  417. (8)
  418. s.rstrip() return a copy of s with trailing whitespace removed.
  419. s.split([sep[ return a list of the words in s, using sep as the (10)
  420. ,maxsplit]]) delimiter string.
  421. s.splitlines([ return a list of the lines in s, breaking at line (11)
  422. keepends]) boundaries.
  423. s.startswith return true if s starts with the specified prefix,
  424. (prefix[,start[ otherwise return false. (2)
  425. ,end]])
  426. s.strip() return a copy of s with leading and trailing whitespace
  427. removed.
  428. s.swapcase() return a copy of s with uppercase characters converted
  429. to lowercase and vice versa.
  430. return a titlecased copy of s, i.e. words start with
  431. s.title() uppercase characters, all remaining cased characters
  432. are lowercase.
  433. s.translate(table return a copy of s mapped through translation table (12)
  434. [,deletechars]) table.
  435. s.upper() return a copy of s converted to uppercase.
  436. s.zfill(width) return a string padded with zeroes on the left side and
  437. sliding a minus sign left if necessary. never truncates.
  438. Notes :
  439. (1) Padding is done using spaces.
  440. (2) If optional argument start is supplied, substring s[start:] is
  441. processed. If optional arguments start and end are supplied, substring s[start:
  442. end] is processed.
  443. (3) Optional argument errors may be given to set a different error handling
  444. scheme. The default for errors is 'strict', meaning that encoding errors raise
  445. a ValueError. Other possible values are 'ignore' and 'replace'.
  446. (4) If optional argument tabsize is not given, a tab size of 8 characters
  447. is assumed.
  448. (5) Returns false if string s does not contain at least one character.
  449. (6) Returns false if string s does not contain at least one cased
  450. character.
  451. (7) A titlecased string is a string in which uppercase characters may only
  452. follow uncased characters and lowercase characters only cased ones.
  453. (8) s is returned if width is less than len(s).
  454. (9) If the optional argument maxsplit is given, only the first maxsplit
  455. occurrences are replaced.
  456. (10) If sep is not specified or None, any whitespace string is a separator.
  457. If maxsplit is given, at most maxsplit splits are done.
  458. (11) Line breaks are not included in the resulting list unless keepends is
  459. given and true.
  460. (12) table must be a string of length 256. All characters occurring in the
  461. optional argument deletechars are removed prior to translation.
  462. String formatting with the % operator
  463. formatString % args--> evaluates to a string
  464. * formatString uses C printf format codes : %, c, s, i, d, u, o, x, X, e, E,
  465. f, g, G, r (details below).
  466. * Width and precision may be a * to specify that an integer argument gives
  467. the actual width or precision.
  468. * The flag characters -, +, blank, # and 0 are understood. (details below)
  469. * %s will convert any type argument to string (uses str() function)
  470. * args may be a single arg or a tuple of args
  471. '%s has %03d quote types.' % ('Python', 2) # => 'Python has 002 quote types.'
  472. * Right-hand-side can also be a mapping:
  473. a = '%(lang)s has %(c)03d quote types.' % {'c':2, 'lang':'Python}
  474. (vars() function very handy to use on right-hand-side.)
  475. Format codes
  476. Conversion Meaning
  477. d Signed integer decimal.
  478. i Signed integer decimal.
  479. o Unsigned octal.
  480. u Unsigned decimal.
  481. x Unsigned hexadecimal (lowercase).
  482. X Unsigned hexadecimal (uppercase).
  483. e Floating point exponential format (lowercase).
  484. E Floating point exponential format (uppercase).
  485. f Floating point decimal format.
  486. F Floating point decimal format.
  487. g Same as "e" if exponent is greater than -4 or less than precision,
  488. "f" otherwise.
  489. G Same as "E" if exponent is greater than -4 or less than precision,
  490. "F" otherwise.
  491. c Single character (accepts integer or single character string).
  492. r String (converts any python object using repr()).
  493. s String (converts any python object using str()).
  494. % No argument is converted, results in a "%" character in the result.
  495. (The complete specification is %%.)
  496. Conversion flag characters
  497. Flag Meaning
  498. # The value conversion will use the ``alternate form''.
  499. 0 The conversion will be zero padded.
  500. - The converted value is left adjusted (overrides "-").
  501. (a space) A blank should be left before a positive number (or empty
  502. string) produced by a signed conversion.
  503. + A sign character ("+" or "-") will precede the conversion (overrides a
  504. "space" flag).
  505. File Objects
  506. Created with built-in function open; may be created by other modules' functions
  507. as well.
  508. Operators on file objects
  509. File operations
  510. Operation Result
  511. f.close() Close file f.
  512. f.fileno() Get fileno (fd) for file f.
  513. f.flush() Flush file f's internal buffer.
  514. f.isatty() True if file f is connected to a tty-like dev, else False.
  515. f.read([size]) Read at most size bytes from file f and return as a string
  516. object. If size omitted, read to EOF.
  517. f.readline() Read one entire line from file f.
  518. f.readlines() Read until EOF with readline() and return list of lines read.
  519. Set file f's position, like "stdio's fseek()".
  520. f.seek(offset[, whence == 0 then use absolute indexing.
  521. whence=0]) whence == 1 then offset relative to current pos.
  522. whence == 2 then offset relative to file end.
  523. f.tell() Return file f's current position (byte offset).
  524. f.write(str) Write string to file f.
  525. f.writelines(list Write list of strings to file f.
  526. )
  527. File Exceptions
  528. EOFError
  529. End-of-file hit when reading (may be raised many times, e.g. if f is a
  530. tty).
  531. IOError
  532. Other I/O-related I/O operation failure.
  533. OSError
  534. OS system call failed.
  535. Advanced Types
  536. -See manuals for more details -
  537. + Module objects
  538. + Class objects
  539. + Class instance objects
  540. + Type objects (see module: types)
  541. + File objects (see above)
  542. + Slice objects
  543. + XRange objects
  544. + Callable types:
  545. o User-defined (written in Python):
  546. # User-defined Function objects
  547. # User-defined Method objects
  548. o Built-in (written in C):
  549. # Built-in Function objects
  550. # Built-in Method objects
  551. + Internal Types:
  552. o Code objects (byte-compile executable Python code: bytecode)
  553. o Frame objects (execution frames)
  554. o Traceback objects (stack trace of an exception)
  555. Statements
  556. pass -- Null statement
  557. del name[,name]* -- Unbind name(s) from object. Object will be indirectly
  558. (and automatically) deleted only if no longer referenced.
  559. print [>> fileobject,] [s1 [, s2 ]* [,]
  560. -- Writes to sys.stdout, or to fileobject if supplied.
  561. Puts spaces between arguments. Puts newline at end
  562. unless statement ends with comma.
  563. Print is not required when running interactively,
  564. simply typing an expression will print its value,
  565. unless the value is None.
  566. exec x [in globals [,locals]]
  567. -- Executes x in namespaces provided. Defaults
  568. to current namespaces. x can be a string, file
  569. object or a function object.
  570. callable(value,... [id=value], [*args], [**kw])
  571. -- Call function callable with parameters. Parameters can
  572. be passed by name or be omitted if function
  573. defines default values. E.g. if callable is defined as
  574. "def callable(p1=1, p2=2)"
  575. "callable()" <=> "callable(1, 2)"
  576. "callable(10)" <=> "callable(10, 2)"
  577. "callable(p2=99)" <=> "callable(1, 99)"
  578. *args is a tuple of positional arguments.
  579. **kw is a dictionary of keyword arguments.
  580. Assignment operators
  581. Caption
  582. Operator Result Notes
  583. a = b Basic assignment - assign object b to label a (1)
  584. a += b Roughly equivalent to a = a + b (2)
  585. a -= b Roughly equivalent to a = a - b (2)
  586. a *= b Roughly equivalent to a = a * b (2)
  587. a /= b Roughly equivalent to a = a / b (2)
  588. a %= b Roughly equivalent to a = a % b (2)
  589. a **= b Roughly equivalent to a = a ** b (2)
  590. a &= b Roughly equivalent to a = a & b (2)
  591. a |= b Roughly equivalent to a = a | b (2)
  592. a ^= b Roughly equivalent to a = a ^ b (2)
  593. a >>= b Roughly equivalent to a = a >> b (2)
  594. a <<= b Roughly equivalent to a = a << b (2)
  595. Notes :
  596. (1) Can unpack tuples, lists, and strings.
  597. first, second = a[0:2]; [f, s] = range(2); c1,c2,c3='abc'
  598. Tip: x,y = y,x swaps x and y.
  599. (2) Not exactly equivalent - a is evaluated only once. Also, where
  600. possible, operation performed in-place - a is modified rather than
  601. replaced.
  602. Control Flow
  603. if condition: suite
  604. [elif condition: suite]*
  605. [else: suite] -- usual if/else_if/else statement
  606. while condition: suite
  607. [else: suite]
  608. -- usual while statement. "else" suite is executed
  609. after loop exits, unless the loop is exited with
  610. "break"
  611. for element in sequence: suite
  612. [else: suite]
  613. -- iterates over sequence, assigning each element to element.
  614. Use built-in range function to iterate a number of times.
  615. "else" suite executed at end unless loop exited
  616. with "break"
  617. break -- immediately exits "for" or "while" loop
  618. continue -- immediately does next iteration of "for" or "while" loop
  619. return [result] -- Exits from function (or method) and returns result (use a tuple to
  620. return more than one value). If no result given, then returns None.
  621. yield result -- Freezes the execution frame of a generator and returns the result
  622. to the iterator's .next() method. Upon the next call to next(),
  623. resumes execution at the frozen point with all of the local variables
  624. still intact.
  625. Exception Statements
  626. assert expr[, message]
  627. -- expr is evaluated. if false, raises exception AssertionError
  628. with message. Inhibited if __debug__ is 0.
  629. try: suite1
  630. [except [exception [, value]: suite2]+
  631. [else: suite3]
  632. -- statements in suite1 are executed. If an exception occurs, look
  633. in "except" clauses for matching <exception>. If matches or bare
  634. "except" execute suite of that clause. If no exception happens
  635. suite in "else" clause is executed after suite1.
  636. If exception has a value, it is put in value.
  637. exception can also be tuple of exceptions, e.g.
  638. "except (KeyError, NameError), val: print val"
  639. try: suite1
  640. finally: suite2
  641. -- statements in suite1 are executed. If no
  642. exception, execute suite2 (even if suite1 is
  643. exited with a "return", "break" or "continue"
  644. statement). If exception did occur, executes
  645. suite2 and then immediately reraises exception.
  646. raise exception [,value [, traceback]]
  647. -- raises exception with optional value
  648. value. Arg traceback specifies a traceback object to
  649. use when printing the exception's backtrace.
  650. raise -- a raise statement without arguments re-raises
  651. the last exception raised in the current function
  652. An exception is either a string (object) or a class instance.
  653. Can create a new one simply by creating a new string:
  654. my_exception = 'You did something wrong'
  655. try:
  656. if bad:
  657. raise my_exception, bad
  658. except my_exception, value:
  659. print 'Oops', value
  660. Exception classes must be derived from the predefined class: Exception, e.g.:
  661. class text_exception(Exception): pass
  662. try:
  663. if bad:
  664. raise text_exception()
  665. # This is a shorthand for the form
  666. # "raise <class>, <instance>"
  667. except Exception:
  668. print 'Oops'
  669. # This will be printed because
  670. # text_exception is a subclass of Exception
  671. When an error message is printed for an unhandled exception which is a
  672. class, the class name is printed, then a colon and a space, and
  673. finally the instance converted to a string using the built-in function
  674. str().
  675. All built-in exception classes derives from StandardError, itself
  676. derived from Exception.
  677. Name Space Statements
  678. [1.51: On Mac & Windows, the case of module file names must now match the case
  679. as used
  680. in the import statement]
  681. Packages (>1.5): a package is a name space which maps to a directory including
  682. module(s) and the special initialization module '__init__.py'
  683. (possibly empty). Packages/dirs can be nested. You address a
  684. module's symbol via '[package.[package...]module.symbol's.
  685. import module1 [as name1] [, module2]*
  686. -- imports modules. Members of module must be
  687. referred to by qualifying with [package.]module name:
  688. "import sys; print sys.argv:"
  689. "import package1.subpackage.module; package1.subpackage.module.foo()"
  690. module1 renamed as name1, if supplied.
  691. from module import name1 [as othername1] [, name2]*
  692. -- imports names from module module in current namespace.
  693. "from sys import argv; print argv"
  694. "from package1 import module; module.foo()"
  695. "from package1.module import foo; foo()"
  696. name1 renamed as othername1, if supplied.
  697. from module import *
  698. -- imports all names in module, except those starting with "_";
  699. *to be used sparsely, beware of name clashes* :
  700. "from sys import *; print argv"
  701. "from package.module import *; print x'
  702. NB: "from package import *" only imports the symbols defined
  703. in the package's __init__.py file, not those in the
  704. template modules!
  705. global name1 [, name2]*
  706. -- names are from global scope (usually meaning from module)
  707. rather than local (usually meaning only in function).
  708. -- E.g. in fct without "global" statements, assuming
  709. "a" is name that hasn't been used in fct or module
  710. so far:
  711. -Try to read from "a" -> NameError
  712. -Try to write to "a" -> creates "a" local to fcn
  713. -If "a" not defined in fct, but is in module, then
  714. -Try to read from "a", gets value from module
  715. -Try to write to "a", creates "a" local to fct
  716. But note "a[0]=3" starts with search for "a",
  717. will use to global "a" if no local "a".
  718. Function Definition
  719. def func_id ([param_list]): suite
  720. -- Creates a function object & binds it to name func_id.
  721. param_list ::= [id [, id]*]
  722. id ::= value | id = value | *id | **id
  723. [Args are passed by value.Thus only args representing a mutable object
  724. can be modified (are inout parameters). Use a tuple to return more than
  725. one value]
  726. Example:
  727. def test (p1, p2 = 1+1, *rest, **keywords):
  728. -- Parameters with "=" have default value (v is
  729. evaluated when function defined).
  730. If list has "*id" then id is assigned a tuple of
  731. all remaining args passed to function (like C vararg)
  732. If list has "**id" then id is assigned a dictionary of
  733. all extra arguments passed as keywords.
  734. Class Definition
  735. class <class_id> [(<super_class1> [,<super_class2>]*)]: <suite>
  736. -- Creates a class object and assigns it name <class_id>
  737. <suite> may contain local "defs" of class methods and
  738. assignments to class attributes.
  739. Example:
  740. class my_class (class1, class_list[3]): ...
  741. Creates a class object inheriting from both "class1" and whatever
  742. class object "class_list[3]" evaluates to. Assigns new
  743. class object to name "my_class".
  744. - First arg to class methods is always instance object, called 'self'
  745. by convention.
  746. - Special method __init__() is called when instance is created.
  747. - Special method __del__() called when no more reference to object.
  748. - Create instance by "calling" class object, possibly with arg
  749. (thus instance=apply(aClassObject, args...) creates an instance!)
  750. - In current implementation, can't subclass off built-in
  751. classes. But can "wrap" them, see UserDict & UserList modules,
  752. and see __getattr__() below.
  753. Example:
  754. class c (c_parent):
  755. def __init__(self, name): self.name = name
  756. def print_name(self): print "I'm", self.name
  757. def call_parent(self): c_parent.print_name(self)
  758. instance = c('tom')
  759. print instance.name
  760. 'tom'
  761. instance.print_name()
  762. "I'm tom"
  763. Call parent's super class by accessing parent's method
  764. directly and passing "self" explicitly (see "call_parent"
  765. in example above).
  766. Many other special methods available for implementing
  767. arithmetic operators, sequence, mapping indexing, etc.
  768. Documentation Strings
  769. Modules, classes and functions may be documented by placing a string literal by
  770. itself as the first statement in the suite. The documentation can be retrieved
  771. by getting the '__doc__' attribute from the module, class or function.
  772. Example:
  773. class C:
  774. "A description of C"
  775. def __init__(self):
  776. "A description of the constructor"
  777. # etc.
  778. Then c.__doc__ == "A description of C".
  779. Then c.__init__.__doc__ == "A description of the constructor".
  780. Others
  781. lambda [param_list]: returnedExpr
  782. -- Creates an anonymous function. returnedExpr must be
  783. an expression, not a statement (e.g., not "if xx:...",
  784. "print xxx", etc.) and thus can't contain newlines.
  785. Used mostly for filter(), map(), reduce() functions, and GUI callbacks..
  786. List comprehensions
  787. result = [expression for item1 in sequence1 [if condition1]
  788. [for item2 in sequence2 ... for itemN in sequenceN]
  789. ]
  790. is equivalent to:
  791. result = []
  792. for item1 in sequence1:
  793. for item2 in sequence2:
  794. ...
  795. for itemN in sequenceN:
  796. if (condition1) and furthur conditions:
  797. result.append(expression)
  798. Built-In Functions
  799. Built-In Functions
  800. Function Result
  801. __import__(name[, Imports module within the given context (see lib ref for
  802. globals[, locals[, more details)
  803. fromlist]]])
  804. abs(x) Return the absolute value of number x.
  805. apply(f, args[, Calls func/method f with arguments args and optional
  806. keywords]) keywords.
  807. bool(x) Returns True when the argument x is true and False otherwise.
  808. buffer(obj) Creates a buffer reference to an object.
  809. callable(x) Returns True if x callable, else False.
  810. chr(i) Returns one-character string whose ASCII code isinteger i
  811. classmethod(f) Converts a function f, into a method with the class as the
  812. first argument. Useful for creating alternative constructors.
  813. cmp(x,y) Returns negative, 0, positive if x <, ==, > to y
  814. coerce(x,y) Returns a tuple of the two numeric arguments converted to a
  815. common type.
  816. Compiles string into a code object.filename is used in
  817. error message, can be any string. It isusually the file
  818. compile(string, from which the code was read, or eg. '<string>'if not read
  819. filename, kind) from file.kind can be 'eval' if string is a single stmt, or
  820. 'single' which prints the output of expression statements
  821. thatevaluate to something else than None, or be 'exec'.
  822. complex(real[, Builds a complex object (can also be done using J or j
  823. image]) suffix,e.g. 1+3J)
  824. delattr(obj, name) deletes attribute named name of object obj <=> del obj.name
  825. If no args, returns the list of names in current
  826. dict([items]) Create a new dictionary from the specified item list.
  827. dir([object]) localsymbol table. With a module, class or class
  828. instanceobject as arg, returns list of names in its attr.
  829. dict.
  830. divmod(a,b) Returns tuple of (a/b, a%b)
  831. enumerate(seq) Return a iterator giving: (0, seq[0]), (1, seq[1]), ...
  832. eval(s[, globals[, Eval string s in (optional) globals, locals contexts.s must
  833. locals]]) have no NUL's or newlines. s can also be acode object.
  834. Example: x = 1; incr_x = eval('x + 1')
  835. execfile(file[, Executes a file without creating a new module, unlike
  836. globals[, locals]]) import.
  837. file() Synonym for open().
  838. filter(function, Constructs a list from those elements of sequence for which
  839. sequence) function returns true. function takes one parameter.
  840. float(x) Converts a number or a string to floating point.
  841. getattr(object, [<default> arg added in 1.5.2]Gets attribute called name
  842. name[, default])) from object,e.g. getattr(x, 'f') <=> x.f). If not found,
  843. raisesAttributeError or returns default if specified.
  844. globals() Returns a dictionary containing current global variables.
  845. hasattr(object, Returns true if object has attr called name.
  846. name)
  847. hash(object) Returns the hash value of the object (if it has one)
  848. help(f) Display documentation on object f.
  849. hex(x) Converts a number x to a hexadecimal string.
  850. id(object) Returns a unique 'identity' integer for an object.
  851. input([prompt]) Prints prompt if given. Reads input and evaluates it.
  852. Converts a number or a string to a plain integer. Optional
  853. int(x[, base]) base paramenter specifies base from which to convert string
  854. values.
  855. intern(aString) Enters aString in the table of "interned strings"
  856. andreturns the string. Interned strings are 'immortals'.
  857. isinstance(obj, returns true if obj is an instance of class. Ifissubclass
  858. class) (A,B) then isinstance(x,A) => isinstance(x,B)
  859. issubclass(class1, returns true if class1 is derived from class2
  860. class2)
  861. Returns the length (the number of items) of an object
  862. iter(collection) Returns an iterator over the collection.
  863. len(obj) (sequence, dictionary, or instance of class implementing
  864. __len__).
  865. list(sequence) Converts sequence into a list. If already a list,returns a
  866. copy of it.
  867. locals() Returns a dictionary containing current local variables.
  868. Converts a number or a string to a long integer. Optional
  869. long(x[, base]) base paramenter specifies base from which to convert string
  870. values.
  871. Applies function to every item of list and returns a listof
  872. map(function, list, the results. If additional arguments are passed,function
  873. ...) must take that many arguments and it is givento function on
  874. each call.
  875. max(seq) Returns the largest item of the non-empty sequence seq.
  876. min(seq) Returns the smallest item of a non-empty sequence seq.
  877. oct(x) Converts a number to an octal string.
  878. open(filename [, Returns a new file object. First two args are same asthose
  879. mode='r', [bufsize= for C's "stdio open" function. bufsize is 0for unbuffered,
  880. implementation 1 for line-buffered, negative forsys-default, all else, of
  881. dependent]]) (about) given size.
  882. ord(c) Returns integer ASCII value of c (a string of len 1). Works
  883. with Unicode char.
  884. object() Create a base type. Used as a superclass for new-style objects.
  885. open(name Open a file.
  886. [, mode
  887. [, buffering]])
  888. pow(x, y [, z]) Returns x to power y [modulo z]. See also ** operator.
  889. property() Created a property with access controlled by functions.
  890. range(start [,end Returns list of ints from >= start and < end.With 1 arg,
  891. [, step]]) list from 0..arg-1With 2 args, list from start..end-1With 3
  892. args, list from start up to end by step
  893. raw_input([prompt]) Prints prompt if given, then reads string from stdinput (no
  894. trailing \n). See also input().
  895. reduce(f, list [, Applies the binary function f to the items oflist so as to
  896. init]) reduce the list to a single value.If init given, it is
  897. "prepended" to list.
  898. Re-parses and re-initializes an already imported module.
  899. Useful in interactive mode, if you want to reload amodule
  900. reload(module) after fixing it. If module was syntacticallycorrect but had
  901. an error in initialization, mustimport it one more time
  902. before calling reload().
  903. Returns a string containing a printable and if possible
  904. repr(object) evaluable representation of an object. <=> `object`
  905. (usingbackquotes). Class redefinissable (__repr__). See
  906. also str()
  907. round(x, n=0) Returns the floating point value x rounded to n digitsafter
  908. the decimal point.
  909. setattr(object, This is the counterpart of getattr().setattr(o, 'foobar',
  910. name, value) 3) <=> o.foobar = 3Creates attribute if it doesn't exist!
  911. slice([start,] stop Returns a slice object representing a range, with R/
  912. [, step]) Oattributes: start, stop, step.
  913. Returns a string containing a nicely
  914. staticmethod() Convert a function to method with no self or class
  915. argument. Useful for methods associated with a class that
  916. do not need access to an object's internal state.
  917. str(object) printablerepresentation of an object. Class overridable
  918. (__str__).See also repr().
  919. super(type) Create an unbound super object. Used to call cooperative
  920. superclass methods.
  921. sum(sequence, Add the values in the sequence and return the sum.
  922. [start])
  923. tuple(sequence) Creates a tuple with same elements as sequence. If already
  924. a tuple, return itself (not a copy).
  925. Returns a type object [see module types] representing
  926. thetype of obj. Example: import typesif type(x) ==
  927. type(obj) types.StringType: print 'It is a string'NB: it is
  928. recommanded to use the following form:if isinstance(x,
  929. types.StringType): etc...
  930. unichr(code) code.
  931. unicode(string[, Creates a Unicode string from a 8-bit string, using
  932. encoding[, error thegiven encoding name and error treatment (