pcjavanet
pcjavanet

Python 2.5 Quick Reference

Style chooser: Modern, Modern Black&White, Classic, High contrast or Printing
[Hint: Use styles Modern Black & White or Printing to print. If you get problems, try printing the PDF versions instead]

Contents

  • Front matter
  • Invocation Options
  • Environment variables
  • Lexical entities : keywords, identifiers, string literals, boolean constants, numbers, sequences, dictionaries, operators
  • Basic types and their operations: None, bool, Numeric types, sequence types, list, dictionary, string, file, set, date/time
  • Advanced types
  • Statements: assignment, conditional expressions, control flow, exceptions, name space, function def, class def
  • Iterators; Generators; Descriptors; Decorators
  • Built-in Functions
  • Built-in Exceptions
  • Standard methods & operators redefinition in user-created Classes
  • Special informative state attributes for some types
  • Important modules : sys, os, posix, posixpath, shutil, time, string, re, math, getopt
  • List of modules in the base distribution
  • Workspace exploration and idiom hints
  • Python mode for Emacs

Front matter

Version 2.5 (What's new?)
Check updates at http://rgruet.free.fr/#QuickRef.
Please report errors, inaccuracies and suggestions to Richard Gruet (pqr at rgruet.net).

Creative Commons License.

 

Last modified on August 16, 2009
14 Dec 2006,
upgraded by Richard Gruet for Python 2.5
17 Feb 2005,
upgraded by Richard Gruet for Python 2.4
03 Oct 2003,
upgraded by Richard Gruet for Python 2.3
11 May 2003, rev 4
upgraded by Richard Gruet for Python 2.2 (restyled by Andrei)
7 Aug 2001
upgraded by Simon Brunning for Python 2.1
16 May 2001
upgraded by Richard Gruet and Simon Brunning for Python 2.0
18 Jun 2000
upgraded by Richard Gruet for Python 1.5.2
30 Oct 1995
created by Chris Hoffmann for Python 1.3

Color coding:

Features added in 2.5 since 2.4
Features added in 2.4 since 2.3
Features added in 2.3 since 2.2
Features added in 2.2 since 2.1

Originally based on:

  • Python Bestiary, author: Ken Manheimer
  • Python manuals, authors: Guido van Rossum and Fred Drake
  • python-mode.el, author: Tim Peters
  • and the readers of comp.lang.python

 

Useful links :

  • Python's nest: http://www.python.org
  • Official documentation: http://www.python.org/doc/   [Module index; Language Reference]
  • Other doc & free books: FAQs, Faqts, Dive into Python, Python Cookbook, Thinking in Python, Text processing in Python
  • Getting started: Official site, 7mn to Hello World (windows)
  • Topics: Databases, Web programming, XML, Web Services, Parsers, Scientific Computing, GUI programming, Distributing
  • Where to find packages: Easy Install, Python Package Index (PyPI), Vaults of Parnassus, SourceForge (search "python"), Python Eggs, O'Reilly Python DevCenter, Starship Python
  • Wiki: moinmoin
  • Newsgroups: comp.lang.python and comp.lang.python.announce
  • Misc pages: Daily Python URL, Kevin Altis' WebLog, PEAK
  • Python Development: http://www.python.org/dev/
  • Jython - Java implementation of Python: http://www.jython.org/
  • IronPython - Python on .Net: http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython
  • ActivePython: http://www.ActiveState.com/ASPN/Python/
  • Help desk: [email protected]
  • 2 excellent Python reference books: Python Essential Reference by David Beazley & Guido Van Rossum (Other New Riders) and Python in a nutshell by Alex martelli (O'Reilly).
  • Python 2.4 Reference Card (cheatsheet) by Laurent Pointal, designed for printing (15 pages).
  • Online Python 2.2 Quick Reference by the New Mexico Tech Computer Center.
Tip: From within the Python interpreter, type help, help(object) or help("name") to get help.

Invocation Options

python[ w] [-dEhi mOQStuUvVWxX?] [-c command | scriptFile | - ] [ args]
    (pythonw does not open a terminal/console; python does)
Invocation Options
Option Effect
-d Output parser debugging information (also PYTHONDEBUG=x)
-E Ignore environment variables (such as PYTHONPATH)
-h Print a help message and exit (formerly -?)
-i Inspect interactively after running script (also PYTHONINSPECT=x) and force prompts, even if stdin appears not to be a terminal.
-m module Search for module on sys.path and runs the module as a script. (Implementation improved in 2.5: module runpy)
-O Optimize generated bytecode (also PYTHONOPTIMIZE=x). Asserts are suppressed.
-OO Remove doc-strings in addition to the -O optimizations.
-Q arg Division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew
-S Don't perform import site on initialization.
-t Issue warnings about inconsistent tab usage (-tt: issue errors).
-u Unbuffered binary stdout and stderr (also PYTHONUNBUFFERED=x).
-U Force Python to interpret all string literals as Unicode literals.
-v Verbose (trace import statements) (also PYTHONVERBOSE=x).
-V Print the Python version number and exit.
-W arg Warning control (arg is action:message:category:module:lineno)
-x Skip first line of source, allowing use of non-unix Forms of #!cmd
-X Disable class based built-in exceptions (for backward compatibility management of exceptions)
-c command Specify the command to execute (see next section). This terminates the option list (following options are passed as arguments to the command).
scriptFile The name of a python file (.py) to execute. Read from stdin.
- Program read from stdin (default; interactive mode if a tty).
args Passed to script or command (in sys.argv[1:])
  If no scriptFile or command, Python enters interactive mode.
  • Available IDEs in std distrib: IDLE (tkinter based, portable), Pythonwin (on Windows). Other free IDEs: IPython (enhanced interactive Python shell), Eric, SPE, BOA constructor, PyDev (Eclipse plugin).
  • Typical python module header :
    #!/usr/bin/env python
    # -*- coding: latin1 -*-
    Since 2.3 the encoding of a Python source file must be declared as one of the two first lines (or defaults to 7 bits Ascii) [PEP-0263], with the format:
    # -*- coding: encoding -*-
    Std encodings are defined here, e.g. ISO-8859-1 (aka latin1), iso-8859-15 (latin9), UTF-8... Not all encodings supported, in particular UTF-16 is not supported.
  • It's now a syntax error if a module contains string literals with 8-bit characters but doesn't have an encoding declaration (was a warning before).
  • Since 2.5, from __future__ import feature statements must be declared at beginning of source file.
  • Site customization: File sitecustomize.py is automatically loaded by Python if it exists in the Python path (ideally located in ${PYTHONHOME}/lib/site-packages/).
  • Tip: when launching a Python script on Windows,
    /python myScript.py args ... can be reduced to :
    myScript.py args ... if is in the PATH envt variable, and further reduced to :
    myScript args ... provided that .py;.pyw;.pyc;.pyo is added to the PATHEXT envt variable.

Environment variables

Environment variables
Variable Effect
PYTHONHOME Alternate prefix directory (or prefix;exec_prefix). The default module search path uses prefix/lib
PYTHONPATH Augments the default search path for module files. The format is the same as the shell's $PATH: one or more directory pathnames separated by ':' or ';' without spaces around (semi-) colons !
On Windows Python first searches for Registry key HKEY_LOCAL_MACHINE/Software/Python/PythonCore/x.y/PythonPath (default value). You can create a key named after your application with a default string value giving the root directory path of your appl.

Alternatively, you can create a text file with a .pth extension, containing the path(s), one per line, and put the file somewhere in the Python search path (ideally in the site-packages/ directory). It's better to create a .pth for each application, to make easy to uninstall them.
PYTHONSTARTUP If this is the name of a readable file, the Python commands in that file are executed before the first prompt is displayed in interactive mode (no default).
PYTHONDEBUG If non-empty, same as -d option
PYTHONINSPECT If non-empty, same as -i option
PYTHONOPTIMIZE If non-empty, same as -O option
PYTHONUNBUFFERED If non-empty, same as -u option
PYTHONVERBOSE If non-empty, same as -v option
PYTHONCASEOK If non-empty, ignore case in file/module names (imports)

Notable lexical entities

Keywords 

        and       del       for       is        raise
        assert    elif      from      lambda    return
        break     else      global    not       try
        class     except    if        or        while
        continue  exec      import    pass      with
        def       finally   in        print     yield
  • (List of keywords available in std module: keyword)
  • Illegitimate Tokens (only valid in strings): $ ? (plus @ before 2.4)
  • A statement must all be on a single line. To break a statement over multiple lines, use "/", as with the C preprocessor.
    Exception: can always break when inside any (), [], or {} pair, or in triple-quoted strings.
  • More than one statement can appear on a line if they are separated with semicolons (";").
  • Comments start with "#" and continue to end of line.

Identifiers

( letter | "_") ( letter | digit | "_")*
  • Python identifiers keywords, attributes, etc. are case-sensitive.
  • Special forms: _ident (not imported by 'from module import *'); __ident__ (system defined name); __ident (class-private name mangling).

String literals

Two flavors: str (standard 8 bits locale-dependent strings, like ascii, iso 8859-1, utf-8, ...) and unicode (16 or 32 bits/char in utf-16 mode or 32 bits/char in utf-32 mode); one common ancestor basestring.

Literal
"a string enclosed by double quotes"
'another string delimited by single quotes and with a " inside'
'''a string containing embedded newlines and quote (') marks, can be delimited with triple quotes.'''
""" may also use 3- double quotes as delimiters """
u'a unicode string'
U"Another unicode string"
r'a raw string where / are kept (literalized): handy for regular expressions and windows paths!'
R"another raw string"   -- raw strings cannot end with a /
ur'a unicode raw string'
UR"another raw unicode"
  • Use / at end of line to continue a string on next line.
  • Adjacent strings are concatened, e.g. 'Monty ' 'Python' is the same as 'Monty Python'.
  • u'hello' + ' world'  --> u'hello world'   (coerced to unicode)

 

String Literal Escapes
Escape Meaning
/newline Ignored (escape newline)
// Backslash (/)
/e Escape (ESC)
/v Vertical Tab (VT)
/' Single quote (')
/f Formfeed (FF)
/ooo char with octal value ooo
/" Double quote (")
/n Linefeed (LF)
/a Bell (BEL)
/r Carriage Return (CR)
/xhh char with hex value hh
/b Backspace (BS)
/t Horizontal Tab (TAB)
/uxxxx Character with 16-bit hex value xxxx (unicode only)
/Uxxxxxxxx Character with 32-bit hex value xxxxxxxx (unicode only)
/N{name} Character named in the Unicode database (unicode only), e.g. u'/N{Greek Small Letter Pi}' <=> u'/u03c0'.
(Conversely, in module unicodedata, unicodedata.name(u'/u03c0') == 'GREEK SMALL LETTER PI')
/AnyOtherChar left as-is, including the backslash, e.g. str('/z') == '//z'
  • NUL byte (/000) is not an end-of-string marker; NULs may be embedded in strings.
  • Strings (and tuples) are immutable: they cannot be modified.

Boolean constants (since 2.2.1)

  • True
  • False

In 2.2.1, True and False are integers 1 and 0. Since 2.3, they are of new type bool.

Numbers

  • Decimal integer: 1234, 1234567890546378940L (or l)
  • Octal integer: 0177, 0177777777777777777L (begin with a 0)
  • Hex integer: 0xFF, 0XFFFFffffFFFFFFFFFFL (begin with 0x or 0X)
  • Long integer (unlimited precision): 1234567890123456L (ends with L or l) or long(1234)
  • Float (double precision): 3.14e-10, .001, 10., 1E3
  • Complex: 1J, 2+3J, 4+5j (ends with J or j, + separates (float) real and imaginary parts)

Integers and long integers are unified starting from release 2.2 (the L suffix is no longer required)

Sequences

  • Strings (types str and unicode) of length 0, 1, 2 (see above)
      '', '1', "12", 'hello/n'
  • Tuples (type tuple) of length 0, 1, 2, etc:
      () (1,) (1,2) # parentheses are optional if len > 0
  • Lists (type list) of length 0, 1, 2, etc:
      [] [1] [1,2]
  • Indexing is 0-based. Negative indices (usually) mean count backwards from end of sequence.
  • Sequence slicing [starting-at-index : but-less-than-index [ : step]]. Start defaults to 0, end to len(sequence), step to 1. 
      a = (0,1,2,3,4,5,6,7)
      a[3] == 3
      a[-1] == 7
      a[2:4] == (2, 3)
      a[1:] == (1, 2, 3, 4, 5, 6, 7)
      a[:3] == (0, 1, 2)
      a[:] == (0,1,2,3,4,5,6,7) # makes a copy of the sequence.
      a[::2] == (0, 2, 4, 6) # Only even numbers. 
      a[::-1] = (7, 6, 5, 4, 3 , 2, 1, 0) # Reverse order.

Dictionaries (Mappings)

Dictionaries (type dict) of length 0, 1, 2, etc: {} {1 : 'first'} {1 : 'first', 'two': 2, key: value}

Keys must be of a hashable type; Values can be any type.

Operators and their evaluation order

Operators and their evaluation order
Highest Operator Comment
  , [...] {...} `...` Tuple, list & dict. creation; string conv.
s[i] s[i:j] s.attr f(...) indexing & slicing; attributes, fct calls
+x, -x, ~x Unary operators
x**y Power
x*y x/y x%y mult, division, modulo
x+y x-y addition, substraction
x<>y Bit shifting
x&y Bitwise and
x^y Bitwise exclusive or
x|y Bitwise or
x<y  x<=y  x>y  x>=y  x==y x!=y  x<>y
x is y   x is not y
x in s   x not in s 		Comparison, 
identity, 
membership
not x boolean negation
x and y boolean and
x or y boolean or
Lowest lambda args: expr anonymous function
  • Alternate names are defined in module operator (e.g. __add__ and add for +)
  • Most operators are overridable

Basic types and their operations

Comparisons (defined between any types)

Comparisons
Comparison Meaning
Notes
< strictly less than
(1)
<= less than or equal to  
> strictly greater than  
>= greater than or equal to  
== equal to  
!= or <> not equal to  
is object identity
(2)
is not negated object identity
(2)

Notes:

  • Comparison behavior can be overridden for a given class by defining special method __cmp__.
  • (1) X < Y < Z < W has expected meaning, unlike C
  • (2) Compare object identities (i.e. id(object)), not object values.

None

  • None is used as default return value on functions. Built-in single object with type NoneType. Might become a keyword in the future.
  • Input that evaluates to None does not print when running Python interactively.
  • None is now a constant; trying to bind a value to the name "None" is now a syntax error.

Boolean operators

Boolean values and operators
Value or Operator Evaluates to
Notes
built-in bool(expr) True if expr is true, False otherwise.
see True, False
None, numeric zeros, empty sequences and mappings considered False  
all other values considered True  
not x True if x is False, else False  
x or y if x is False then y, else x
(1)
x and y if x is False then x, else y
(1)

Notes:

  • Truth testing behavior can be overridden for a given class by defining special method __nonzero__.
  • (1) Evaluate second arg only if necessary to determine outcome.

Numeric types

Floats, integers, long integers, Decimals.

  • Floats (type float) are implemented with C doubles.
  • Integers (type int) are implemented with C longs (signed 32 bits, maximum value is sys.maxint)
  • Long integers (type long) have unlimited size (only limit is system resources).
  • Integers and long integers are unified starting from release 2.2 (the L suffix is no longer required). int() returns a long integer instead of raising OverflowError. Overflowing operations such as 2<<32 no longer trigger FutureWarning and return a long integer.
  • Since 2.4, new type Decimal introduced (see module: decimal) to compensate for some limitations of the floating point type, in particular with fractions. Unlike floats, decimal numbers can be represented exactly; exactness is preserved in calculations; precision is user settable via the Context type [ PEP 327].

Operators on all numeric types

Operators on all numeric types
Operation Result
abs(x) the absolute value of x
int(x) x converted to integer
long(x) x converted to long integer
float(x) x converted to floating point
-x x negated
+x x unchanged
x + y the sum of x and y
x - y difference of x and y
x * y product of x and y
x / y true division of x by y: 1/2 -> 0.5 (1)
x // y floor division operator: 1//2 -> 0 (1)
x % y x modulo y
divmod(x, y) the tuple (x//y, x%y)
x ** y x to the power y (the same as pow(x,y))

Notes:

  • (1) / is still a floor division (1/2 == 0) unless validated by a from __future__ import division.
  • classes may override methods __truediv__ and __floordiv__ to redefine these operators.

Bit operators on integers and long integers

Bit operators
Operation Result
~x the bits of x inverted
x ^ y bitwise exclusive or of x and y
x & y bitwise and of x and y
x | y bitwise or of x and y
x << n x shifted left by n bits
x >> n x shifted right by n bits

Complex Numbers

  • Type complex, represented as a pair of machine-level double precision floating point numbers.
  • The real and imaginary value of a complex number z can be retrieved through the attributes z.real and z.imag.

Numeric exceptions

TypeError
raised on application of arithmetic operation to non-number
OverflowError
numeric bounds exceeded
ZeroDivisionError
raised when zero second argument of div or modulo op

Operations on all sequence types (lists, tuples, strings)

Operations on all sequence types
Operation Result
Notes
x in s True if an item of s is equal to x, else False
(3)
x not in s False if an item of s is equal to x, else True
(3)
s1 + s2 the concatenation of s1 and s2  
s * n, n*s n copies of s concatenated
 
s[i] i'th item of s, origin 0
(1)
s[i: j]
s[i: j:step]		 Slice of s from i (included) to j(excluded). Optional step value, possibly negative (default: 1).
(1), (2)
len(s) Length of s  
min(s) Smallest item of s
 
max(s) Largest item of s
 
reversed(s) [2.4] Returns an iterator on s in reverse order. s must be a sequence, not an iterator (use reversed(list(s)) in this case. [PEP 322]
 
sorted(iterable [, cmp]
  [, cmp=cmpFct]
  [, key=keyGetter]
  [, reverse=bool]) 		[2.4] works like the new in-place list.sort(), but sorts a new list created from the iterable.
 

Notes:

  • (1) if i or j is negative, the index is relative to the end of the string, ie len(s)+i or len(s)+j is substituted. But note that -0 is still 0.
  • (2) The slice of s from i to j is defined as the sequence of items with index k such that i<= k < j.
    If i or j is greater than len(s), use len(s). If j is omitted, use len(s). If i is greater than or equal to j, the slice is empty.
  • (3) For strings: before 2.3, x must be a single character string; Since 2.3, x in s is True if x is a substring of s.

Operations on mutable sequences (type list)

Operations on mutable sequences
Operation Result
Notes
s[i] =x item i of s is replaced by x  
s[i:j [:step]] = t slice of s from i to j is replaced by t  
del s[i:j[:step]] same as s[i:j] = []  
s.append(x) same as s[len(s) : len(s)] = [x]  
s.extend(x) same as s[len(s):len(s)]= x
(5)
s.count(x) returns number of i's for which s[i] == x  
s.index(x[, start[, stop]]) returns smallest i such that s[i]==x. start and stop limit search to only part of the list.
(1)
s.insert(i, x) same as s[i:i] = [x] if i>= 0. i == -1 inserts before the last element.  
s.remove(x) same as del s[s.index(x)]
(1)
s.pop([i]) same as x = s[i]; del s[i]; return x
(4)
s.reverse() reverses the items of s in place
(3)
s.sort([cmp ])
s.sort([cmp=cmpFct]
  [, key=keyGetter]
  [, reverse=bool]) 		sorts the items of s in place
(2), (3)

Notes:

  • (1) Raises a ValueError exception when x is not found in s (i.e. out of range).
  • (2) The sort() method takes an optional argument cmp specifying a comparison function takings 2 list items and returning -1, 0, or 1 depending on whether the 1st argument is considered smaller than, equal to, or larger than the 2nd argument. Note that this slows the sorting process down considerably. Since 2.4, the cmp argument may be specified as a keyword, and 2 optional keywords args are added: key is a fct that takes a list item and returns the key to use in the comparison (faster than cmp); reverse: If True, reverse the sense of the comparison used.
    Since Python 2.3, the sort is guaranteed "stable". This means that two entries with equal keys will be returned in the same order as they were input. For example, you can sort a list of people by name, and then sort the list by age, resulting in a list sorted by age where people with the same age are in name-sorted order.
  • (3) The sort() and reverse() methods modify the list in place for economy of space when sorting or reversing a large list. They don't return the sorted or reversed list to remind you of this side effect.
  • (4) The pop() method is not supported by mutable sequence types other than lists. The optional argument i defaults to -1, so that by default the last item is removed and returned.
  • (5) Raises a TypeError when x is not a list object.

Operations on mappings / dictionaries (type dict)

Operations on mappings
Operation Result
Notes
len(d) The number of items in d  
dict()
dict(**kwargs)
dict(iterable)
dict(d)
 Creates an empty dictionary.
Creates a dictionary init with the keyword args kwargs.
Creates a dictionary init with (key, value) pairs provided by iterable.
Creates a dictionary which is a copy of dictionary d. 		 
d.fromkeys(iterable, value=None) Class method to create a dictionary with keys provided by iterator, and all values set to value.  
d[k] The item of d with key k
(1)
d[k] = x Set d[k] to x  
del d[k] Removes d[k] from d
(1)
d.clear() Removes all items from d  
d.copy() A shallow copy of d  
d.has_key(k)
k in d 		True if d has key k, else False  
d.items() A copy of d's list of (key, item) pairs
(2)
d.keys() A copy of d's list of keys
(2)
d1.update(d2) for k, v in d2.items(): d1[k] = v
Since 2.4, update(**kwargs) and update(iterable) may also be used.
d.values() A copy of d's list of values
(2)
d.get(k, defaultval) The item of d with key k
(3)
d.setdefault(k[,defaultval]) d[k] if k in d, else defaultval(also setting it)
(4)
d.iteritems() Returns an iterator over (key, value) pairs.  
d.iterkeys() Returns an iterator over the mapping's keys.  
d.itervalues() Returns an iterator over the mapping's values.  
d.pop(k[, default]) Removes key k and returns the corresponding value. If key is not found, default is returned if given, otherwise KeyError is raised.  
d.popitem() Removes and returns an arbitrary (key, value) pair from d
 

Notes:

  • TypeError is raised if key is not acceptable.
  • (1) KeyError is raised if key k is not in the map.
  • (2) Keys and values are listed in random order.
  • (3) Never raises an exception if k is not in the map, instead it returns defaultval. defaultval is optional, when not provided and k is not in the map, None is returned.
  • (4) Never raises an exception if k is not in the map, instead returns defaultVal, and adds k to map with value defaultVal. defaultVal is optional. When not provided and k is not in the map, None is returned and added to map.

Operations on strings (types str & unicode)

These string methods largely (but not completely) supersede the functions available in the string module.
The str and unicode types share a common base class basestring.
Operations on strings
Operation Result
Notes
s.capitalize() Returns a copy of s with its first character capitalized, and the rest of the characters lowercased.  
s.center(width[, fillChar=' ']) Returns a copy of s centered in a string of length width, surrounded by the appropriate number of fillChar characters.
(1)
s.count(sub[, start[, end]]) Returns the number of occurrences of substring sub in string s.
(2)
s.decode([encoding[, errors]]) Returns a unicode string representing the decoded version of str s, using the given codec (encoding). Useful when reading from a file or a I/O function that handles only str. Inverse of encode.
(3)
s.encode([encoding[, errors]]) Returns a str representing an encoded version of s. Mostly used to encode a unicode string to a str in order to print it or write it to a file (since these I/O functions only accept str), e.g. u'légère'.encode('utf8'). Also used to encode a str to a str, e.g. to zip (codec 'zip') or uuencode (codec 'uu') it. Inverse of decode.
(3)
s.endswith(suffix [, start[, end]]) Returns True if s ends with the specified suffix, otherwise return false. Since 2.5 suffix can also be a tuple of strings to try.
(2)
s.expandtabs([tabsize]) Returns a copy of s where all tab characters are expanded using spaces.
(4)
s.find(sub [,start[,end]]) Returns the lowest index in s where substring sub is found. Returns -1 if sub is not found.
(2)
s.index(sub[, start[, end]]) like find(), but raises ValueError when the substring is not found.
(2)
s.isalnum() Returns True if all characters in s are alphanumeric, False otherwise.
(5)
s.isalpha() Returns True if all characters in s are alphabetic, False otherwise.
(5)
s.isdigit() Returns True if all characters in s are digit characters, False otherwise.
(5)
s.islower() Returns True if all characters in s are lowercase, False otherwise.
(6)
s.isspace() Returns True if all characters in s are whitespace characters, False otherwise.
(5)
s.istitle() Returns True if string s is a titlecased string, False otherwise.
(7)
s.isupper() Returns True if all characters in s are uppercase, False otherwise.
(6)
separator.join(seq) Returns a concatenation of the strings in the sequence seq, separated by string separator, e.g.: ",".join(['A', 'B', 'C']) -> "A,B,C"
 
s.ljust/rjust/center(width[, fillChar=' ']) Returns s left/right justified/centered in a string of length width.
(1), (8)
s.lower() Returns a copy of s converted to lowercase.
 
s.lstrip([chars] ) Returns a copy of s with leading chars (default: blank chars) removed.
 
s.partition(separ) Searches for the separator separ in s, and returns a tuple (head, sep, tail) containing the part before it, the separator itself, and the part after it. If the separator is not found, returns (s, '', '').
 
s.replace(old, new[, maxCount =-1]) Returns a copy of s with the first maxCount (-1: unlimited) occurrences of substring old replaced by new.
(9)
s.rfind(sub[ , start[, end]]) Returns the highest index in s where substring sub is found. Returns -1 if sub is not found.
(2)
s.rindex(sub[ , start[, end]]) like rfind(), but raises ValueError when the substring is not found.
(2)
s.rpartition(separ) Searches for the separator separ in s, starting at the end of s, and returns a tuple (head, sep, tail) containing the (left) part before it, the separator itself, and the (right) part after it. If the separator is not found, returns ('', '', s).
 
s.rstrip([chars]) Returns a copy of s with trailing chars(default: blank chars) removed, e.g. aPath.rstrip('/') will remove the trailing '/'from aPath if it exists
 
s.split([ separator[, maxsplit]]) Returns a list of the words in s, using separator as the delimiter string.
(10)
s.rsplit([ separator[, maxsplit]]) Same as split, but splits from the end of the string.
(10)
s.splitlines([ keepends]) Returns a list of the lines in s, breaking at line boundaries.
(11)
s.startswith(prefix [, start[, end]]) Returns True if s starts with the specified prefix, otherwise returns False. Negative numbers may be used for start and end. Since 2.5 prefix can also be a tuple of strings to try.
(2)
s.strip([chars]) Returns a copy of s with leading and trailing chars(default: blank chars) removed.
 
s.swapcase() Returns a copy of s with uppercase characters converted to lowercase and vice versa.
 
s.title() Returns a titlecased copy of s, i.e. words start with uppercase characters, all remaining cased characters are lowercase.
 
s.translate(table [, deletechars]) Returns a copy of s mapped through translation table table.
(12)
s.upper() Returns a copy of s converted to uppercase.
 
s.zfill(width) Returns the numeric string left filled with zeros in a string of length width.  

Notes:

  • (1) Padding is done using spaces or the given character.
  • (2) If optional argument start is supplied, substring s[start:] is processed. If optional arguments start and end are supplied, substring s[start:end] is processed.
  • (3) Default encoding is sys.getdefaultencoding(), can be changed via sys.setdefaultencoding(). Optional argument errors may be given to set a different error handling scheme. The default for errors is 'strict', meaning that encoding errors raise a ValueError. Other possible values are 'ignore' and 'replace'. See also module codecs.
  • (4) If optional argument tabsize is not given, a tab size of 8 characters is assumed.
  • (5) Returns False if string s does not contain at least one character.
  • (6) Returns False if string s does not contain at least one cased character.
  • (7) A titlecased string is a string in which uppercase characters may only follow uncased characters and lowercase characters only cased ones.
  • (8) s is returned if width is less than len(s).
  • (9) If the optional argument maxCount is given, only the first maxCount occurrences are replaced.
  • (10) If separator is not specified or None, any whitespace string is a separator. If maxsplit is given, at most maxsplit splits are done.
  • (11) Line breaks are not included in the resulting list unless keepends is given and true.
  • (12) table must be a string of length 256. All characters occurring in the optional argument deletechars are removed prior to translation.

String formatting with the % operator

formatString % args --> evaluates to a string
  • formatString mixes normal text with C printf format fields :
    %[ flag][ width][. precision] formatCode
    where formatCode is one of c, s, i, d, u, o, x, X, e, E, f, g, G, r, % (see table below).
  • The flag characters -, +, blank, # and 0 are understood (see table below).
  • Width and precision may be a * to specify that an integer argument gives the actual width or precision. Examples of width and precision :
    Examples
    Format string Result
    '%3d' % 2 ' 2'
    '%*d' % (3, 2) ' 2'
    '%-3d' % 2 '2 '
    '%03d' % 2 '002'
    '% d' % 2 ' 2'
    '%+d' % 2 '+2'
    '%+3d' % -2 ' -2'
    '%- 5d' % 2 ' 2 '
    '%.4f' % 2 '2.0000'
    '%.*f' % (4, 2) '2.0000'
    '%0*.*f' % (10, 4, 2) '00002.0000'
    '%10.4f' % 2 ' 2.0000'
    '%010.4f' % 2 '00002.0000'
  • %s will convert any type argument to string (uses str() function)
  • args may be a single arg or a tuple of args 
    '%s has %03d quote types.' % ('Python', 2)  == 'Python has 002 quote types.'
  • Right-hand-side can also be a mapping: 
    a = '%(lang)s has %(c)03d quote types.' % {'c':2, 'lang':'Python'}
    (vars() function very handy to use on right-hand-side)

 

Format codes
Code Meaning
d Signed integer decimal.
i Signed integer decimal.
o Unsigned octal.
u Unsigned decimal.
x Unsigned hexadecimal (lowercase).
X Unsigned hexadecimal (uppercase).
e Floating point exponential format (lowercase).
E Floating point exponential format (uppercase).
f Floating point decimal format.
F Floating point decimal format.
g Same as "e" if exponent is greater than -4 or less than precision, "f" otherwise.
G Same as "E" if exponent is greater than -4 or less than precision, "F" otherwise.
c Single character (accepts integer or single character string).
r String (converts any python object using repr()).
s String (converts any python object using str()).
% No argument is converted, results in a "%" character in the result. (The complete specification is %%.)
Conversion flag characters
Flag Meaning
# The value conversion will use the "alternate form".
0 The conversion will be zero padded.
- The converted value is left adjusted (overrides "-").
  (a space) A blank should be left before a positive number (or empty string) produced by a signed conversion.
+ A sign character ("+" or "-") will precede the conversion (overrides a "space" flag).

String templating

Since 2.4 [PEP 292] the string module provides a new mechanism to substitute variables into template strings.
Variables to be substituted begin with a $. Actual values are provided in a dictionary via the substitute or safe_substitute methods ( substitute throws KeyError if a key is missing while safe_substitute ignores it) :

  t = string.Template('Hello $name, you won $$$amount') # (note $$ to literalize $)
  t.substitute({'name': 'Eric', 'amount': 100000}) # -> u'Hello Eric, you won $100000'

File objects

(Type file). Created with built-in functions open() [preferred] or its alias file(). May be created by other modules' functions as well.
Unicode file names are now supported for all functions accepting or returning file names (open, os.listdir, etc...).

Operators on file objects

File operations
Operation Result
f.close() Close file f.
f.fileno() Get fileno (fd) for file f.
f.flush() Flush file f's internal buffer.
f.isatty() 1 if file f is connected to a tty-like dev, else 0.
f.next() Returns the next input line of file f, or raises StopIteration when EOF is hit. Files are their own iterators. next is implicitly called by constructs like for line in f: print line.
f.read([size]) Read at most size bytes from file f and return as a string object. If size omitted, read to EOF.
f.readline() Read one entire line from file f. The returned line has a trailing /n, except possibly at EOF. Return '' on EOF.
f.readlines() Read until EOF with readline() and return a list of lines read.
f.xreadlines() Return a sequence-like object for reading a file line-by-line without reading the entire file into memory. From 2.2, use rather: for line in f (see below).
for line in f: do something... Iterate over the lines of a file (using readline)
f.seek(offset[, whence=0]) Set file f's position, like "stdio's fseek()".
whence == 0 then use absolute indexing.
whence == 1 then offset relative to current pos.
whence == 2 then offset relative to file end.
f.tell() Return file f's current position (byte offset).
f.truncate([size]) Truncate f's size. If size is present, f is truncated to (at most) that size, otherwise f is truncated at current position (which remains unchanged).
f.write(str) Write string to file f.
f.writelines(list) Write list of strings to file f. No EOL are added.

File Exceptions

EOFError
End-of-file hit when reading (may be raised many times, e.g. if f is a tty).
IOError
Other I/O-related I/O operation failure

Sets

Since 2.4, Python has 2 new built-in types with fast C implementations [PEP 218]: set and frozenset (immutable set). Sets are unordered collections of unique (non duplicate) elements. Elements must be hashable. frozensets are hashable (thus can be elements of other sets) while sets are not. All sets are iterable.

 

Since 2.3, the classes Set and ImmutableSet were available in the module sets. This module remains in the 2.4 std library in addition to the built-in types.
Main Set operations
Operation Result
set/frozenset([iterable=None]) [using built-in types] Builds a set or frozenset from the given iterable (default: empty), e.g. set([1,2,3]), set("hello").
Set/ImmutableSet([iterable=None]) [using the sets module] Builds a Set or ImmutableSet from the given iterable (default: empty), e.g. Set([1,2,3]).
len(s) Cardinality of set s.
elt in s / not in s True if element elt belongs / does not belong to set s.
for elt in s: process elt... Iterates on elements of set s.
s1.issubset(s2) True if every element in s1 is in s2.
s1.issuperset(s2) True if every element in s2 is in s1.
s.add(elt) Adds element elt to set s (if it doesn't already exist).
s.remove(elt) Removes element elt from set s. KeyError if element not found.
s.discard(elt) Removes element elt from set s if present.
s.pop() Removes and returns an arbitrary element from set s; raises KeyError if empty.
s.clear() Removes all elements from this set (not on immutable sets!).
s1.intersection(s2) or s1&s2 Returns a new Set with elements common to s1 and s2.
s1.union(s2) or s1|s2 Returns a new Set with elements from both s1 and s2.
s1.difference(s2) or s1-s2 Returns a new Set with elements in s1 but not in s2.
s1.symmetric_difference(s2) or s1^s2 Returns a new Set with elements in either s1 or s2 but not both.
s.copy() Returns a shallow copy of set s.
s.update(iterable) Adds all values from iterable to set s.

Date/Time

Python has no intrinsic Date and Time types, but provides 2 built-in modules:

  • time: time access and conversions
  • datetime: classes date, time, datetime, timedelta, tzinfo.


...see also the third-party module: mxDateTime.

Advanced Types

- See manuals for more details -

  • Module objects
  • Class objects
  • Class instance objects
  • Type objects (see module: types)
  • File objects (see above)
  • Slice objects
  • Ellipsis object, used by extended slice notation (unique, named Ellipsis)
  • Null object (unique, named None)
  • XRange objects
  • Callable types:
    • User-defined (written in Python):
      • User-defined Function objects
      • User-defined Method objects
    • Built-in (written in C):
      • Built-in Function objects
      • Built-in Method object
  • Internal Types:
    • Code objects (byte-compile executable Python code: bytecode)
    • Frame objects (execution frames)
    • Traceback objects (stack trace of an exception)

Statements

 

Statement Result
pass Null statement
del name[, name]* Unbind name(s) from object. Object will be indirectly (and automatically) deleted only if no longer referenced.
print[>> fileobject,] [s1 [, s2 ]* [,] Writes to sys.stdout, or to fileobject if supplied. Puts spaces between arguments. Puts newline at end unless statement ends with comma [if nothing is printed when using a comma, try calling system.out.flush()]. Print is not required when running interactively, simply typing an expression will print its value, unless the value is None.
exec x [in globals [, locals]] Executes x in namespaces provided. Defaults to current namespaces. x can be a string, open file-like object or a function object. locals can be any mapping type, not only a regular Python dict. See also built-in function execfile.
callable(value,... [id=value] , [*args], [**kw]) Call function callable with parameters. Parameters can be passed by name or be omitted if function defines default values. E.g. if callable is defined as "def callable(p1=1, p2=2)"
" callable()" <=> " callable(1, 2)"
" callable(10)" <=> " callable(10, 2)"
" callable(p2=99)" <=> " callable(1, 99)"
*args is a tuple of positional arguments.
**kw is a dictionary of keyword arguments.

Assignment operators

Assignment operators
Operator Result
Notes
a = b Basic assignment - assign object b to label a
(1)(2)
a += b Roughly equivalent to a = a + b
(3)
a -= b Roughly equivalent to a = a - b
(3)
a *= b Roughly equivalent to a = a * b
(3)
a /= b Roughly equivalent to a = a / b
(3)
a //= b Roughly equivalent to a = a // b
(3)
a %= b Roughly equivalent to a = a % b
(3)
a **= b Roughly equivalent to a = a ** b
(3)
a &= b Roughly equivalent to a = a & b
(3)
a |= b Roughly equivalent to a = a | b
(3)
a ^= b Roughly equivalent to a = a ^ b
(3)
a >>= b Roughly equivalent to a = a >> b
(3)
a <<= b Roughly equivalent to a = a << b
(3)

Notes:

  • (1) Can unpack tuples, lists, and strings:
    first, second = l[0:2]    # equivalent to: first=l[0]; second=l[1]
    [f, s] = range(2)    # equivalent to: f=0; s=1
    c1,c2,c3 = 'abc'    # equivalent to: c1='a'; c2='b'; c3='c'
    (a, b), c, (d, e, f) = ['ab', 'c', 'def']    # equivalent to: a='a'; b='b'; c='c'; d='d'; e='e'; f='f'
    Tip: x,y = y,x swaps x and y.
  • (2) Multiple assignment possible:
    a = b = c = 0
    list1 = list2 = [1, 2, 3]    # list1 and list2 points to the same list (l1 is l2)
  • (3) Not exactly equivalent - a is evaluated only once. Also, where possible, operation performed in-place - a is modified rather than replaced.

 

Conditional Expressions

Conditional Expressions (not statements) have been added since 2.5 [ PEP 308]:
result = (whenTrue if condition else whenFalse)
is equivalent to:
if condition:
    result = whenTrue
else:
    result = whenFalse
() are not mandatory but recommended.

Control Flow statements

Control flow statements
Statement Result
if condition:
  suite
[elif condition:   suite]*
[else:
  suite] 		Usual if/else if/else statement. See also Conditional Expressions.
while condition:
  suite
[else:
  suite] 		Usual while statement. The else suite is executed after loop exits, unless the loop is exited with break.
for element in sequence:
  suite
[else:
  suite] 		Iterates over sequence, assigning each element to element. Use built-in range function to iterate a number of times. The else suite is executed at end unless loop exited with break.
break Immediately exits for or while loop.
continue Immediately does next iteration of for or while loop.
return [result] Exits from function (or method) and returns result (use a tuple to return more than one value). If no result given, then returns None.
yield expression (Only used within the body of a generator function, outside a try of a try..finally). "Returns" the evaluated expression.

Exception statements

Exception statements
Statement Result
assert expr[, message] expr is evaluated. if false, raises exception AssertionError with message. Before 2.3, inhibited if __debug__ is 0.
try:
  block1
[except [exception [, value]]:
  handler]+
[else:
  else-block] 		Statements in block1 are executed. If an exception occurs, look in except clause(s) for matching exception(s). If matches or bare except, execute handler of that clause. If no exception happens, else-block in else clause is executed after block1. If exception has a value, it is put in variable value. exception can also be a tuple of exceptions, e.g. except(KeyError, NameError), e: print e.
try:
  block1
finally:
  final-block 		Statements in block1 are executed. If no exception, execute final-block (even if block1 is exited with a return, break or continue statement). If exception did occur, execute final-block and then immediately re-raise exception. Typically used to ensure that a resource (file, lock...) allocated before the try is freed (in the final-block) whatever the outcome of block1 execution. See also the with statement below.
try:
  block1
[except [exception [, value]]:
  handler1]+
[else:
  else-block]
finally:
  final-block 		Unified try/except/finally. Equivalent to a try...except nested inside a try..finally [PEP341]. See also the with statement below.
with allocate-expression [as variable]
  with-block
 Alternative to the try...finally structure [PEP343].
allocate-expression should evaluate to an object that supports the context management protocol, representing a resource. This object may return a value that can optionally be bound to variable (variable is not assigned the result of expression).
The object can then run set-up code before with-block is executed and some clean-up code is executed after the block is done, even if the block raised an exception.
Standard Python objects such as files and locks support the context management protocol:
with open('/etc/passwd', 'r') as f: # file automatically closed on block exit
  for line in f:
    print line

with threading.Lock(): # lock automatically released on block exit
  do something...
- You can write your own context managers.
- Helper functions are available in module contextlib.
In 2.5 the statement must be enabled by: from __future__ import with_statement. The statement will always be enabled in Python 2.6.
raise exceptionInstance Raises an instance of a class derived from Exception (preferred form of raise).
raise exceptionClass [, value [, traceback]] Raises exception of given class exceptionClass with optional value value. Arg traceback specifies a traceback object to use when printing the exception's backtrace.
raise A raise statement without arguments re-raises the last exception raised in the current function.
  • An exception is an instance of an exception class (before 2.0, it may also be a mere string).
  • Exception classes must be derived from the predefined class: Exception, e.g.: 
    class TextException(Exception): pass
    try:
        if bad:
            raise TextException()
    except Exception:
        print 'Oops'  # This will be printed because TextException is a subclass of Exception
  • When an error message is printed for an unhandled exception, the class name is printed, then a colon and a space, and finally the instance converted to a string using the built-in function str().
  • All built-in exception classes derives from StandardError, itself derived from Exception.
  • [PEP 352]: Exceptions can now be new-style classes, and all built-in ones are. Built-in exception hierarchy slightly reorganized with the introduction of base class BaseException. Raising strings as exceptions is now deprecated (warning).

Name Space Statements

Imported module files must be located in a directory listed in the Python path (sys.path). Since 2.3, they may reside in a zip file [e.g. sys.path.insert(0, "aZipFile.zip")].

 

Absolute/relative imports (since 2.5 [ PEP328]):
  • Feature must be enabled by: from __future__ import absolute_import: will probably be adopted in 2.7.
  • Imports are normally relative: modules are searched first in the current directory/package, and then in the builtin modules, resulting in possible ambiguities (e.g. masking a builtin symbol).
  • When the new feature is enabled:
    • import X will look up for module X in sys.path first (absolute import).
    • import .X (with a dot) will still search for X in the current package first, then in builtins (relative import).
    • import ..X will search for X in the package containing the current one, etc...

Packages (>1.5): a package is a name space which maps to a directory including module(s) and the special initialization module __init__.py (possibly empty).
Packages/directories can be nested. You address a module's symbol via [package.[package...].module.symbol.
[1.51: On Mac & Windows, the case of module file names must now match the case as used in the import statement]

Name space statements
Statement Result
import module1 [as name1] [, module2]* Imports modules. Members of module must be referred to by qualifying with [package.]module name, e.g.: 
import sys; print sys.argv
import package1.subpackage.module
package1.subpackage.module.foo()
module1 renamed as name1, if supplied.
from module import name1 [as othername1][, name2]* Imports names from module module in current namespace. 
from sys import argv; print argv
from package1 import module; module.foo()
from package1.module import foo; foo()
name1 renamed as othername1, if supplied.
[2.4] You can now put parentheses around the list of names in a from module import names statement ( PEP 328).
from module import * Imports all names in module, except those starting with "_". Use sparsely, beware of name clashes! 
from sys import *; print argv
from package.module import *; print x
Only legal at the top level of a module.
If module defines an __all__ attribute, only names listed in __all__ will be imported.
NB: "from package import *" only imports the symbols defined in the package's __init__.py file, not those in the package's modules !
global name1 [, name2] Names are from global scope (usually meaning from module) rather than local (usually meaning only in function).
E.g. in function without global statements, assuming "x" is name that hasn't been used in function or module so far:
- Try to read from "x" -> NameError
- Try to write to "x" -> creates "x" local to function
If "x" not defined in fct, but is in module, then: - Try to read from "x", gets value from module
- Try to write to "x", creates "x" local to fct
But note "x[0]=3" starts with search for "x", will use to global "x" if no local "x".

Function Definition 

def funcName ([paramList]):
    suite
Creates a function object and binds it to name funcName. 
paramList ::= [param [, param]*]
param ::= value | id=value | *id | **id
  • Args are passed by value, so only args representing a mutable object can be modified (are inout parameters).
  • Use return to return (None) from the function, or return value to return value. Use a tuple to return more than one value, e.g. return 1,2,3
  • Keyword arguments arg=value specify a default value (evaluated at function def. time). They can only appear last in the param list, e.g. foo(x, y=1, s='')
  • Pseudo-arg *args captures a tuple of all remaining non-keyword args passed to the function, e.g. if def foo(x, *args): ... is called foo(1, 2, 3), then args will contain (2,3).
  • Pseudo-arg **kwargs captures a dictionary of all extra keyword arguments, e.g. if def foo(x, **kwargs): ... is called foo(1, y=2, z=3), then kwargs will contain {'y':2, 'z':3}. if def foo(x, *args, **kwargs): ... is called foo(1, 2, 3, y=4, z=5), then args will contain (2, 3), and kwargs will contain {'y':4, 'z':5}
  • args and kwargs are conventional names, but other names may be used as well.
  • *args and **kwargs can be "forwarded" (individually or together) to another function, e.g.
    def f1(x, *args, **kwargs):
      f2(*args, **kwargs)
  • See also Anonymous functions (lambdas).

Class Definition

class className [(super_class1[, super_class2]*)]:
  suite

Creates a class object and assigns it name className.
suite may contain local "defs" of class methods and assignments to class attributes.


Examples:

class MyClass (class1, class2): ...
  Creates a class object inheriting from both class1 and class2. Assigns new class object to name MyClass.

class MyClass: ...
  Creates a base class object (inheriting from nothing). Assigns new class object to name MyClass. Since 2.5 the equivalent syntax class MyClass(): ... is allowed.

class MyClass (object): ...
  Creates a new-style class (inheriting from object makes a class a new-style class -available since Python 2.2-). Assigns new class object to name MyClass.

  • First arg to class instance methods (operations) is always the target instance object, called 'self' by convention.
  • Special static method __new__(cls[,...]) called when instance is created. 1st arg is a class, others are args to __init__(), more details here
  • Special method __init__() is called when instance is created.
  • Special method __del__() called when no more reference to object.
  • Create instance by "calling" class object, possibly with arg (thus instance=apply(aClassObject, args...) creates an instance!)
  • Before 2.2 it was not possible to subclass built-in classes like list, dict (you had to "wrap" them, using UserDict & UserList modules); since 2.2 you can subclass them directly (see Types/Classes unification).


Example: 

class c (c_parent):
    def __init__(self, name): 
        self.name = name
    def print_name(self): 
        print "I'm", self.name
    def call_parent(self): 
        c_parent.print_name(self)
        
instance = c('tom')
print instance.name
'tom'
instance.print_name()
"I'm tom"


Call parent's super class by accessing parent's method directly and passing self explicitly (see call_parent in example above).
Many other special methods available for implementing arithmetic operators, sequence, mapping indexing, etc...

Types / classes unification

Base types int, float, str, list, tuple, dict and file now (2.2) behave like classes derived from base class object, and may be subclassed:

x = int(2) # built-in cast function now a constructor for base type
y = 3  # <=> int(3) (litterals are instances of new base types)
print type(x), type(y) # int, int

assert isinstance(x, int) # replaces isinstance(x, types.IntType)

assert issubclass(int, object) # base types derive from base class 'object'.
s = "hello" # <=> str("hello")
assert isinstance(s, str)

f = 2.3  # <=> float(2.3)
class MyInt(int): pass    # may subclass base types
x,y = MyInt(1), MyInt("2")

print x, y, x+y # => 1,2,3

class MyList(list): pass

l = MyList("hello")

print l # ['h', 'e', 'l', 'l', 'o']

New-style classes extends object. Old-style classes don't.

Documentation Strings

Modules, classes and functions may be documented by placing a string literal by itself as the first statement in the suite. The documentation can be retrieved by getting the '__doc__' attribute from the module, class or function.

Example: 

class C:
    "A description of C"
        def __init__(self):
            "A description of the constructor"
            # etc.
            
c.__doc__ == "A description of C".
c.__init__.__doc__ == "A description of the constructor"

Iterators

  • An iterator enumerates elements of a collection. It is an object with a single method next() returning the next element or raising StopIteration.
  • You get an iterator on obj via the new built-in function iter(obj), which calls obj.__class__.__iter__().
  • A collection may be its own iterator by implementing both __iter__() and next().
  • Built-in collections (lists, tuples, strings, dict) implement __iter__(); dictionaries (maps) enumerate their keys; files enumerates their lines.
  • You can build a list or a tuple from an iterator, e.g. list(anIterator)
  • Python implicitly uses iterators wherever it has to loop :
    • for elt in collection:
    • if elt in collection:
    • when assigning tuples: x,y,z= collection

Generators

  • A generator is a function that retains its state between 2 calls and produces a new value at each invocation. The values are returned (one at a time) using the keyword yield, while return or raise StopIteration() are used to notify the end of values.
  • A typical use is the production of IDs, names, or serial numbers. Fancier applications like nanothreads are also possible.
  • In 2.2, the feature needs to be enabled by the statement: from __future__ import generators (not required since 2.3+)
  • To use a generator: call the generator function to get a generator object, then call generator.next() to get the next value until StopIteration is raised.
  • 2.4 introduces generator expressions [PEP 289] similar to list comprehensions, except that they create a generator that will return elements one by one, which is suitable for long sequences :
      linkGenerator = (link for link in get_all_links() if not link.followed)
      for link in linkGenerator:
        ...process link...
    Generator expressions must appear between parentheses.
  • [PEP342] Generators before 2.5 could only produce output. Now values can be passed to generators via their method send(value). yield is now an expression returning a value, so val = (yield i) will yield i to the caller, and will reciprocally evaluate to the value "sent" back by the caller, or None.
    Two other new generator methods allow for additional control:
    • throw(type, value=None, traceback=None) is used to raise an exception inside the generator (appears as raised by the yield expression).
    • close() raises a new GeneratorExit exception inside the generator to terminate the iteration.


Example: 

def genID(initialValue=0):
  v = initialValue
  while v < initialValue + 1000:
    yield "ID_%05d" % v
    v += 1
  return    # or: raise StopIteration()

generator = genID() # Create a generator
for i in range(10): # Generates 10 values
  print generator.next()

Descriptors / Attribute access

  • Descriptors are objects implementing at least the first of these 3 methods representing the descriptor protocol:
    • __get__(self, obj, type=None) --> value
    • __set__(self, obj, value)
    • __delete__(self, obj)
    Python now transparently uses descriptors to describe and access the attributes and methods of new-style classes (i.e. derived from object). [more info])
  • Built-in descriptors now allow to define:
    • Static methods : Use staticmethod(f) to make method f(x) static (unbound).
    • Class methods: like a static but takes the Class as 1st argument => Use f = classmethod(f) to make method f(theClass, x) a class method.
    • Properties : A property is an instance of the new built-in type property, which implements the descriptor protocol for attributes => Use propertyName = property(fget=None, fset=None, fdel=None, doc=None) to define a property inside or outside a class. Then access it as propertyName or obj.propertyName
    • Slots. New style classes can define a class attribute __slots__ to constrain the list of assignable attribute names, to avoid typos (which is normally not detected by Python and leads to the creation of new attributes), e.g. __slots__ = ('x', 'y')
      Note: According to recent discussions, the real purpose of slots seems still unclear (optimization?), and their use should probably be discouraged.

Decorators for functions & methods

  • [PEP 318] A decorator D is noted @D on the line preceding the function/method it decorates :
        @D
        def f(): ...
    and is equivalent to:
        def f(): ...
        f = D(f)
  • Several decorators can be applied in cascade :
        @A
        @B
        @C
        def f(): ...
    is equivalent to:
        f = A(B(C(f)))
  • A decorator is just a function taking the fct to be decorated and returns the same function or some new callable thing.
  • Decorator functions can take arguments:
        @A
        @B
        @C(args)
    becomes :
        def f(): ...
        _deco = C(args)
        f = A(B(_deco(f)))
  • The decorators @staticmethod and @classmethod replace more elegantly the equivalent declarations f = staticmethod(f) and f = classmethod(f).

Misc

lambda [param_list]: returnedExpr
Creates an anonymous function.
returnedExpr must be an expression, not a statement (e.g., not "if xx:...", "print xxx", etc.) and thus can't contain newlines. Used mostly for filter(), map(), reduce() functions, and GUI callbacks.


List comprehensions 
result = [expression for item1 in sequence1  [if condition1]
             [for item2 in sequence2 ... for itemN in sequenceN]
         ]
is equivalent to: 
result = []
for item1 in sequence1:
    for item2 in sequence2:
        ...
        for itemN in sequenceN:
            if (condition1) and further conditions:
               result.append(expression)

 

Nested scopes
Since 2.2 nested scopes no longer need to be specially enabled by a from __future__ import nested_scopes directive, and are always used.

Built-In Functions

Built-in functions are defined in a module _builtin__ automatically imported.

Built-In Functions
Function Result
__import__(name[, globals[,locals[,from list]]]) Imports module within the given context (see library reference for more details)
abs(x) Returns the absolute value of the number x.
all(iterable) Returns True if bool(x) is True for all values x in the iterable.
any(iterable) Returns True if bool(x) is True for any value x in the iterable.
apply(f, args[, keywords]) Calls func/method f with arguments args and optional keywords. deprecated since 2.3, replace apply(func, args, keywords) with func(*args, **keywords) [details]
basestring() Abstract superclass of str and unicode; can't be called or instantiated directly, but useful in: isinstance(obj, basestring).
bool([x]) Converts a value to a Boolean, using the standard truth testing procedure. If x is false or omitted, returns False; otherwise returns True. bool is also a class/type, subclass of int. Class bool cannot be subclassed further. Its only instances are False and True. See also boolean operators
buffer(object[, offset[, size]]) Returns a Buffer from a slice of object, which must support the buffer call interface (string, array, buffer). Non essential function, see [details]
callable(x) Returns True if x callable, else False.
chr(i) Returns one-character string whose ASCII code is integer i.
classmethod(function) Returns a class method for function. A class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom:

  class C:
    def f(cls, arg1, arg2, ...): ...
    f = classmethod(f)

Then call it on the class C.f() or on an instance C().f(). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.
Since 2.4 you can alternatively use the decorator notation:
  class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...
cmp(x,y) Returns negative, 0, positive if x <, ==, > to y respectively.
coerce(x,y) Returns a tuple of the two numeric arguments converted to a common type. Non essential function, see [details]
compile(string, filename, kind[, flags[, dont_inherit]]) Compiles string into a code object. filename is used in error message, can be any string. It is usually the file from which the code was read, or e.g. '' if not read from file. kind can be 'eval' if string is a single stmt, or 'single' which prints the output of expression statements that evaluate to something else than None, or be 'exec'. New args flags and dont_inherit concern future statements.
complex(real[, image]) Creates a complex object (can also be done using J or j suffix, e.g. 1+3J).
delattr(obj, name) Deletes the attribute named name of object obj <=> del obj.name
dict([mapping-or-sequence]) Returns a new dictionary initialized from the optional argument (or an empty dictionary if no argument). Argument may be a sequence (or anything iterable) of pairs (key,value).
dir([object]) Without args, returns the list of names in the current local symbol table. With a module, class or class instance object as arg, returns the list of names in its attr. dictionary.
divmod(a,b) Returns tuple (a//b, a%b)
enumerate(iterable) Iterator returning pairs (index, value) of iterable, e.g. List(enumerate('Py')) -> [(0, 'P'), (1, 'y')].
eval(s[, globals[, locals]]) Evaluates string s, representing a single python expression, in (optional) globals, locals contexts. s must have no NUL's or newlines. s can also be a code object. locals can be any mapping type, not only a regular Python dict.
Example: 
x = 1; assert eval('x + 1') == 2
(To execute statements rather than a single expression, use Python statement exec or built-in function execfile)
execfile(file[, globals[,locals]]) Executes a file without creating a new module, unlike import. locals can be any mapping type, not only a regular Python dict.
file(filename[,mode[,bufsize]]) Opens a file and returns a new file object. Alias for open.
filter(function,sequence) Constructs a list from those elements of sequence for which function returns true. function takes one parameter.
float(x) Converts a number or a string to floating point.
frozenset([iterable]) Returns a frozenset (immutable set) object whose (immutable) elements are taken from iterable, or empty by default. See also Sets.
getattr(object,name[,default])) Gets attribute called name from object, e.g. getattr(x, 'f') <=> x.f). If not found, raises AttributeError or returns default if specified.
globals() Returns a dictionary containing the current global variables.
hasattr(object, name) Returns true if object has an attribute called name.
hash(object) Returns the hash value of the object (if it has one).
help([object]) Invokes the built-in help system. No argument -> interactive help; if object is a string (name of a module, function, class, method, keyword, or documentation topic), a help page is printed on the console; otherwise a help page on object is generated.
hex(x) Converts a number x to a hexadecimal string.
id(object) Returns a unique integer identifier for object. Since 2.5 always returns non-negative numbers.
input([prompt]) Prints prompt if given. Reads input and evaluates it. Uses line editing / history if module readline available.
int(x[, base]) Converts a number or a string to a plain integer. Optional base parameter specifies base from which to convert string values.
intern(aString) Enters aString in the table of interned strings and returns the string. Since 2.3, interned strings are no longer 'immortal' (never garbage collected), see [details]
isinstance(obj, classInfo) Returns true if obj is an instance of class classInfo or an object of type classInfo (classInfo may also be a tuple of classes or types). If issubclass(A,B) then isinstance(x,A) => isinstance(x,B)
issubclass(class1, class2) Returns true if class1 is derived from class2 (or if class1 is class2).
iter(obj[,sentinel]) Returns an iterator on obj. If sentinel is absent, obj must be a collection implementing either __iter__() or __getitem__(). If sentinel is given, obj will be called with no arg; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value will be returned. See Iterators.
len(obj) Returns the length (the number of items) of an object (sequence, dictionary, or instance of class implementing __len__).
list([seq]) Creates an empty list or a list with same elements as seq. seq may be a sequence, a container that supports iteration, or an iterator object. If seq is already a list, returns a copy of it.
locals() Returns a dictionary containing current local variables.
long(x[, base]) Converts a number or a string to a long integer. Optional base parameter specifies the base from which to convert string values.
map(function, sequence[, sequence, ...]) Returns a list of the results of applying function to each item from sequence(s). If more than one sequence is given, the function is called with an argument list consisting of the corresponding item of each sequence, substituting None for missing values when not all sequences have the same length. If function is None, returns a list of the items of the sequence (or a list of tuples if more than one sequence). => You might also consider using list comprehensions instead of map().
max(iterable[, key=func])
max(v1, v2, ...[, key=func]) 		With a single argument iterable, returns the largest item of a non-empty iterable (such as a string, tuple or list). With more than one argument, returns the largest of the arguments. The optional key arg is a function that takes a single argument and is called for every value in the list.
min(iterable[, key=func])
min(v1, v2, ...[, key=func])		 With a single argument iterable, returns the smallest item of a non-empty iterable (such as a string, tuple or list). With more than one argument, returns the smallest of the arguments. The optional key arg is a function that takes a single argument and is called for every value in the list.
object() Returns a new featureless object. object is the base class for all new style classes, its methods are common to all instances of new style classes.
oct(x) Converts a number to an octal string.
open(filename [, mode='r', [bufsize]]) Returns a new file object. See also alias file(). Use codecs.open() instead to open an encoded file and provide transparent encoding / decoding.
  • filename is the file name to be opened
  • mode indicates how the file is to be opened:
    • 'r' for reading
    • 'w' for writing (truncating an existing file)
    • 'a' opens it for appending
    • '+' (appended to any of the previous modes) open the file for updating (note that 'w+'truncates the file)
    • 'b' (appended to any of the previous modes) open the file in binary mode
    • 'U' (or 'rU') open the file for reading in Universal Newline mode: all variants of EOL (CR, LF, CR+LF) will be translated to a single LF ('/n').
  • bufsize is 0 for unbuffered, 1 for line buffered, negative or omitted for system default, >1 for a buffer of (about) the given size.
ord(c) Returns integer ASCII value of c (a string of len 1). Works with Unicode char.
pow(x, y [, z]) Returns x to power y [modulo z]. See also ** operator.
property([fget[, fset[, fdel[, doc]]]]) Returns a property attribute for new-style classes (classes deriving from object). fget, fset, and fdel are functions to get the property value, set the property value, and delete the property, respectively. Typical use:
class C(object):
  def __init__(self): self.__x = None
  def getx(self): return self.__x
  def setx(self, value): self.__x = value
  def delx(self): del self.__x
  x = property(getx, setx, delx, "I'm the 'x' property.")
range([start,] end [, step]) Returns list of ints from >= start and < end.
With 1 arg, list from 0..arg-1
With 2 args, list from start..end-1
With 3 args, list from start up to end by step
raw_input([prompt]) Prints prompt if given, then reads string from std input (no trailing /n). See also input().
reduce(f, list [, init]) Applies the binary function f to the items of list so as to reduce the list to a single value. If init is given, it is "prepended" to list.
reload(module) Re-parses and re-initializes an already imported module. Useful in interactive mode, if you want to reload a module after fixing it. If module was syntactically correct but had an error in initialization, must import it one more time before calling reload().
repr(object) Returns a string containing a printable and if possible evaluable representation of an object. <=> `object` (using backquotes). Class redefinable (__repr__). See also str()
round(x, n=0) Returns the floating point value x rounded to n digits after the decimal point.
set([iterable]) Returns a set object whose elements are taken from iterable, or empty by default. See also Sets.
setattr(object, name, value) This is the counterpart of getattr().setattr(o, 'foobar', 3) <=> o.foobar = 3. Creates attribute if it doesn't exist!
slice([start,] stop[, step]) Returns a slice object representing a range, with R/O attributes: start, stop, step.
sorted(iterable[, cmp[, key[, reverse]]]) Returns a new sorted list from the items in iterable. This contrasts with list.sort() that sorts lists in place and doesn't apply to immutable sequences like strings or tuples. See sequences.sort method.
staticmethod(function) Returns a static method for function. A static method does not receive an implicit first argument. To declare a static method, use this idiom:

  class C:
    def f(arg1, arg2, ...): ...
    f = staticmethod(f)

Then call it on the class C.f() or on an instance C().f(). The instance is ignored except for its class.
Since 2.4 you can alternatively use the decorator notation:
  class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
str(object) Returns a string containing a nicely printable representation of an object. Class overridable (__str__). See also repr().
sum(iterable[, start=0]) Returns the sum of a sequence of numbers (not strings), plus the value of parameter. Returns start when the sequence is empty.
super( type[, object-or-type]) Returns the superclass of type. If the second argument is omitted the super object returned is unbound. If the second argument is an object, isinstance(obj, type) must be true. If the second argument is a type, issubclass(type2, type) must be true. Typical use:
class C(B):
  def meth(self, arg):
    super(C, self).meth(arg)
tuple([seq]) Creates an empty tuple or a tuple with same elements as seq. seq may be a sequence, a container that supports iteration, or an iterator object. If seq is already a tuple, returns itself (not a copy).
type(obj) Returns a type object [see module types] representing the type of obj. Example: import types if type(x) == types.StringType: print 'It is a string'. NB: it is better to use instead: if isinstance(x, types.StringType)...
unichr(code) Returns a unicode string 1 char long with given code.
unicode(string[, encoding[,error]]]) Creates a Unicode string from a 8-bit string, using the given encoding name and error treatment ('strict', 'ignore',or 'replace'}. For objects which provide a __unicode__() method, it will call this method without arguments to create a Unicode string.
vars([object]) Without arguments, returns a dictionary corresponding to the current local symbol table. With a module, class or class instance object as argument, returns a dictionary corresponding to the object's symbol table. Useful with the "%" string formatting operator.
xrange(start [, end [, step]]) Like range(), but doesn't actually store entire list all at once. Good to use in "for" loops when there is a big range and little memory.
zip(seq1[, seq2,...]) [No, that's not a compression tool! For that, see module zipfile] Returns a list of tuples where each tuple contains the nth element of each of the argument sequences. Since 2.4 returns an empty list if called with no arguments (was raising TypeError before).

Built-In Exception classes

BaseException
Mother of all exceptions (was Exception before 2.5). New-style class. exception.args is a tuple of the arguments passed to the constructor.
KeyboardInterrupt & SystemExit were moved out of Exception because they don't really represent errors, so now a try:...except Exception: will only catch errors, while a try:...except BaseException: (or simply try:..except:) will still catch everything.

  • KeyboardInterrupt
    On user entry of the interrupt key (often `CTRL-C'). Before 2.5 was derived from Exception.
  • SystemExit
    On sys.exit(). Before 2.5 was derived from Exception.
  • Exception
    Base of all errors. Before 2.5 was the base of all exceptions.
    • GeneratorExit
      Raised by the close() method of generators to terminate the iteration.
    • StandardError
      Base class for all built-in exceptions; derived from Exception root class.
      • ArithmeticError
        Base class for arithmetic errors.
        • FloatingPointError
          When a floating point operation fails.
        • OverflowError
          On excessively large arithmetic operation.
        • ZeroDivisionError
          On division or modulo operation with 0 as 2nd argument.
      • AssertionError
        When an assert statement fails.
      • AttributeError
        On attribute reference or assignment failure
      • EnvironmentError [new in 1.5.2]
        On error outside Python; error arg. tuple is (errno, errMsg...)
        • IOError [changed in 1.5.2]
          I/O-related operation failure.
        • OSError [new in 1.5.2]
          Used by the os module's os.error exception.
          • WindowsError
            When a Windows-specific error occurs or when the error number does not correspond to an errno value.
      • EOFError
        Immediate end-of-file hit by input() or raw_input()
      • ImportError
        On failure of import to find module or name.
      • KeyboardInterrupt
        Moved under BaseException.
      • LookupError
        base class for IndexError, KeyError
        • IndexError
          On out-of-range sequence subscript
        • KeyError
          On reference to a non-existent mapping (dict) key
      • MemoryError
        On recoverable memory exhaustion
      • NameError
        On failure to find a local or global (unqualified) name.
        • UnboundLocalError
          On reference to an unassigned local variable.
      • ReferenceError
        On attempt to access to a garbage-collected object via a weak reference proxy.
      • RuntimeError
        Obsolete catch-all; define a suitable error instead.
        • NotImplementedError [new in 1.5.2]
          On method not implemented.
      • SyntaxError
        On parser encountering a syntax error
        • IndentationError
          On parser encountering an indentation syntax error
          • TabError
            On improper mixture of spaces and tabs
      • SystemError
        On non-fatal interpreter error - bug - report it !
      • TypeError
        On passing inappropriate type to built-in operator or function.
      • ValueError
        On argument error not covered by TypeError or more precise.
        • UnicodeError
          On Unicode-related encoding or decoding error.
          • UnicodeDecodeError
            On Unicode decoding error.
          • UnicodeEncodeError
            On Unicode encoding error.
          • UnicodeTranslateError
            On Unicode translation error.
    • StopIteration
      Raised by an iterator's next() method to signal that there are no further values.
    • SystemExit
      Moved under BaseException.
    • Warning
      Base class for warnings (see module warning)
      • DeprecationWarning
        Warning about deprecated code.
      • FutureWarning
        Warning about a construct that will change semantically in the future.
      • ImportWarning
        Warning about probable mistake in module import (e.g. missing __init__.py).
      • OverflowWarning
        Warning about numeric overflow. Won't exist in Python 2.5.
      • PendingDeprecationWarning
        Warning about future deprecated code.
      • RuntimeWarning
        Warning about dubious runtime behavior.
      • SyntaxWarning
        Warning about dubious syntax.
      • UnicodeWarning
        When attempting to compare a Unicode string and an 8-bit string that can't be converted to Unicode using default ASCII encoding (raised a UnicodeDecodeError before 2.5).
      • UserWarning
        Warning generated by user code.

Standard methods & operators redefinition in classes

Standard methods & operators map to special methods '__method__' and thus can be redefined (mostly in user-defined classes), e.g.: 

class C:
    def __init__(self, v): self.value = v
    def __add__(self, r): return self.value + r

a = C(3) # sort of like calling C.__init__(a, 3)
a + 4    # is equivalent to a.__add__(4)

 

Special methods for any class
Method Description
__new__(cls[, ...]) Instance creation (on construction). If __new__ returns an instance of cls then __init__ is called with the rest of the arguments (...), otherwise __init__ is not invoked. More details here.
__init__(self, args) Instance initialization (on construction)
__del__(self) Called on object demise (refcount becomes 0)
__repr__(self) repr() and `...` conversions
__str__(self) str() and print statement
__cmp__(self,other) Compares self to other and returns <0, 0, or >0. Implements >, <, == etc...
__index__(self) [PEP357] Allows using any object as integer indice (e.g. for slicing). Must return a single integer or long integer value.
__lt__(self, other) Called for self < other comparisons. Can return anything, or can raise an exception.
__le__(self, other) Called for self <= other comparisons. Can return anything, or can raise an exception.
__gt__(self, other) Called for self > other comparisons. Can return anything, or can raise an exception.
__ge__(self, other) Called for self >= other comparisons. Can return anything, or can raise an exception.
__eq__(self, other) Called for self == other comparisons. Can return anything, or can raise an exception.
__ne__(self, other) Called for self != other (and self <> other) comparisons. Can return anything, or can raise an exception.
__hash__(self) Compute a 32 bit hash code; hash() and dictionary ops. Since 2.5 can also return a long integer, in which case the hash of that value will be taken.
__nonzero__(self) Returns 0 or 1 for truth value testing. when this method is not defined, __len__() is called if defined; otherwise all class instances are considered "true".
__getattr__(self,name) Called when attribute lookup doesn't find name. See also __getattribute__.
__getattribute__( self, name) Same as __getattr__ but always called whenever the attribute name is accessed.
__setattr__(self, name, value) Called when setting an attribute (inside, don't use "self.name = value", use instead "self.__dict__[name] = value")
__delattr__(self, name) Called to delete attribute <name>.
__call__(self, *args, **kwargs) Called when an instance is called as function: obj(arg1, arg2, ...) is a shorthand for obj.__call__(arg1, arg2, ...).

Operators

See list in the operator module. Operator function names are provided with 2 variants, with or without leading & trailing '__' (e.g. __add__ or add).

Numeric operations special methods
Operator Special method
self + other __add__(self, other)
self - other __sub__(self, other)
self * other __mul__(self, other)
self / other __div__(self, other) or __truediv__(self,other) if __future__.division is active.
self // other __floordiv__(self, other)
self % other __mod__(self, other)
divmod(self,other) __divmod__(self, other)
self ** other __pow__(self, other)
self & other __and__(self, other)
self ^ other __xor__(self, other)
self | other __or__(self, other)
self << other __lshift__(self, other)
self >> other __rshift__(self, other)
bool(self) __nonzero__(self) (used in boolean testing)
-self __neg__(self)
+self __pos__(self)
abs(self) __abs__(self)
~self __invert__(self) (bitwise)
self += other __iadd__(self, other)
self -= other __isub__(self, other)
self *= other __imul__(self, other)
self /= other __idiv__(self, other) or __itruediv__(self,other) if __future__.division is in effect.
self //= other __ifloordiv__(self, other)
self %= other __imod__(self, other)
self **= other __ipow__(self, other)
self &= other __iand__(self, other)
self ^= other __ixor__(self, other)
self |= other __ior__(self, other)
self <<= other __ilshift__(self, other)
self >>= other __irshift__(self, other)

 

Conversions
built-in function Special method
int(self) __int__(self)
long(self) __long__(self)
float(self) __float__(self)
complex(self) __complex__(self)
oct(self) __oct__(self)
hex(self) __hex__(self)
coerce(self, other) __coerce__(self, other)

Right-hand-side equivalents for all binary operators exist (__radd__, __rsub__, __rmul__, __rdiv__, ...).
They are called when class instance is on r-h-s of operator:

  • a + 3  calls __add__(a, 3)
  • 3 + a  calls __radd__(a, 3)

 

Special operations for containers
Operation Special method Notes
All sequences and maps :
len(self) __len__(self) length of object, >= 0. Length 0 == false
self[k] __getitem__(self, k) Get element at indice /key k (indice starts at 0). Or, if k is a slice object, return a slice.
  __missing__(self, key) Hook called when key is not found in the dictionary, returns the default value.
self[k] = value __setitem__(self, k, value) Set element at indice/key/slice k.
del self[k] __delitem__(self, k) Delete element at indice/key/slice k.
elt in self
elt not in self 		__contains__(self, elt)
not __contains__(self, elt)		 More efficient than std iteration thru sequence.
iter(self) __iter__(self) Returns an iterator on elements (keys for mappings <=> self.iterkeys()). See iterators.
Sequences, general methods, plus:
self[i:j] __getslice__(self, i, j) Deprecated since 2.0, replaced by __getitem__ with a slice object as parameter.
self[i:j] = seq __setslice__(self, i, j,seq) Deprecated since 2.0, replaced by __setitem__ with a slice object as parameter.
del self[i:j] __delslice__(self, i, j) Same as self[i:j] = [] - Deprecated since 2.0, replaced by __delitem__ with a slice object as parameter.
self * n __mul__(self, n) (__repeat__ in the official doc but doesn't work!)
self + other __add__(self, other) (__concat__ in the official doc but doesn't work!)
Mappings, general methods, plus:
hash(self) __hash__(self) hashed value of object self is used for dictionary keys

Special informative state attributes for some types:

Tip: use module inspect to inspect live objects.

Lists & Dictionaries
Attribute Meaning
__methods__ (list, R/O): list of method names of the object Deprecated, use dir() instead
Modules
Attribute Meaning
__doc__ (string/None, R/O): doc string (<=> __dict__['__doc__'])
__name__ (string, R/O): module name (also in __dict__['__name__'])
__dict__ (dict, R/O): module's name space
__file__ (string/undefined, R/O): pathname of .pyc, .pyo or .pyd (undef for modules statically linked to the interpreter). Before 2.3 use sys.argv[0] instead to find the current script filename.
__path__ (list/undefined, R/W): List of directory paths where to find the package (for packages only).
Classes
Attribute Meaning
__doc__ (string/None, R/W): doc string (<=> __dict__['__doc__'])
__name__ (string, R/W): class name (also in __dict__['__name__'])
__module__ (string, R/W): module name in which the class was defined
__bases__ (tuple, R/W): parent classes
__dict__ (dict, R/W): attributes (class name space)
Instances
Attribute Meaning
__class__ (class, R/W): instance's class
__dict__ (dict, R/W): attributes
User defined functions
Attribute Meaning
__doc__ (string/None, R/W): doc string
__name__ (string, R/O): function name
func_doc (R/W): same as __doc__
func_name (R/O, R/W from 2.4): same as __name__
func_defaults (tuple/None, R/W): default args values if any
func_code (code, R/W): code object representing the compiled function body
func_globals (dict, R/O): ref to dictionary of func global variables
User-defined Methods
Attribute Meaning
__doc__ (string/None, R/O): doc string
__name__ (string, R/O): method name (same as im_func.__name__)
im_class (class, R/O): class defining the method (may be a base class)
im_self (instance/None, R/O): target instance object (None if unbound)
im_func (function, R/O): function object
Built-in Functions & methods
Attribute Meaning
__doc__ (string/None, R/O): doc string
__name__ (string, R/O): function name
__self__ [methods only] target object
__members__ list of attr names: ['__doc__','__name__','__self__']) Deprecated, use dir() instead.
Codes
Attribute Meaning
co_name (string, R/O): function name
co_argcount (int, R/0): number of positional args
co_nlocals (int, R/O): number of local vars (including args)
co_varnames (tuple, R/O): names of local vars (starting with args)
co_code (string, R/O): sequence of bytecode instructions
co_consts (tuple, R/O): literals used by the bytecode, 1st one is function doc (or None)
co_names (tuple, R/O): names used by the bytecode
co_filename (string, R/O): filename from which the code was compiled
co_firstlineno (int, R/O): first line number of the function
co_lnotab (string, R/O): string encoding bytecode offsets to line numbers.
co_stacksize (int, R/O): required stack size (including local vars)
co_flags (int, R/O): flags for the interpreter bit 2 set if fct uses "*arg" syntax, bit 3 set if fct uses '**keywords' syntax
Frames
Attribute Meaning
f_back (frame/None, R/O): previous stack frame (toward the caller)
f_code (code, R/O): code object being executed in this frame
f_locals (dict, R/O): local vars
f_globals (dict, R/O): global vars
f_builtins (dict, R/O): built-in (intrinsic) names
f_restricted (int, R/O): flag indicating whether fct is executed in restricted mode
f_lineno (int, R/O): current line number
f_lasti (int, R/O): precise instruction (index into bytecode)
f_trace (function/None, R/W): debug hook called at start of each source line
f_exc_type (Type/None, R/W): Most recent exception type
f_exc_value (any, R/W): Most recent exception value
f_exc_traceback (traceback/None, R/W): Most recent exception traceback
Tracebacks
Attribute Meaning
tb_next (frame/None, R/O): next level in stack trace (toward the frame where the exception occurred)
tb_frame (frame, R/O): execution frame of the current level
tb_lineno (int, R/O): line number where the exception occured
tb_lasti (int, R/O): precise instruction (index into bytecode)
Slices
Attribute Meaning
start (any/None, R/O): lowerbound, included
stop (any/None, R/O): upperbound, excluded
step (any/None, R/O): step value
Complex numbers
Attribute Meaning
real (float, R/O): real part
imag (float, R/O): imaginary part
xranges
Attribute Meaning
tolist (Built-in method, R/O): ?

Important Modules

sys

System-specific parameters and functions. [Full doc]

Some sys variables
Variable Content
argv The list of command line arguments passed to a Python script. sys.argv[0] is the script name.
builtin_module_names A list of strings giving the names of all modules written in C that are linked into this interpreter.
byteorder Native byte order, either 'big'(-endian) or 'little'(-endian).
check_interval How often to check for thread switches or signals (measured in number of virtual machine instructions). Deprecated (since ??), use method getcheckinterval() instead.
copyright A string containing the copyright pertaining to the Python interpreter.
exec_prefix
prefix 		Root directory where platform-dependent Python files are installed, e.g. 'C://Python23', '/usr'.
executable Name of executable binary of the Python interpreter (e.g. 'C://Python23//python.exe', '/usr/bin/python')
exitfunc User can set to a parameterless function. It will get called before interpreter exits. Deprecated since 2.4. Code should be using the existing atexit module
last_type, last_value, last_traceback Set only when an exception not handled and interpreter prints an error. Used by debuggers.
maxint Maximum positive value for integers. Since 2.2 integers and long integers are unified, thus integers have no limit.
maxunicode Largest supported code point for a Unicode character.
modules Dictionary of modules that have already been loaded.
path Search path for external modules. Can be modified by program. sys.path[0] == directory of script currently executed.
platform The current platform, e.g. "sunos5", "win32"
ps1, ps2 Prompts to use in interactive mode, normally ">>>" and "..."
stdin, stdout, stderr File objects used for I/O. One can redirect by assigning a new file object to them (or any object: with a method write(string) for stdout/stderr, or with a method readline() for stdin). __stdin__,__stdout__ and __stderr__ are the default values.
subversion Info about Python build version in the Subversion repository: tuple (interpreter-name, branch-name, revision-range), e.g. ('CPython', 'tags/r25', '51908').
version String containing version info about Python interpreter.
version_info Tuple containing Python version info - (major, minor, micro, level, serial).
winver Version number used to form registry keys on Windows platforms (e.g. '2.2').
Some sys functions
Function Result
_current_frames() Returns the current stack frames for all running threads, as a dictionary mapping thread identifiers to the topmost stack frame currently active in that thread at the time the function is called.
displayhook The function used to display the output of commands issued in interactive mode - defaults to the builtin repr(). __displayhook__ is the original value.
excepthook Can be set to a user defined function, to which any uncaught exceptions are passed. __excepthook__ is the original value.
exit(n) Exits with status n (usually 0 means OK). Raises SystemExit exception (hence can be caught and ignored by program)
getrefcount(object) Returns the reference count of the object. Generally 1 higher than you might expect, because of object arg temp reference.
getcheckinterval() / setcheckinterval(interval) Gets / Sets the interpreter's thread switching interval (in number of bytecode instructions, default: 10 until 2.2, 100 from 2.3).
settrace(func) Sets a trace function: called before each line of code is exited.
setprofile(func) Sets a profile function for performance profiling.
exc_info() Info on exception currently being handled; this is a tuple (exc_type, exc_value, exc_traceback). Warning: assigning the traceback return value to a local variable in a function handling an exception will cause a circular reference.
setdefaultencoding(encoding) Change default Unicode encoding - defaults to 7-bit ASCII.
getrecursionlimit() Retrieve maximum recursion depth.
setrecursionlimit() Set maximum recursion depth (default 1000).

os

Miscellaneous operating system interfaces. [Full doc]

"synonym" for whatever OS-specific module (nt, mac, posix...) is proper for current environment. This module uses posix whenever possible.
See also M.A. Lemburg's utility platform.py (now included in 2.3+).

Some os variables
Variable Meaning
name name of O/S-specific module (e.g. "posix", "mac", "nt")
path O/S-specific module for path manipulations.
On Unix, os.path.split() <=> posixpath.split()
curdir string used to represent current directory (eg '.')
pardir string used to represent parent directory (eg '..')
sep string used to separate directories ('/' or '/'). Tip: Use os.path.join() to build portable paths.
altsep Alternate separator if applicable (None otherwise)
pathsep character used to separate search path components (as in $PATH), eg. ';' for windows.
linesep line separator as used in text files, ie '/n' on Unix, '/r/n' on Dos/Win, '/r' on Mac.
Some os functions
Function Result
makedirs(path[, mode=0777]) Recursive directory creation (create required intermediary dirs); os.error if fails.
removedirs(path) Recursive directory delete (delete intermediary empty dirs); fails (os.error) if the directories are not empty.
renames(old, new) Recursive directory or file renaming; os.error if fails.
urandom(n) Returns a string containing n bytes of random data.

posix

Posix OS interfaces. [Full doc]
Do not import this module directly, import os instead ! (see also module: shutil for file copy & remove functions)

posix Variables
Variable Meaning
environ dictionary of environment variables, e.g. posix.environ['HOME'].
error exception raised on POSIX-related error.
Corresponding value is tuple of errno code and perror() string.
Some posix functions
Function Result
access(path, mode) Returns True if the requested access to path is granted. Use mode=F_OK to check for existence, or an OR-ed combination of R_OK, W_OK, and X_OK to check for r, w, x permissions.
chdir(path) Changes current directory to path.
chmod(path, mode) Changes the mode of path to the numeric mode
close(fd) Closes file descriptor fd opened with posix.open.
_exit(n) Immediate exit, with no cleanups, no SystemExit, etc... Should use this to exit a child process.
execv(p, args) "Become" executable p with args args
getcwd() Returns a string representing the current working directory.
getcwdu() Returns a Unicode string representing the current working directory.
getpid() Returns the current process id.
getsid() Calls the system call getsid() [Unix].
fork() Like C's fork(). Returns 0 to child, child pid to parent [Not on Windows].
kill(pid, signal) Like C's kill [Not on Windows].
listdir(path) Lists (base)names of entries in directory path, excluding '.' and '..'. If path is a Unicode string, so will be the returned strings.
lseek(fd, pos, how) Sets current position in file fd to position pos, expressed as an offset relative to beginning of file (how=0), to current position (how=1), or to end of file (how=2).
mkdir(path[, mode]) Creates a directory named path with numeric mode (default 0777). Actual permissions = (mode & ~umask & 0777). To set directly the permissions, use chmod() after dir creation.
open(file, flags, mode) Like C's open(). Returns file descriptor. Use file object functions rather than this low level ones.
pipe() Creates a pipe. Returns pair of file descriptors (r, w) [Not on Windows].
popen(command, mode='r', bufSize=0) Opens a pipe to or from command. Result is a file object to read to or write from, as indicated by mode being 'r' or 'w'. Use it to catch a command output ('r' mode), or to feed it ('w' mode).
remove(path) See unlink.
rename(old, new) Renames/moves the file or directory old to new. [error if target name already exists]
renames(old, new) Recursive directory or file renaming function. Works like rename(), except creation of any intermediate directories needed to make the new pathname good is attempted first. After the rename, directories corresponding to rightmost path segments of the old name will be pruned away using removedirs().
rmdir(path) Removes the empty directory path
read(fd, n) Reads n bytes from file descriptor fd and return as string.
stat(path) Returns st_mode, st_ino, st_dev, st_nlink, st_uid,st_gid, st_size, st_atime, st_mtime, st_ctime. [st_ino, st_uid, st_gid are dummy on Windows]
system(command) Executes string command in a subshell. Returns exit status of subshell (usually 0 means OK). Since 2.4 use subprocess.call() instead.
times() Returns accumulated CPU times in sec (user, system, children's user, children's sys, elapsed real time) [3 last not on Windows].
unlink(path) Unlinks ("deletes") the file (not dir!) path. Same as: remove.
utime(path, (aTime, mTime)) Sets the access & modified time of the file to the given tuple of values.
wait() Waits for child process completion. Returns tuple of pid, exit_status [Not on Windows].
waitpid(pid, options) Waits for process pid to complete. Returns tuple of pid, exit_status [Not on Windows].
walk(top[, topdown=True [, onerror=None]]) Generates a list of file names in a directory tree, by walking the tree either top down or bottom up. For each directory in the tree rooted at directory top (including top itself), it yields a 3-tuple (dirpath, dirnames, filenames) - more info here. See also os.path.walk().
write(fd, str) Writes str to file fd. Returns nb of bytes written.

posixpath

Posix pathname operations.
Do not import this module directly, import os instead and refer to this module as os.path. (e.g. os.path.exists(p))!

posixpath functions
Function Result
abspath(path) Returns absolute path for path, taking current working dir in account.
commonprefix(list) Returns the longuest path prefix (taken character-by-character) that is a prefix of all paths in list (or '' if list empty).
dirname/basename(path) directory and name parts of path. See also split.
exists(path) True if path is the path of an existing file or directory. See also lexists.
expanduser(path) Returns a copy of path with "~" expansion done.
expandvars(path) Returns string that is (a copy of) path with environment vars expanded. [Windows: case significant; must use Unix: $var notation, not %var%]
getatime(path) Returns last access time of path (integer nb of seconds since epoch).
getctime(path) Returns the metadata change time of path (integer nb of seconds since epoch).
getmtime(path) Returns last modification time of path (integer nb of seconds since epoch).
getsize(path) Returns the size in bytes of path. os.error if file inexistent or inaccessible.
isabs(path) True if path is absolute.
isdir(path) True if path is a directory.
isfile(path) True if path is a regular file.
islink(path) True if path is a symbolic link.
ismount(path) True if path is a mount point [true for all dirs on Windows].
join(p[,q[,...]]) Joins one or more path components in a way suitable for the current OS.
lexists(path) True if the file specified by path exists, whether or not it's a symbolic link (unlike exists).
normcase(path) Normalizes case of path. Has no effect under Posix.
normpath(path) Normalizes path, eliminating double slashes, etc...
realpath(path) Returns the canonical path for path, eliminating any symbolic links encountered in the path.
samefile(f1, f2) True if the 2 paths f1 and f2 reference the same file.
sameopenfile(f1, f2) True if the 2 open file objects f1 and f2 reference the same file.
samestat(s1, s2) True if the 2 stat buffers s1 and s2 reference the same file.
split(p) Splits p into (head, tail) where tail is last pathname component and head is everything leading up to that. <=> (dirname(p), basename(p))
splitdrive(p) Splits path p in a pair ('drive:', tail) [Windows]
splitext(p) Splits into (root, ext) where last comp of root contains no periods and ext is empty or starts with a period.
walk(p, visit, arg) Calls the function visit with arguments (arg, dirname, names) for each directory recursively in the directory tree rooted at p (including p itself if it's a dir). The argument dirname specifies the visited directory, the argument names lists the files in the directory. The visit function may modify names to influence the set of directories visited below dirname, e.g. to avoid visiting certain parts of the tree. See also os.walk() for an alternative.

shutil

High-level file operations (copying, deleting). [Full doc]

Main shutil functions
Function Result
copy(src, dest) Copies the contents of file src to file dest, retaining file permissions.
copytree(src, dest[, symlinks]) Recursively copies an entire directory tree rooted at src into dest (which should not already exist). If symlinks is true, links in src are kept as such in dest.
move(src, dest) Recursively moves a file or directory to a new location.
rmtree(path[, ignore_errors[, onerror]]) Deletes an entire directory tree, ignoring errors if ignore_errors is true, or calling onerror(func, path, sys.exc_info()) if supplied, with arguments func (faulty function), and path (concerned file). This fct fails when the files are Read Only.

(and also: copyfile, copymode, copystat, copy2)

time

Time access and conversions. [Full doc]
(see also module mxDateTime if you need a more sophisticated date/time management)

Variables
Variable Meaning
altzone Signed offset of local DST timezone in sec west of the 0th meridian.
daylight Non zero if a DST timezone is specified.
timezone The offset of the local (non-DST) timezone, in seconds west of UTC.
tzname A tuple (name of local non-DST timezone, name of local DST timezone).
Some functions
Function Result
clock() On Unix: current processor time as a floating point number expressed in seconds.
On Windows: wall-clock seconds elapsed since the 1st call to this function, as a floating point number (precision < 1µs).
time() Returns a float representing UTC time in seconds since the epoch.
gmtime([secs]),
localtime([secs]) 		Returns a 9-tuple representing time. Current time is used if secs is not provided.
Since 2.2, returns a struct_time object (still accessible as a tuple) with the following attributes:
Index Attribute Values
0 tm_year Year (e.g. 1993)
1 tm_mon Month [1,12]
2 tm_mday Day [1,31]
3 tm_hour Hour [0,23]
4 tm_min Minute [0,59]
5 tm_sec Second [0,61]; The 61 accounts for leap seconds and (the very rare) double leap seconds.
6 tm_wday Weekday [0,6], Monday is 0
7 tm_yday Julian day [1,366]
8 tm_isdst Daylight flag: 0, 1 or -1; -1 passed to mktime() will usually work
asctime([timeTuple]), 24-character string of the following form: 'Mon Apr 03 08:31:14 2006'. timeTuple defaults to localtime() if omitted.
ctime([secs]) equivalent to asctime(localtime(secs))
mktime(timeTuple) Inverse of localtime(). Returns a float representing a number of seconds.
strftime(format[, timeTuple]) Formats a time tuple as a string, according to format (see table below). Current time is used if timeTuple is omitted.
strptime(string[, format]) Parses a string representing a time according to format (same format as for strftime(), see below), default "%a %b %d %H:%M:%S %Y" = asctime format.
Returns a time tuple/struct_time.
sleep(secs) Suspends execution for secs seconds. secs can be a float.

 

Formatting in strftime() and strptime()
Directive Meaning
%a Locale's abbreviated weekday name.
%A Locale's full weekday name.
%b Locale's abbreviated month name.
%B Locale's full month name.
%c Locale's appropriate date and time representation.
%d Day of the month as a decimal number [01,31].
%H Hour (24-hour clock) as a decimal number [00,23].
%I Hour (12-hour clock) as a decimal number [01,12].
%j Day of the year as a decimal number [001,366].
%m Month as a decimal number [01,12].
%M Minute as a decimal number [00,59].
%p Locale's equivalent of either AM or PM.
%S Second as a decimal number [00,61]. Yes, 61 !
%U Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.
%w Weekday as a decimal number [0(Sunday),6].
%W Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.
%x Locale's appropriate date representation.
%X Locale's appropriate time representation.
%y Year without century as a decimal number [00,99].
%Y Year with century as a decimal number.
%Z Time zone name (or by no characters if no time zone exists).
%% A literal "%" character.

string

Common string operations. [Full doc]
As of Python 2.0, much (though not all) of the functionality provided by the string module have been superseded by built-in string methods - see Operations on strings for details.

Some string variables
Variable Meaning
digits The string '0123456789'.
hexdigits, octdigits Legal hexadecimal & octal digits.
letters, uppercase, lowercase, whitespace Strings containing the appropriate characters.
ascii_letters, ascii_lowercase, ascii_uppercase Same, taking the current locale in account.
index_error Exception raised by index() if substring not found.
Some string functions
Function Result
expandtabs(s, tabSize) Returns a copy of string s with tabs expanded.
find/rfind(s, sub[, start=0[, end=0]) Returns the lowest/highest index in s where the substring sub is found such that sub is wholly contained in s[start:end]. Return -1 if sub not found.
ljust/rjust/center(s, width[, fillChar=' ']) Returns a copy of string s; left/right justified/centered in a field of given width, padded with spaces or the given character. s is never truncated.
lower/upper(s) Returns a string that is (a copy of) s in lowercase/uppercase.
split(s[, sep=whitespace[, maxsplit=0]]) Returns a list containing the words of the string s, using the string sep as a separator.
rsplit(s[, sep=whitespace[, maxsplit=0]]) Same as split above but starts splitting from the end of string, e.g. 'A,B,C'.split(',', 1) == ['A', 'B,C'] but 'A,B,C'.rsplit(',', 1) == ['A,B', 'C']
join(words[, sep=' ']) Concatenates a list or tuple of words with intervening separators; inverse of split.
replace(s, old, new[, maxsplit=0] Returns a copy of string s with all occurrences of substring old replaced by new. Limits to maxsplit first substitutions if specified.
strip(s[, chars=None]) Returns a string that is (a copy of) s without leading and trailing chars (default: whitespace), if any. Also: lstrip, rstrip.

re (sre)

Regular expression operations. [Full doc]

Handles Unicode strings. Implemented in new module sre, re now a mere front-end for compatibility.
Patterns are specified as strings. Tip: Use raw strings (e.g. r'/w*') to literalize backslashes.

Regular expression syntax
Form Description
. Matches any character (including newline if DOTALL flag specified).
^ Matches start of the string (of every line in MULTILINE mode).
$ Matches end of the string (of every line in MULTILINE mode).
* 0 or more of preceding regular expression (as many as possible).
+ 1 or more of preceding regular expression (as many as possible).
? 0 or 1 occurrence of preceding regular expression.
*?, +?, ?? Same as *, + and ? but matches as few characters as possible.
{m,n} Matches from m to n repetitions of preceding RE.
{m,n}? Idem, attempting to match as few repetitions as possible.
[ ] Defines character set: e.g. '[a-zA-Z]' to match all letters (see also /w /S).
[^ ] Defines complemented character set: matches if char is NOT in set.
/ Escapes special chars '*?+&$|()' and introduces special sequences (see below). Due to Python string rules, write as '//' or r'/' in the pattern string.
// Matches a litteral '/'; due to Python string rules, write as '////' in pattern string, or better using raw string: r'//'.
| Specifies alternative: 'foo|bar' matches 'foo' or 'bar'.
(...) Matches any RE inside (), and delimits a group.
(?:...) Idem but doesn't delimit a group (non capturing parenthesis).
(?P<name>...) Matches any RE inside (), and delimits a named group, (e.g. r'(?P<id>[a-zA-Z_]/w*)' defines a group named id).
(?P=name) Matches whatever text was matched by the earlier group named name.
(?=...) Matches if ... matches next, but doesn't consume any of the string e.g. 'Isaac (?=Asimov)' matches 'Isaac' only if followed by 'Asimov'.
(?!...) Matches if ... doesn't match next. Negative of (?=...).
(?<=...) Matches if the current position in the string is preceded by a match for ... that ends at the current position. This is called a positive lookbehind assertion.
(? Matches if the current position in the string is not preceded by a match for .... This is called a negative lookbehind assertion.
(?(group)A|B) [2.4+] group is either a numeric group ID or a group name defined with (?Pgroup...) earlier in the expression. If the specified group matched, the regular expression pattern A will be tested against the string; if the group didn't match, the pattern B will be used instead.
(?#...) A comment; ignored.
(?letters) letters is one or more of 'i','L', 'm', 's', 'u', 'x'. Sets the corresponding flags (re.I, re.L, re.M, re.S, re.U, re.X) for the entire RE. See the compile() function for equivalent flags.
Special sequences
Sequence Description
/number Matches content of the group of the same number; groups are numbered starting from 1.
/A Matches only at the start of the string.
/b Empty str at beginning or end of word: '/bis/b' matches 'is', but not 'his'.
/B Empty str NOT at beginning or end of word.
/d Any decimal digit (<=> [0-9]).
/D Any non-decimal digit char (<=> [^0-9]).
/s Any whitespace char (<=> [ /t/n/r/f/v]).
/S Any non-whitespace char (<=> [^ /t/n/r/f/v]).
/w Any alphaNumeric char (depends on LOCALE flag).
/W Any non-alphaNumeric char (depends on LOCALE flag).
/Z Matches only at the end of the string.
Variables
Variable Meaning
error Exception when pattern string isn't a valid regexp.
Functions
Function Result
compile(pattern[,flags=0]) Compiles a RE pattern string into a regular expression object.
Flags (combinable by |):
I or IGNORECASE <=> (?i)
case insensitive matching
L or LOCALE <=> (?L)
make /w, /W, /b, /B dependent on the current locale
M or MULTILINE <=> (?m)
matches every new line and not only start/end of the whole string
S or DOTALL <=> (?s)
'.' matches ALL chars, including newline
U or UNICODE <=> (?u)
Make /w, /W, /b, and /B dependent on the Unicode character properties database.
X or VERBOSE <=> (?x)
Ignores whitespace outside character sets
escape(string) Returns (a copy of) string with all non-alphanumerics backslashed.
match(pattern, string[, flags]) If 0 or more chars at beginning of string matches the RE pattern string, returns a corresponding MatchObject instance, or None if no match.
search(pattern, string[, flags]) Scans thru string for a location matching pattern, returns a corresponding MatchObject instance, or None if no match.
split(pattern, string[, maxsplit=0]) Splits string by occurrences of pattern. If capturing () are used in pattern, then occurrences of patterns or subpatterns are also returned.
findall(pattern, string) Returns a list of non-overlapping matches of pattern in string, either a list of groups or a list of tuples if the pattern has more than 1 group.
finditer(pattern, string[, flags]) Returns an iterator over all non-overlapping matches of pattern in string. For each match, the iterator returns a match object. Empty matches are included in the result unless they touch the beginning of another match.
sub(pattern, repl, string[, count=0]) Returns string obtained by replacing the (count first) leftmost non-overlapping occurrences of pattern (a string or a RE object) in string by repl; repl can be a string or a function called with a single MatchObj arg, which must return the replacement string.
subn(pattern, repl, string[, count=0]) Same as sub(), but returns a tuple (newString, numberOfSubsMade).

Regular Expression Objects

RE objects are returned by the compile function.

re object attributes
Attribute Description
flags Flags arg used when RE obj was compiled, or 0 if none provided.
groupindex Dictionary of {group name: group number} in pattern.
pattern Pattern string from which RE obj was compiled.
re object methods
Method Result
match(string[, pos][, endpos]) If zero or more characters at the beginning of string match this regular expression, returns a corresponding MatchObject instance. Returns None if the string does not match the pattern; note that this is different from a zero-length match.
The optional second parameter pos gives an index in the string where the search is to start; it defaults to 0. This is not completely equivalent to slicing the string; the '' pattern character matches at the real beginning of the string and at positions just after a newline, but not necessarily at the index where the search is to start.
The optional parameter endpos limits how far the string will be searched; it will be as if the string is endpos characters long, so only the characters from pos to endpos will be searched for a match.
search(string[, pos][, endpos]) Scans through string looking for a location where this regular expression produces a match, and returns a corresponding MatchObject instance. Returns None if no position in the string matches the pattern; note that this is different from finding a zero-length match at some point in the string.
The optional pos and endpos parameters have the same meaning as for the match() method.
split(string[, maxsplit=0]) Identical to the split() function, using the compiled pattern.
findall(string[, pos[, endpos]]) Identical to the findall() function, using the compiled pattern.
finditer(string[, pos[, endpos]]) Identical to the finditer() function, using the compiled pattern.
sub(repl, string[, count=0]) Identical to the sub() function, using the compiled pattern.
subn(repl, string[, count=0]) Identical to the subn() function, using the compiled pattern.

Match Objects

Match objects are returned by the match & search functions.

Match object attributes
Attribute Description
pos Value of pos passed to search or match functions; index into string at which RE engine started search.
endpos Value of endpos passed to search or match functions; index into string beyond which RE engine won't go.
re RE object whose match or search fct produced this MatchObj instance.
string String passed to match() or search().
Match object methods
Method Result
group([g1, g2, ...]) Returns one or more groups of the match. If one arg, result is a string; if multiple args, result is a tuple with one item per arg. If gi is 0, returns the entire matching string; if 1 <= gi <= 99, returns string matching group #gi (or None if no such group); gi may also be a group name.
groups() Returns a tuple of all groups of the match; groups not participating to the match have a value of None. Returns a string instead of tuple if len(tuple)== 1.
start(group), end(group) Returns indices of start & end of substring matched by group (or None if group exists but didn't contribute to the match).
span(group) Returns the 2-tuple (start(group), end(group)); can be (None, None) if group didn't contibute to the match.

math

For complex number functions, see module cmath. For intensive number crunching, see Numerical Python and the Python and Scientific computing page. [Full doc]

Constants
Name Value
pi 3.1415926535897931
e 2.7182818284590451
Functions
Name Result
acos(x) Returns the arc cosine (measured in radians) of x.
asin(x) Returns the arc sine (measured in radians) of x.
atan(x) Returns the arc tangent (measured in radians) of x.
atan2(y, x) Returns the arc tangent (measured in radians) of y/x. The result is between -pi and pi. Unlike atan(y/x), the signs of both x and y are considered.
ceil(x) Returns the ceiling of x as a float. This is the smallest integral value >= x.
cos(x) Returns the cosine of x (measured in radians).
cosh(x) Returns the hyperbolic cosine of x.
degrees(x) Converts angle x from radians to degrees.
exp(x) Returns e raised to the power of x.
fabs(x) Returns the absolute value of the float x.
floor(x) Returns the floor of x as a float. This is the largest integral value <= x.
fmod(x, y) Returns fmod(x, y), according to platform C. x % y may differ.
frexp(x) Returns the mantissa and exponent of x, as pair (m, e). m is a float and e is an int, such that x = m * 2.**e. If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.
hypot(x, y) Returns the Euclidean distance sqrt(x*x + y*y).
ldexp(x, i) x * (2**i)
log(x[, base]) Returns the logarithm of x to the given base. If the base is not specified, returns the natural logarithm (base e) of x.
log10(x) Returns the base 10 logarithm of x.
modf(x) Returns the fractional and integer parts of x. Both results carry the sign of x. The integer part is returned as a float.
pow(x, y) Returns x**y (x to the power of y). Note that for y=2, it is more efficient to use x*x.
radians(x) Converts angle x from degrees to radians.
sin(x) Returns the sine (measured in radians) of x.
sinh(x) Returns the hyperbolic sine of x.
sqrt(x) Returns the square root of x.
tan(x) Returns the tangent (measured in radians) of x.
tanh(x) Returns the hyperbolic tangent of x.

getopt

Parser for command line options. [Full doc]

This was the standard parser until Python 2.3, now superseded by optparse.
[see also: Richard Gruet's simple parser getargs.py (shameless self promotion)]

Functions:

getopt(list, optstr)    -- Similar to C.  is option letters to look for. 
                           Put ':' after letter if option takes arg. E.g.
    # invocation was "python test.py -c hi -a arg1 arg2"
       opts, args =  getopt.getopt(sys.argv[1:], 'ab:c:')
    # opts would be
       [('-c', 'hi'), ('-a', '')]
    # args would be
       ['arg1', 'arg2']

List of modules and packages in base distribution

Built-ins and content of python Lib directory. The subdirectory Lib/site-packages contains platform-specific packages and modules.
[Main distributions (Windows, Unix), some OS specific modules may be missing]

Standard library modules
Operation Result
__builtin__ Provide direct access to all `built-in' identifiers of Python, e.g. __builtin__.open is the full name for the built-in function open().
__future__ Future statement definitions. Used to progressively introduce new features in the language.
__main__ Represent the (otherwise anonymous) scope in which the interpreter's main program executes -- commands read either from standard input, from a script file, or from an interactive prompt. Typical idiom to check if a code was run as a script (as opposed to being imported):
if __name__ == '__main__':
  main()  # (this code was run as script)
aifc Stuff to parse AIFF-C and AIFF files.
anydbm Generic interface to all dbm clones. (dbhash, gdbm, dbm, dumbdbm).
array Efficient arrays of numeric values.
asynchat A class supporting chat-style (command/response) protocols.
asyncore Basic infrastructure for asynchronous socket service clients and servers.
atexit Register functions to be called at exit of Python interpreter.
audiodev Classes for manipulating audio devices (currently only for Sun and SGI).
audioop Manipulate raw audio data. 2.5: Supports the a-LAW encoding.
base64 Conversions to/from base64 transport encoding as per RFC-1521.
BaseHTTPServer HTTP server base class
Bastion "Bastionification" utility (control access to instance vars).
bdb A generic Python debugger base class.
binascii Convert between binary and ASCII.
binhex Macintosh binhex compression/decompression.
bisect Bisection algorithms.
bsddb (Optional) improved BSD database interface [package].
bz2 BZ2 compression.
calendar Calendar printing functions.
cgi Wraps the WWW Forms Common Gateway Interface (CGI).
CGIHTTPServer CGI-savvy HTTP Server.
cgitb Traceback manager for CGI scripts.
chunk Read IFF chunked data.
cmath Mathematical functions for complex numbers. See also math.
cmd A generic class to build line-oriented command interpreters.
cmp Efficiently compare files, boolean outcome only.
cmpcache Same, but caches 'stat' results for speed.
code Utilities needed to emulate Python's interactive interpreter.
codecs Lookup existing Unicode encodings and register new ones. 2.5: support for incremental codecs.
codeop Utilities to compile possibly incomplete Python source code.
collections high-performance container datatypes. Currently, the only datatype is a double-ended queue. 2.5: Type deque has now a remove method. New type defaultdict.
colorsys Conversion functions between RGB and other color systems.
commands Execute shell commands via os.popen [Unix].
compileall Force "compilation" of all .py files in a directory.
ConfigParser Configuration file parser (much like windows .ini files).
contextlib Utilities for with statement contexts.
Cookie HTTP state (cookies) management.
copy Generic shallow and deep copying operations.
copy_reg Helper to provide extensibility for modules pickle/cPickle.
cPickle Faster, C implementation of pickle.
cProfile Faster, C implementation of profile.
crypt Function to check Unix passwords [Unix].
cStringIO Faster, C implementation of StringIO.
csv Tools to read comma-separated files (of variations thereof). 2.5: Several enhancements.
ctypes "Foreign function" library for Python. Provides C compatible data types, and allows to call functions in dlls/shared libraries. Can be used to wrap these libraries in pure Python.
curses Terminal handling for character-cell displays [Unix/OS2/DOS only].
datetime Improved date/time types (date, time, datetime, timedelta). 2.5: New method strptime(string, format) for class datetime.
dbhash (g)dbm-compatible interface to bsdhash.hashopen.
decimal Decimal floating point arithmetic.
difflib Tool for comparing sequences, and computing the changes required to convert one into another. 2.5: Improved SequenceMatcher.get_matching_blocks() method .
dircache Sorted list of files in a dir, using a cache.
dircmp Defines a class to build directory diff tools on.
dis Bytecode disassembler.
distutils Package installation system. 2.5: Function setup enhanced with new keyword parameters requires, provides, obsoletes, and download_url [PEP314].
distutils.command.register Registers a module in the Python package index (PyPI). This command plugin adds the register command to distutil scripts.
distutils.debug  
distutils.emxccompiler  
distutils.log  
dl Call C functions in shared objects [Unix].
doctest Unit testing framework based on running examples embedded in docstrings. 2.5: New SKIP option. New encoding arg to testfile() function.
DocXMLRPCServer Creation of self-documenting XML-RPC servers, using pydoc to create HTML API doc on the fly. 2.5: New attribute rpc_paths.
dospath Common operations on DOS pathnames.
dumbdbm A dumb and slow but simple dbm clone.
dump Print python code that reconstructs a variable.
dummy_thread  
dummy_threading Helpers to make it easier to write code that uses threads where supported, but still runs on Python versions without thread support. The dummy modules simply run the threads sequentially.
email A package for parsing, handling, and generating email messages. New version 3.0 dropped various deprecated APIs and removes support for Python versions earlier than 2.3. 2.5: Updated to version 4.0.
encodings New codecs: idna (IDNA strings), koi8_u (Ukranian), palmos (PalmOS 3.5), punycode (Punycode IDNA codec), string_escape (Python string escape codec: replaces non-printable chars w/ Python-style string escapes). New codecs in 2.4: HP Roman8, ISO_8859-11, ISO_8859-16, PCTP-154, TIS-620; Chinese, Japanese and Korean codecs.
errno Standard errno system symbols. The value of each symbol is the corresponding integer value.
exceptions Class based built-in exception hierarchy.
fcntl The fcntl() and ioctl() system calls [Unix].
filecmp File and directory comparison.
fileinput Helper class to quickly write a loop over all standard input files. 2.5: Made more flexible (Unicode filenames, mode parameter, etc...)
find Find files directory hierarchy matching a pattern.
fnmatch Filename matching with shell patterns.
formatter Generic output formatting.
fpectl Floating point exception control [Unix].
fpformat General floating point formatting functions.
ftplib An FTP client class. Based on RFC 959.
functools tools for functional-style programming. See in particular function partial() [PEP309].
gc Perform garbage collection, obtain GC debug stats, and tune GC parameters. 2.5: New get_count() function. gc.collect() takes a new generation argument.
gdbm GNU's reinterpretation of dbm [Unix].
getopt Standard command line processing. See also optparse.
getpass Utilities to get a password and/or the current user name.
gettext Internationalization and localization support.
glob Filename "globbing" utility.
gopherlib Gopher protocol client interface.
grp The group database [Unix].
grep 'grep' utilities.
gzip Read & write gzipped files.
hashlib Secure hashes and message digests.
heapq Heap queue (priority queue) helpers. 2.5: nsmallest() and nlargest() takes a key keyword param.
hmac HMAC (Keyed-Hashing for Message Authentication).
hotshot.stones Helper to run the pystone benchmark under the Hotshot profiler.
htmlentitydefs HTML character entity references.
htmllib HTML2 parsing utilities
HTMLParser Simple HTML and XHTML parser.
httplib HTTP1 client class.
idlelib (package) Support library for the IDLE development environment.
ihooks Hooks into the "import" mechanism.
imageop Manipulate raw image data.
imaplib IMAP4 client.Based on RFC 2060.
imghdr Recognizing image files based on their first few bytes.
imp Access the import internals.
imputil Provides a way of writing customized import hooks.
inspect Get information about live Python objects.
itertools Tools to work with iterators and lazy sequences. 2.5: islice() accepts None for start & step args.
keyword List of Python keywords.
knee A Python re-implementation of hierarchical module import.
linecache Cache lines from files.
linuxaudiodev Linux /dev/audio support. Replaced by ossaudiodev(Linux).
locale Support for number formatting using the current locale settings. 2.5: format() modified; new fcts format_string() and currency()
logging (package) Tools for structured logging in log4j style.
macpath Pathname (or related) operations for the Macintosh [Mac].
macurl2path Mac specific module for conversion between pathnames and URLs [Mac].
mailbox Classes to handle Unix style, MMDF style, and MH style mailboxes. 2.5: added capability to modify mailboxes in addition to reading them.
mailcap Mailcap file handling (RFC 1524).
marshal Internal Python object serialization.
markupbase Shared support for scanning document type declarations in HTML and XHTML.
math Mathematical functions. See also cmath
md5 MD5 message digest algorithm. 2.5: Now a mere wrapper around new library hashlib.
mhlib MH (mailbox) interface.
mimetools Various tools used by MIME-reading or MIME-writing programs.
mimetypes Guess the MIME type of a file.
MimeWriter Generic MIME writer. Deprecated since release 2.3. Use the email package instead.
mimify Mimification and unmimification of mail messages.
mmap Interface to memory-mapped files - they behave like mutable strings.
modulefinder Tools to find what modules a given Python program uses, without actually running the program.
msilib Read and write Microsoft Installer files [Windows].
msvcrt File & Console Windows-specific operations [Windows].
multifile A readline()-style interface to the parts of a multipart message.
mutex Mutual exclusion -- for use with module sched. See also std module threading, and glock.
netrc Parses and encapsulates the netrc file format.
new Creation of runtime internal objects (interface to interpreter object creation functions).
nis Interface to Sun's NIS (Yellow Pages) [Unix]. 2.5: New domain arg to nis.match() and nis.maps().
nntplib An NNTP client class. Based on RFC 977.
ntpath Common operations on Windows pathnames [Windows].
nturl2path Convert a NT pathname to a file URL and vice versa [Windows].
olddifflib Old version of difflib (helpers for computing deltas between objects)?
operator Standard operators as functions. 2.5: itemgetter() and attrgetter() now supports multiple fields.
optparse Improved command-line option parsing library (see also getopt). 2.5: Updated to Optik library 1.51.
os OS routines for Mac, DOS, NT, or Posix depending on what system we're on. 2.5: os.stat() return time values as floats; new constants to os.lseek(); new functions wait3() and wait4(); on FreeBSD, os.stat() returns times with nanosecond resolution.
os.path Common pathname manipulations.
os2emxpath os.path support for OS/2 EMX.
packmail Create a self-unpacking shell archive.
parser Access Python parse trees.
pdb A Python debugger.
pickle Pickling (save/serialize and restore/deserialize) of Python objects (a faster C implementation exists in built-in module: cPickle). 2.5: Value returned by __reduce__() must be different from None.
pickletools Tools to analyze and disassemble pickles.
pipes Conversion pipeline templates [Unix].
pkgutil Tools to extend the module search path for a given package. 2.5: PEP302's import hooks support; works for packages in ZIP format archives.
platform Get info about the underlying platform.
poly Polynomials.
popen2 Spawn a command with pipes to its stdin, stdout, and optionally stderr. Superseded by module subprocess since 2.4
poplib A POP3 client class.
posix Most common POSIX system calls [Unix].
posixfile (deprecated since 1.5, use fcntl.lockf() instead) File-like objects with locking support [Unix].
posixpath Common operations on POSIX pathnames.
pprint Support to pretty-print lists, tuples, & dictionaries recursively.
pre Support for regular expressions (RE) - see re.
profile Class for profiling python code. 2.5: See also new fast C implementation cProfile
pstats Class for printing reports on profiled python code. 2.5: new stream arg to Stats constructor.
pty Pseudo terminal utilities [Linux, IRIX].
pwd The password database [Unix].
py_compile Routine to "compile" a .py file to a .pyc file.
pyclbr Parse a Python file and retrieve classes and methods.
pydoc Generate Python documentation in HTML or text for interactive use.
pyexpat Interface to the Expat XML parser. 2.5: now uses V2.0 of the expat parser.
PyUnit Unit test framework inspired by JUnit. See unittest.
Queue A multi-producer, multi-consumer queue.
quopri Conversions to/from quoted-printable transport encoding as per RFC 1521.
rand Don't use unless you want compatibility with C's rand().
random Random variable generators.
re Regular Expressions.
readline GNU readline interface [Unix].
reconvert Convert old ("regex") regular expressions to new syntax ("re").
regexp Backward compatibility for module "regexp" using "regex".
regex_syntax Flags for regex.set_syntax().
regsub Regexp-based split and replace using the obsolete regex module.
repr Alternate repr() implementation.
resource Resource usage information [Unix].
rexec Restricted execution facilities ("safe" exec, eval, etc).
rfc822 Parse RFC-8222 mail headers.
rgbimg Read and write 'SGI RGB' files.
rlcompleter Word completion for GNU readline 2.0 [Unix]. 2.5: Doesn't depend on readline anymore; now works on non-Unix platforms.
robotparser Parse robot.txt files, useful for web spiders.
sched A generally useful event scheduler class.
select Waiting for I/O completion.
sets A Set datatype implementation based on dictionaries (see Sets).
sgmllib A parser for SGML, using the derived class as a static DTD.
sha SHA-1 message digest algorithm. 2.5: Now a mere wrapper around new library hashlib.
shelve Manage shelves of pickled objects.
shlex Lexical analyzer class for simple shell-like syntaxes.
shutil Utility functions for copying files and directory trees.
signal Set handlers for asynchronous events.
SimpleHTTPServer Simple HTTP Server.
SimpleXMLRPCServer Simple XML-RPC Server. 2.5: New attribute rpc_paths.
site Append module search paths for third-party packages to sys.path.
smtpd An RFC 2821 SMTP server.
smtplib SMTP/ESMTP client class.
sndhdr Several routines that help recognizing sound.
socket Socket operations and some related functions. Now supports timeouts thru function settimeout(t). Also supports SSL on Windows. 2.5: Now supports AF_NETLINK sockets on Linux; new socket methods recv_buf(buffer), recvfrom_buf(buffer), getfamily(), gettype() and getproto() .
SocketServer Generic socket server classes.
spwd Access to the UNIX shadow password database [Unix].
sqlite3 DB-API 2.0 interface for SQLite databases.
sre Support for regular expressions (RE). See re.
stat Constants/functions for interpreting results of os.
statcache Maintain a cache of stat() information on files.
statvfs Constants for interpreting statvfs struct as returned by os.statvfs() and os.fstatvfs() (if they exist).
string A collection of string operations (see Strings).
StringIO File-like objects that read/write a string buffer (a faster C implementation exists in built-in module cStringIO).
stringprep Normalization and manipulation of Unicode strings.
struct Perform conversions between Python values and C structs represented as Python strings. 2.5: faster (new pack() and unpack() methods); pack and unpack to and from buffer objects via methods pack_into and unpack_from.
subprocess Subprocess management. Replacement for os.system, os.spawn*, os.popen*, popen2.* [PEP324]
sunau Stuff to parse Sun and NeXT audio files.
sunaudio Interpret sun audio headers.
symbol Non-terminal symbols of Python grammar (from "graminit.h").
symtable Interface to the compiler's internal symbol tables.
sys System-specific parameters and functions.
syslog Unix syslog library routines [Unix].
tabnanny Check Python source for ambiguous indentation.
tarfile Tools to read and create TAR archives. 2.5: New method TarFile.extractall().
telnetlib TELNET client class. Based on RFC 854.
tempfile Temporary files and filenames.
termios POSIX style tty control [Unix].
test Regression tests package for Python.
textwrap Tools to wrap paragraphs of text.
thread Multiple threads of control (see also threading below).
threading New threading module, emulating a subset of Java's threading model. 2.5: New function stack_size([size]) allows to get/set the stack size for threads created.
threading_api (doc of the threading module).
time Time access and conversions.
timeit Benchmark tool.
Tix Extension widgets for Tk.
Tkinter Python interface to Tcl/Tk.
toaiff Convert "arbitrary" sound files to AIFF (Apple and SGI's audio format).
token Token constants (from "token.h").
tokenize Tokenizer for Python source.
trace Tools to trace execution of a function or program.
traceback Extract, format and print information about Python stack traces.
tty Terminal utilities [Unix].
turtle LogoMation-like turtle graphics.
types Define names for all type symbols in the std interpreter.
tzparse Parse a timezone specification.
unicodedata Interface to unicode properties. 2.5: Updated to Unicode DB 4.1.0; Version 3.2.0 still available as unicodedata.ucd_3_2_0.
unittest Python unit testing framework, based on Erich Gamma's and Kent Beck's JUnit.
urllib Open an arbitrary URL.
urllib2 An extensible library for opening URLs using a variety of protocols.
urlparse Parse (absolute and relative) URLs.
user Hook to allow user-specified customization code to run.
UserDict A wrapper to allow subclassing of built-in dict class (useless with new-style classes. Since Python 2.2, dict is subclassable).
UserList A wrapper to allow subclassing of built-in list class (useless with new-style classes. Since Python 2.2, list is subclassable)
UserString A wrapper to allow subclassing of built-in string class (useless with new-style classes. Since Python 2.2, str is subclassable).
util some useful functions that don't fit elsewhere !!
uu Implementation of the UUencode and UUdecode functions.
uuid UUID objects according to RFC 4122.
warnings Python part of the warnings subsystem. Issue warnings, and filter unwanted warnings.
wave Stuff to parse WAVE files.
weakref Weak reference support for Python. Also allows the creation of proxy objects. 2.5: new methods iterkeyrefs(), keyrefs(), itervaluerefs() and valuerefs().
webbrowser Platform independent URL launcher. 2.5: several enhancements (more browsers supported, etc...).
whatsound Several routines that help recognizing sound files.
whichdb Guess which db package to use to open a db file.
whrandom Wichmann-Hill random number generator (obsolete, use random instead).
winsound Sound-playing interface for Windows [Windows].
wsgiref WSGI Utilities and Reference Implementation.
xdrlib Implements (a subset of) Sun XDR (eXternal Data Representation).
xml.dom Classes for processing XML using the DOM (Document Object Model). 2.3: New modules expatbuilder, minicompat, NodeFilter, xmlbuilder.
xml.etree.ElementTree Subset of Fredrik Lundh's ElementTree library for processing XML.
xml.parsers.expat An interface to the Expat non-validating XML parser.
xml.sax Classes for processing XML using the SAX API.
xmlrpclib An XML-RPC client interface for Python. 2.5: Supports returning datetime objects for the XML-RPC date type.
xreadlines Provides a sequence-like object for reading a file line-by-line without reading the entire file into memory. Deprecated since release 2.3. Use for line in file instead. Removed since 2.4
zipfile Read & write PK zipped files. 2.5: Supports ZIP64 version, a .zip archive can now be larger than 4GB.
zipimport ZIP archive importer.
zlib Compression compatible with gzip. 2.5: Compress and Decompress objects now support a copy() method.
zmod Demonstration of abstruse mathematical concepts.

Workspace exploration and idiom hints

dir(object) list valid attributes of object (which can be a module, type or class object)
dir() list names in current local symbol table.
if __name__ == '__main__':
    main()		 invoke main() if running as script
map(None, lst1, lst2, ...) merge lists; see also zip(lst1, lst2, ...)
b = a[:] create a copy b of sequence a
b = list(a) If a is a list, create a copy of it.
a,b,c = 1,2,3 Multiple assignment, same as a=1; b=2; c=3
for key, value in dic.items(): ... Works also in this context
if 1 < x <= 5: ... Works as expected
for line in fileinput.input(): ... Process each file in command line args, one line at a time
_ (underscore) in interactive mode, refers to the last value printed.

Python Mode for Emacs

Emacs goodies available here. 

(The following has not been revised, probably not up to date - any contribution welcome -)

 
Type C-c ? when in python-mode for extensive help.
INDENTATION
Primarily for entering new code:
        TAB      indent line appropriately
        LFD      insert newline, then indent
        DEL      reduce indentation, or delete single character
Primarily for reindenting existing code:
        C-c :    guess py-indent-offset from file content; change locally
        C-u C-c :        ditto, but change globally
        C-c TAB  reindent region to match its context
        C-c <    shift region left by py-indent-offset
        C-c >    shift region right by py-indent-offset
MARKING & MANIPULATING REGIONS OF CODE
C-c C-b         mark block of lines
M-C-h           mark smallest enclosing def
C-u M-C-h       mark smallest enclosing class
C-c #           comment out region of code
C-u C-c #       uncomment region of code
MOVING POINT
C-c C-p         move to statement preceding point
C-c C-n         move to statement following point
C-c C-u         move up to start of current block
M-C-a           move to start of def
C-u M-C-a       move to start of class
M-C-e           move to end of def
C-u M-C-e       move to end of class
EXECUTING PYTHON CODE
C-c C-c sends the entire buffer to the Python interpreter
C-c |   sends the current region
C-c !   starts a Python interpreter window; this will be used by
        subsequent C-c C-c or C-c | commands
VARIABLES
py-indent-offset        indentation increment
py-block-comment-prefix comment string used by py-comment-region
py-python-command       shell command to invoke Python interpreter
py-scroll-process-buffer        t means always scroll Python process buffer
py-temp-directory       directory used for temp files (if needed)
py-beep-if-tab-change   ring the bell if tab-width is changed

你可能感兴趣的:(python)

  • 华为OD机试 - 数大雁（Java & Python& JS & C++ & C ） 算法大师 最新华为OD机试c++java华为OD华为od机试python华为odjavascript
    最新华为OD机试真题目录：点击查看目录华为OD面试真题精选：点击立即查看题目描述一群大雁往南飞，给定一个字符串记录地面上的游客听到的大雁叫声，请给出叫声最少由几只大雁发出。具体的:1.大雁发出的完整叫声为”quack“，因为有多只大雁同一时间嘎嘎作响，所以字符串中可能会混合多个”quack”。2.大雁会依次完整发出”quack”，即字符串中’q’,‘u’,‘a’,‘c’,‘k’这5个字母按顺序完整
  • 【Python】Tkinter电器销售有限公司销售数据分析（源码）【独一无二】 不争不抢不显不露 python数据分析开发语言
    一、设计要求该项目创建一个数据分析软件，利用Tkinter和Matplotlib构建图形用户界面（GUI），读取和分析美迪电器销售有限公司销售数据。用户可以通过界面选择月份查看数据详情、生成销量图表并计算月总销量和年总销量。二、设计思路2.模块引入首先引入了所需的模块，包括Tkinter（用于GUI创建和管理）、ttk（Tkinter主题化控件）、messagebox（用于弹出消息框）、panda
  • 【Python】super() 函数和 MRO 顺序的实例剖析 彭彭不吃虫子 python开发语言
    1.构造函数（__init__(self[,...])）在类中定义__init__()方法，可以实现在实例化对象的时候进行个性化定制：>>>classC:...    def__init__(self,x,y):...      self.x=x...      self.y=y...    defadd(self):...      returnself.x+self.y...    defmu
  • 【Python】类与对象:self在其中的作用，面向对象的优势，函数和方法的区别 彭彭不吃虫子 python开发语言
    1.self在类和对象中的功能与用处在面向对象编程（OOP）中，self是类中方法的第一个参数，它指向当前实例（对象）。每个类的方法第一个参数通常是self，它用于引用当前对象本身，这使得我们能够访问类中的属性和其他方法。功能与用处：访问实例属性：self允许在类的方法中引用对象的属性。例如，如果类中有一个实例属性name，你可以通过self.name来访问它。修改实例属性：通过self，方法可以
  • Python在WRF模型自动化运行及前后处理中实践技术应用-包括数据处理、模型运行、结果可视化等步骤。 KY_chenzhao python自动化开发语言
    1.背景与目标WRF（WeatherResearchandForecasting）模型是中尺度气象数值模式的佼佼者，广泛应用于气象预报和气候研究。Python在WRF模型中的应用主要体现在前后处理、自动化运行和数据可视化等方面。本文将以风速预测为例，详细说明Python在WRF模型中的具体应用，包括数据处理、模型运行、结果可视化等步骤。2.数据准备数据来源包括WRF模型的输出数据和实际观测数据。这
  • 基于Python机器学习、深度学习技术提升气象、海洋、水文领域实践应用 KY_chenzhao python机器学习深度学习气象
    1.背景与目标ENSO（ElNiño-SouthernOscillation）是全球气候系统中最显著的年际变率现象之一，对全球气候、农业、渔业等有着深远的影响。准确预测ENSO事件的发生和发展对于减灾防灾具有重要意义。近年来，深度学习技术在气象领域得到了广泛应用，其中长短期记忆网络（LSTM）因其在处理时间序列数据方面的优势，被广泛用于ENSO预测。2.数据准备数据来源包括NOAA（美国国家海洋和
  • PySide6 GUI 学习笔记——Python文件编译打包 Humbunklung PySide6学习笔记python
    前面编写的软件工具都必须运行在Python环境中，且通过命令行的方式运行，通过Python打包工具，我们可以把.py文件封装成对应平台的运行文件，供用户执行。常见Python打包工具工具简介官网/文档地址py2exe将Python脚本转换为Windows可执行文件https://www.py2exe.orgcx_Freeze跨平台的Python打包工具，它可以将Python脚本打包为可执行文件或动
  • ChatGPT Canvas：开启AI编程新纪元——你的AI代码生成器来了！ 前端
    OpenAI近日宣布ChatGPTCanvas全面开放，并带来了两项重磅更新：直接运行Python代码和整合GPTs生态系统。这意味着，即使你不是专业的程序员，也能轻松体验编程的乐趣，并利用AI的力量创造出更多可能性。这对于想要学习编程或提高工作效率的用户来说，无疑是一个巨大的福音。这篇文章将深入探讨这两项更新，并展望ChatGPTCanvas的未来发展。直接运行Python代码：降低编程门槛，释
  • 华为OD机试E卷 --数大雁--24年OD统一考试（Java & JS & Python & C & C++） 飞码创造者 最新华为OD机试题库2024华为odjavajavascriptpythonjsc语言
    文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码c算法源码题目描述一群大雁往南飞，给定一个字符串记录地面上的游客听到的大雁叫声，请给出叫声最少由几只大雁发出。具体：1.大雁发出的完整叫声为”quack“，因为有多只大雁同一时间嘎嘎作响，所以字符串中可能会混合多个”quack”2.大雁会依次完整发出”quack”，即字符串中’q，u,a，c，k这5个字母按
  • Python中的Pipeline快速教学、 Coding Is Fun python开发语言
    在Python中，Pipeline通常指的是机器学习工作流中的流水线，尤其是在使用scikit-learn库时。Pipeline允许你将多个数据处理步骤和模型训练步骤串联起来，形成一个有序的工作流程。这不仅使代码更简洁，还能确保在训练和预测时一致的数据处理。以下是一个快速教学，帮助你掌握Python中Pipeline的核心概念和使用方法。目录安装和导入必要的库Pipeline的基本概念创建一个简单
  • Python实用记录(十五)：PyQt/PySide6打包成exe，精简版（nuitka/pyinstaller/auto-py-to-exe） ZZY_dl 实用操作总结pythonpyqt开发语言
    文章目录Python打包工具：Nuitka、PyInstaller和Auto-py-to-exe详解方式一：Nuitka安装与使用方式二：PyInstaller安装环境打包方式使用spec文件打包打包后文件说明打包参数说明方式三：Auto-py-to-exe安装环境✅⚠️▶️➡️⭐❄️✅⚠️▶️➡️⭐❄️✅⚠️▶️➡️⭐❄️✅⚠️Python打包工具：Nuitka、PyInstaller和Auto
  • Python 操作二进制文件 昱晏 Python1024程序员节python
    在计算机中，文件可以分为两种类型：文本文件和二进制文件。文本文件包含人类可读的字符，而二进制文件包含计算机指令或数据，无法直接阅读。常见的二进制文件包括图片、音频、视频、可执行文件等。Python提供了处理二进制文件的工具，允许你读写任意类型的数据。1以二进制模式打开文件在Python中，操作二进制文件时，需要使用'b'作为文件模式的一部分。常见的二进制文件模式有：'rb'：以二进制读取文件。'w
  • 第9章：Python TDD解决货币对象相等性比较难题 Tester_孙大壮 测试驱动开发python驱动开发开发语言
    写在前面这本书是我们老板推荐过的，我在《价值心法》的推荐书单里也看到了它。用了一段时间Cursor软件后，我突然思考，对于测试开发工程师来说，什么才更有价值呢？如何让AI工具更好地辅助自己写代码，或许优质的单元测试是一个切入点。就我个人而言，这本书确实很有帮助。第一次读的时候，很多细节我都不太懂，但将书中内容应用到工作中后，我受益匪浅。比如面对一些让人抓狂的代码设计时，书里的方法能让我逐步深入理解
  • Python input 怎么使用 彭彭不吃虫子 windows数据库服务器
    一、input()函数简介Python的input()函数是一个内置函数，用于从用户接收输入。当程序运行到input()函数时，会暂停并等待用户输入一些文本，用户输入的文本将作为函数的返回值。这使得我们可以在程序中获取用户的输入，以便根据输入执行相应的操作。二、input()函数语法input()函数的基本语法如下：input(prompt=None)其中，prompt参数是可选的，它表示在等待用
  • 实操数据预处理：从理论到实践的基础步骤 炼丹侠 python机器学习人工智能
    在快速发展的人工智能领域，数据不仅是基础，更是推动技术创新的关键力量。高质量的数据集是构建高效、准确模型的前提。本文将全面深入探讨数据预处理的各个环节，从基础的数据清洗到复杂的数据增强，再到高效的Python应用实践，为你提供一站式的数据处理解决方案。无论你的经验如何，这篇文章都将成为你宝贵的资源。数据清洗：打好数据质量的基础数据清洗是提升数据质量的首要步骤，涵盖了如下几个关键操作：缺失值的智能处
  • 【python】实用的文件操作-多个excel文件的两种合并方式 匡虐 文件操作python
    【python】实用的文件操作-excel文件两种合并方式工作中常遇到多个excel文件表的结构一样，只是内容不同，现需要将其合并在一起。有两种方式，一种是合并成一张表，将其他表中的数据追加到同一张表中。另外一种是存放成一个文件多张表，不同的文件放到一个excel文件的不同工作簿中。1、合成一张表importpandasaspdimportospath=r'C:\Users\lenovo\Docu
  • python-mysql-连接池 Xiaohuansong python笔记pythonmysql连接池
    利用内部队列编写的简易的支持上下文的连接池，目前只支持多线程内的链接代码如下实现了最大最小连接池的限制，链接回收，dml封装，动态维护链接等操作importMySQLdbimportloggingimportQueuefromthreadingimportThreadfromcontextlibimportcontextmanagerimporttimeclassMysqlTool(object)
  • BUUCTF_Crypto_[WUSTCTF2020]B@se qq_58370970 经验分享
    给了一个txt文件：从题目可以看出是与base64相关，不难发现是base64的变种，将base64的顺序改变了，但还有4个字符不知道可以写python脚本得到缺失的4个字符代码如下：importstrings='JASGBWcQPRXEFLbCDIlmnHUVKTYZdMovwipatNOefghq56rs****kxyz012789+/'j='ABCDEFGHIJKLMNOPQRSTUVWXY
  • Python mysql数据库连接池 戴** Python
    最近在写一个Python的文本分析,需要大量的读取数据库(千万级别mysql)并进行更新操作,运行着程序发现一个问题,过了一会儿程序就报错说链接已经满了,或者是端口不可重复使用,因此我在网上找到了一个连接池的代码用于解决这个问题,在此处贴出代码本身是有配置文件的,因为我觉得在我的项目中不必要所以就删除了#!/usr/bin/envpython#-*-coding:utf-8-*-importpym
  • Python的Selenium库中的模块、类和异常的汇总 qq_24654817 pythonselenium开发语言
    1.`selenium.common.exceptions`：包含了Selenium中可能出现的异常。2.`selenium.webdriver.chrome.options`：用于配置Chrome浏览器的选项。3.`selenium.webdriver.chrome.service`：用于管理Chrome浏览器的后台服务。4.`selenium.webdriver.chrome.webdrive
  • 代码编写java代做c++程序代编程Python代c#设计C语言接单软件定制 matlabgoodboy javac++c#
    您提到的服务涵盖了多种编程语言和软件开发需求，包括Java代码编写、C++程序代编、Python编程代做、C#设计、C语言编程，以及软件定制服务。这些服务在软件开发领域非常常见，且有着广泛的应用。以下是对这些服务更详细的解释和接单时的一些建议：服务详解Java代码编写Java以其跨平台性、面向对象和丰富的API而著称，广泛应用于企业级应用、Android应用开发、Web服务端开发等领域。您可以提供
  • 10个方法：用Python执行SQL、Excel常见任务_python util 前端收割机 程序员pythonsqlexcel
    使用Python的最大优点之一是能够从网络的巨大范围中获取数据的能力，而不是只能访问手动下载的文件。在Python的requests库可以帮助你分类不同的网站，并从它们获取数据，而BeautifulSoup库可以帮助你处理和过滤数据，那么你精确得到你所需要的。如果你要去这条路线，请小心使用权问题。（不用担心，如果你想跳过这个部分，可以的！原始的csv文件在这里，你可以随意下载，如果你宁愿开始这个练
  • 基于Python爬虫的豆瓣电影影评数据可视化分析 wp_tao Python副业接单实战项目python爬虫信息可视化
    文章目录前言一、数据抓取二、数据可视化1.绘制词云图2.读入数据总结前言本文以电影《你好，李焕英》在豆瓣上的影评数据为爬取和分析的目标，利用python爬虫技术对影评数据进行了爬取，使用pandas库进行了数据清洗，使用jieba库进行分词，使用collections库进行词频统计，使用wordcloud库绘制词云图，使用matplotlib库绘制了评论人所在城市占比饼状图，并使用matplotl
  • BP神经网络及其Python和MATLAB实现预测 陈辰学长 神经网络pythonmatlab
    BP神经网络及其Python和MATLAB实现预测引言BP神经网络（BackPropagationNeuralNetwork），即反向传播神经网络，是一种通过反向传播算法进行监督学习的多层前馈网络。这种网络能够通过不断地调整和改变神经元的连接权重，达到对特定任务的学习和优化。由于其高度的灵活性和适应性，BP神经网络在模式识别、函数逼近、优化问题等多个领域有着广泛的应用。本文将详细介绍BP神经网络的
  • 【Python】selenium结合js模拟鼠标点击、拦截弹窗、鼠标悬停方法汇总（使用 execute_script 执行点击的方法） 翠花上酸菜 selenium网络爬虫pythonseleniumjavascript
    我们在写selenium获取网络信息的时候，有时候我们会受到对方浏览器的监控，对方通过分析用户行为模式，如点击、滚动、停留时间等，网站可以识别出异常行为，进而对Selenium爬虫进行限制。这里我们可以加入JavaScript的使用。Selenium可以执行JavaScript，通过使用execute_script方法，来执行点击操作。它可以绕过一些Selenium直接操作元素时可能遇到的问题，比
  • Conda与Bash的完美融合：激活你的开发环境 2401_85760095 condabash开发语言
    Conda与Bash的完美融合：激活你的开发环境在Python开发者的日常工作中，Conda不仅作为包管理器，更是一个强大的环境管理工具。为了在bashshell中使用Conda创建的环境，需要进行初始化操作。condainitbash命令正是为此设计的，它可以修改bash的配置文件，使得Conda的环境能够在每次启动bashshell时自动激活。本文将详细介绍如何使用condainitbash命
  • 2024年最全selenium UI使用小技巧集合_python selenium 中 2401_84692253 程序员seleniumuipython
    al=driver.switch_to.alertal.send_keys(“口罩太贵了”)al.accept()#确认对话框time.sleep(3)driver.quit()###鼠标事件用selenium做自动化，有时候会遇到需要模拟鼠标操作才能进行的情况，比如单击、双击、点击鼠标右键、拖拽等等。而selenium给我们提供了一个类来处理这类事件——ActionChainsActionCha
  • webUI自动化之基本框架搭建（python + selenium + unittest）_python ui自动框架 2401_84140628 2024年程序员学习自动化pythonselenium
    先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课
  • 【2025年】全国CTF夺旗赛-从零基础入门到竞赛，看这一篇就稳了！ 白帽黑客鹏哥 linux网络安全web安全密码学CTF夺旗赛
    基于入门网络安全/黑客打造的：黑客&网络安全入门&进阶学习资源包目录一、CTF简介二、CTF竞赛模式三、CTF各大题型简介四、CTF学习路线4.1、初期1、html+css+js（2-3天）2、apache+php（4-5天）3、mysql（2-3天）4、python(2-3天)5、burpsuite（1-2天）4.2、中期1、SQL注入（7-8天）2、文件上传（7-8天）3、其他漏洞（14-15
  • Python: Python 多版本管理 mikes zhang pythonpython大数据pip
    PythonLauncherPythonLauncher是PythonforWindows才有的功能.(注一)PythonLauncher的出现,让我们可以不必依赖环境变数PATH的设定来简化python执行档的使用,同时也简化了多个版本的python同时存在时的管理工作.(试想如果你的系统里安装3或4个python时,你到底要如何指定使用其中一个版本?)PythonLauncherpy.exe是
  • 强大的销售团队背后 竟然是大数据分析的身影 蓝儿唯美 数据分析
    Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。 大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
  • Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡keepalivedhaproxy高可用
    我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过 服务器资源 10.7
  • eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
    使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
  • 基础篇--resources资源 不懂事的小屁孩 android
    最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml    字符串资源   涉及国际化问题  http://www.2cto.com/kf/201302/190394.html   string-array
  • 接上篇补上window平台自动上传证书文件的批处理问卷 酷的飞上天空 window
    @echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
  • 企业物联网大潮涌动：如何做好准备？ 蓝儿唯美 企业
    物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。 尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
  • spring学习——数据库（mybatis持久化框架配置） a-john mybatis
    Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
  • Java静态代理、动态代理实例 aijuans Java静态代理
    采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。 按照代理类的创建时期，可以分为：静态代理和动态代理。 所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。 所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。   一、静态代理类实例： 1、Serivce.ja
  • Struts1与Struts2的12点区别 asia007 Struts1与Struts2
    1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
  • 初学者要多看看帮助文档 不要用js来写Jquery的代码 百合不是茶 jqueryjs
    解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;   1, JQuery的赋值  有问题    代码如下: data.username 表示的是:  网易            $("#use
  • 经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
            产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
  • 如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenutreeRichfaces
    组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
  • 【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
    开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
  • JSONObject转换JSON--将Date转换为指定格式 白糖_ JSONObject
    项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：   {"nanos":0,"time":-27076233600000,
  • JavaScript语言精粹读书笔记 braveCS JavaScript
    【经典用法】：   //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
  • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出 bylijinnan 编程之美
    import java.util.LinkedList; public class FindInteger { /** * 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
  • 读书笔记 chengxuyuancsdn 读书笔记
    1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
  • [通讯与电力]光网城市建设的一些问题 comsci 问题
          信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系       我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........     
  • oracle 空间RESUMABLE daizj oracle空间不足RESUMABLE错误挂起
    空间RESUMABLE操作  转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。 这一篇简单介绍空间RESUMABLE的例子。 第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
  • 重构第一次写的线程池 dieslrae 线程池 python
    最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
  • C语言学习六指针 dcj3sjt126com c
    初识指针，简单示例程序： /* 指针就是地址，地址就是指针 地址就是内存单元的编号 指针变量是存放地址的变量 指针和指针变量是两个不同的概念 但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
  • yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
    public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }  
  • timertask shuizhaosi888 timertask
    java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
  • Spring Security（13）——session管理 234390216 sessionSpring Security攻击保护超时
    session管理 目录   1.1     检测session超时 1.2     concurrency-control 1.3     session 固定攻击保护         
  • 公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodbsessionnodejs
        http://www.upopen.cn   一、前言         书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
  • pojo.vo.po.domain区别 LiaoJuncai javaVOPOJOjavabeandomain
    　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。 　　 　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
  • Windows Error Code OhMyCC windows
    0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
  • 在storm集群环境下发布Topology roadrunners 集群stormtopologyspoutbolt
    storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。   1、打包 打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
  • 为什么不允许代码里出现“魔数” tomcat_oracle java
    　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
  • zoj 3511 Cake Robbery(线段树) 阿尔萨斯 线段树
    题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。 解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他