mn: append
ms: append(x)
md: same as list[len(s):len(s)] = [x]
type: method
pt: list
mn: extend
ms: extend(x)
md: same as list[len(s):len(s)] = x
type: method
pt: list
mn: count
ms: count(x)
md: return number of i values such that list[i] == x
type: method
pt: list
mn: index
ms: index(x[, i[, j]])
md: return smallest k such that list[k] == x and i <= k < j
type: method
pt: list
mn: insert
ms: insert(i, x)
md: same as list[i:i] = [x]
type: method
pt: list
mn: pop
ms: pop([i])
md: same as x = list[i]; del list[i]; return x
type: method
pt: list
mn: remove
ms: remove(x)
md: same as del list[list.index(x)]
type: method
pt: list
mn: reverse
ms: reverse()
md: reverses the items of s in place
type: method
pt: list
mn: sort
ms: sort([cmp[, key[, reverse]]])
md: sort the items of list in place
type: method
pt: list
mn: clear
ms: clear()
md: remove all items
type: method
pt: dict
mn: copy
ms: copy()
md: a shallow copy
type: method
pt: dict
mn: get
ms: get(k[, x])
md: a[k] if k in a, else x 
type: method
pt: dict
mn: has_key
ms: has_key(k)
md: 
type: method
pt: dict
mn: items
ms: items()
md: a copy of dict's list of (key, value) pairs
type: method
pt: dict
mn: iteritems
ms: iteritems()
md: return an iterator over (key, value) pairs
type: method
pt: dict
mn: iterkeys
ms: iterkeys()
md: return an iterator over the mapping's keys
type: method
pt: dict
mn: itervalues
ms: itervalues()
md: return an iterator over the mapping's values
type: method
pt: dict
mn: keys
ms: keys()
md: a copy of dicts list of keys
type: method
pt: dict
mn: pop
ms: pop(k[, x])
md: if k in a, else x (and remove k)
type: method
pt: dict
mn: popitem
ms: popitem()
md: remove and return an arbitrary (key, value) pair
type: method
pt: dict
mn: setdefault
ms: setdefault(k[, x])
md: a[k] if k in a, else x (also setting it)
type: method
pt: dict
mn: update
ms: update([b])
md: updates dict with key/value pairs from b, overwriting existing keys, returns None
type: method
pt: dict
mn: values
ms: values()
md: a copy of dicts list of values
type: method
pt: dict
mn: copy
ms: copy()
md: new set with a shallow copy of s
type: method
pt: frozenset
mn: difference
ms: difference(t)
md: new set with elements in set but not in t
type: method
pt: frozenset
mn: intersection
ms: intersection(t)
md: new set with elements common to set and t
type: method
pt: frozenset
mn: issubset
ms: issubset(t)
md: test whether every element in set is in t
type: method
pt: frozenset
mn: issuperset
ms: issuperset(t)
md: test whether every element in t is in set
type: method
pt: frozenset
mn: symmetric_difference
ms: symmetric_difference(t)
md: new set with elements in either set or t but not both
type: method
pt: frozenset
mn: union
ms: union(t)
md: new set with elements from both set and t
type: method
pt: frozenset
mn: add
ms: add(x)
md: add element x to set
type: method
pt: set
mn: clear
ms: clear()
md: remove all elements from set
type: method
pt: set
mn: copy
ms: copy()
md: new set with a shallow copy of s
type: method
pt: set
mn: difference
ms: difference(t)
md: new set with elements in set but not in t
type: method
pt: set
mn: difference_update
ms: difference_update(t)
md: update set, removing elements found in t
type: method
pt: set
mn: discard
ms: discard(x)
md: removes x from set if present
type: method
pt: set
mn: intersection
ms: intersection(t)
md: new set with elements common to set and t
type: method
pt: set
mn: intersection_update
ms: intersection_update(t)
md: update set, keeping only elements found in both set and t
type: method
pt: set
mn: issubset
ms: issubset(t)
md: test whether every element in set is in t
type: method
pt: set
mn: issuperset
ms: issuperset(t)
md: test whether every element in t is in set
type: method
pt: set
mn: pop
ms: pop()
md: remove and return an arbitrary element from set; raises KeyError if empty
type: method
pt: set
mn: remove
ms: remove(x)
md: remove x from set; raises KeyError if not present
type: method
pt: set
mn: symmetric_difference
ms: symmetric_difference(t)
md: new set with elements in either set or t but not both
type: method
pt: set
mn: symmetric_difference_update
ms: symmetric_difference_update(t)
md: update set, keeping only elements found in either s or t but not in both
type: method
pt: set
mn: union
ms: union(t)
md: new set with elements from both set and t
type: method
pt: set
mn: update
ms: update(t)
md: update set, adding elements from t
type: method
pt: set
mn: abs
ms: abs(x)
md: Return the absolute value of a number. The argument may be a plain or long integer or a floating point number. If the argument is a complex number, its magnitude is returned.
type: function
pt: Built-in Functions
mn: all
ms: all(iterable)
md: Return True if all elements of the iterable are true. 
type: function
pt: Built-in Functions
mn: any
ms: any(iterable)
md: Return True if any element of the iterable is true.
type: function
pt: Built-in Functions
mn: basestring
ms: basestring()
md: This abstract type is the superclass for str and unicode. It cannot be called or instantiated, but it can be used to test whether an object is an instance of str or unicode. isinstance(obj, basestring) is equivalent to isinstance(obj, (str, unicode)). 
type: function
pt: Built-in Functions
mn: bool
ms: bool([x])
md: Convert a value to a Boolean, using the standard truth testing procedure. If x is false or omitted, this returns False; otherwise it returns True. bool is also a class, which is a subclass of int. Class bool cannot be subclassed further. Its only instances are False and True.
type: function
pt: Built-in Functions
mn: callable
ms: callable(object)
md: Return true if the object argument appears callable, false if not. If this returns true, it is still possible that a call fails, but if it is false, calling object will never succeed. Note that classes are callable (calling a class returns a new instance); class instances are callable if they have a __call__() method.
type: function
pt: Built-in Functions
mn: chr 
ms: chr(i)
md: Return a string of one character whose ASCII code is the integer i. For example, chr(97) returns the string 'a'. This is the inverse of ord(). The argument must be in the range [0..255], inclusive; ValueError will be raised if i is outside that range.
type: function
pt: Built-in Functions
mn: classmethod
ms: classmethod(function)
md: Return a class method for function.
type: function
pt: Built-in Functions
mn: cmp 
ms: cmp(x, y)
md: Compare the two objects x and y and return an integer according to the outcome. The return value is negative if x < y, zero if x == y and strictly positive if x > y.
type: function
pt: Built-in Functions
mn: compile
ms: compile(string, filename, kind[, flags[, dont_inherit]])
md: Compile the string into a code object. 
type: function
pt: Built-in Functions
mn: complex
ms: complex([real[, imag]])
md: Create a complex number with the value real + imag*j or convert a string or number to a complex number.
type: function
pt: Built-in Functions
mn: delattr
ms: delattr(object, name)
md: This is a relative of setattr(). The arguments are an object and a string. The string must be the name of one of the object's attributes. The function deletes the named attribute, provided the object allows it. For example, delattr(x, 'foobar') is equivalent to del x.foobar.
type: function
pt: Built-in Functions
mn: dict
ms: dict([arg])
md: Return a new dictionary initialized from an optional positional argument or from a set of keyword arguments. If no arguments are given, return a new empty dictionary. If the positional argument arg is a mapping object, return a dictionary mapping the same keys to the same values as does the mapping object. Otherwise the positional argument must be a sequence, a container that supports iteration, or an iterator object. The elements of the argument must each also be of one of those kinds, and each must in turn contain exactly two objects. The first is used as a key in the new dictionary, and the second as the key's value. If a given key is seen more than once, the last value associated with it is retained in the new dictionary.
type: function
pt: Built-in Functions
mn: dir
ms: dir([object])
md: Without arguments, return the list of names in the current local symbol table. With an argument, attempts to return a list of valid attributes for that object.
type: function
pt: Built-in Functions
mn: divmod
ms: divmod(a, b)
md: Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using long division. 
type: function
pt: Built-in Functions
mn: enumerate
ms: enumerate(iterable)
md: Return an enumerate object. iterable must be a sequence, an iterator, or some other object which supports iteration. 
type: function
pt: Built-in Functions
mn: eval
ms: eval(expression[, globals[, locals]])
md: The arguments are a string and optional globals and locals. If provided, globals must be a dictionary. If provided, locals can be any mapping object. 
type: function
pt: Built-in Functions
mn: execfile
ms: execfile(filename[, globals[, locals]])
md: Similar to exec, but parses a file instead of a string
type: function
pt: Built-in Functions
mn: file
ms: file(filename[, mode[, bufsize]])
md: Constructor function for the file type. When opening a file, it's preferable to use open() instead of invoking this constructor directly.
type: function
pt: Built-in Functions
mn: filter
ms: filter(function, iterable)
md: Construct a list from those elements of iterable for which function returns true.
type: function
pt: Built-in Functions
mn: float
ms: float([x])
md: Convert a string or a number to floating point. 
type: function
pt: Built-in Functions
mn: frozenset
ms: frozenset([iterable])
md: Return a frozenset object whose elements are taken from iterable.
type: function
pt: Built-in Functions
mn: getattr
ms: getattr(object, name[, default])
md: Return the value of the named attributed of object. name must be a string.
type: function
pt: Built-in Functions
mn: globals
ms: globals()
md: Return a dictionary representing the current global symbol table. 
type: function
pt: Built-in Functions
mn: hasattr
ms: hasattr(object, name)
md: The result is True if the string is the name of one of the object's attributes, False if not.
type: function
pt: Built-in Functions
mn: hash
ms: hash(object)
md: Return the hash value of the object (if it has one). 
type: function
pt: Built-in Functions
mn: help
ms: help([object])
md: Invoke the built-in help system. 
type: function
pt: Built-in Functions
mn: hex
ms: hex(x)
md: Convert an integer number (of any size) to a hexadecimal string. 
type: function
pt: Built-in Functions
mn: id
ms: id(object)
md: Return the ``identity'' of an object. 
type: function
pt: Built-in Functions
mn: input
ms: input([prompt])
md: Equivalent to eval(raw_input(prompt)).
type: function
pt: Built-in Functions
mn: int
ms: int([x[, radix]])
md: Convert a string or number to a plain integer.
type: function
pt: Built-in Functions
mn: isinstance
ms: isinstance(object, classinfo)
md: Return true if the object argument is an instance of the classinfo argument, or of a (direct or indirect) subclass thereof.
type: function
pt: Built-in Functions
mn: issubclass
ms: issubclass(class, classinfo)
md: Return true if class is a subclass (direct or indirect) of classinfo.
type: function
pt: Built-in Functions
mn: iter
ms: iter(o[, sentinel])
md: Return an iterator object. 
type: function
pt: Built-in Functions
mn: len
ms: len(s)
md: Return the length (the number of items) of an object.
type: function
pt: Built-in Functions
mn: list
ms: list([iterable])
md: Return a list whose items are the same and in the same order as iterable's items. 
type: function
pt: Built-in Functions
mn: locals
ms: locals()
md: Update and return a dictionary representing the current local symbol table.
type: function
pt: Built-in Functions
mn: long 
ms: long([x[, radix]])
md: Convert a string or number to a long integer.
type: function
pt: Built-in Functions
mn: map
ms: map(function, iterable, ...)
md: Apply function to every item of iterable and return a list of the results.
type: function
pt: Built-in Functions
mn: max
ms: max(iterable[, args...][key])
md: With a single argument iterable, return the largest item of a non-empty iterable (such as a string, tuple or list). With more than one argument, return the largest of the arguments.
type: function
pt: Built-in Functions
mn: min 
ms: min(iterable[, args...][key])
md: With a single argument iterable, return the smallest item of a non-empty iterable (such as a string, tuple or list). With more than one argument, return the smallest of the arguments.
type: function
pt: Built-in Functions
mn: object
ms: object()
md: Return a new featureless object.
type: function
pt: Built-in Functions
mn: oct
ms: oct(x)
md: Convert an integer number (of any size) to an octal string.
type: function
pt: Built-in Functions
mn: open 
ms: open(filename[, mode[, bufsize]])
md: Open a file, returning an object of the file type.
type: function
pt: Built-in Functions
mn: ord
ms: ord(c)
md: Given a string of length one, return an integer representing the Unicode code point of the character when the argument is a unicode object, or the value of the byte when the argument is an 8-bit string.
type: function
pt: Built-in Functions
mn: pow
ms: pow(x, y[, z])
md: Return x to the power y; if z is present, return x to the power y, modulo z
type: function
pt: Built-in Functions
mn: property
ms: property([fget[, fset[, fdel[, doc]]]])
md: Return a property attribute for new-style classes (classes that derive from object).
type: function
pt: Built-in Functions
mn: range
ms: range([start,] stop[, step])
md: Create lists containing arithmetic progressions. 
type: function
pt: Built-in Functions
mn: raw_input
ms: raw_input([prompt])
md: If the prompt argument is present, it is written to standard output without a trailing newline. The function then reads a line from input, converts it to a string (stripping a trailing newline), and returns that. When EOF is read, EOFError is raised.
type: function
pt: Built-in Functions
mn: reduce
ms: reduce(function, iterable[, initializer])
md: Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value.
type: function
pt: Built-in Functions
mn: reload
ms: reload(module)
md: Reload a previously imported module.
type: function
pt: Built-in Functions
mn: repr
ms: repr(object)
md: Return a string containing a printable representation of an object.
type: function
pt: Built-in Functions
mn: reversed
ms: reversed(seq)
md: Return a reverse iterator. 
type: function
pt: Built-in Functions
mn: round
ms: round(x[, n])
md: Return the floating point value x rounded to n digits after the decimal point. If n is omitted, it defaults to zero.
type: function
pt: Built-in Functions
mn: set
ms: set([iterable])
md: Return a set whose elements are taken from iterable. The elements must be immutable.
type: function
pt: Built-in Functions
mn: setattr
ms: setattr(object, name, value)
md: This is the counterpart of getattr(). The arguments are an object, a string and an arbitrary value.
type: function
pt: Built-in Functions
mn: slice
ms: slice([start,] stop[, step])
md: Return a slice object representing the set of indices specified by range(start, stop, step).
type: function
pt: Built-in Functions
mn: sorted
ms: sorted(iterable[, cmp[, key[, reverse]]])
md: Return a new sorted list from the items in iterable.
type: function
pt: Built-in Functions
mn: staticmethod
ms: staticmethod(function)
md: Return a static method for function.
type: function
pt: Built-in Functions
mn: str
ms: str([object])
md: Return a string containing a nicely printable representation of an object.
type: function
pt: Built-in Functions
mn: sum
ms: sum(iterable[, start])
md: Sums start and the items of an iterable from left to right and returns the total.
type: function
pt: Built-in Functions
mn: super
ms: super(type[, object-or-type])
md: Return the superclass of type.
type: function
pt: Built-in Functions
mn: tuple
ms: tuple([iterable])
md: Return a tuple whose items are the same and in the same order as iterable's items.
type: function
pt: Built-in Functions
mn: type
ms: type(object)
md: Return the type of an object. The return value is a type object.
type: function
pt: Built-in Functions
mn: unichr
ms: unichr(i)
md: Return the Unicode string of one character whose Unicode code is the integer i.
type: function
pt: Built-in Functions
mn: vars
ms: vars([object])
md: Without arguments, return a dictionary corresponding to the current local symbol table. With a module, class or class instance object as argument (or anything else that has a __dict__ attribute), returns a dictionary corresponding to the object's symbol table.
type: function
pt: Built-in Functions
mn: xrange
ms: xrange([start,] stop[, step])
md: This function is very similar to range(), but returns an ``xrange object'' instead of a list.
type: function
pt: Built-in Functions
mn: zip
ms: zip([iterable, ...])
md: This function returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument sequences or iterables.
type: function
pt: Built-in Functions
mn: capwords
ms: capwords(s)
md: Split the argument into words using split(), capitalize each word using capitalize(), and join the capitalized words using join().
type: function
pt: string
mn: maketrans
ms: maketrans(from,to)
md: Return a translation table suitable for passing to translate(), that will map each character in from into the character at the same position in to; from and to must have the same length.
type: function
pt: string
mn: atof
ms: atof(s)
md: Deprecated since release 2.0. Use the float() built-in function.
type: function
pt: string
mn: atoi
ms: atoi(s[,base])
md: Deprecated since release 2.0. Use the int() built-in function.
type: function
pt: string
mn: atol
ms: atol(s[,base])
md: Deprecated since release 2.0. Use the long() built-in function.
type: function
pt: string
mn: capitalize
ms: capitalize()
md: Return a copy of the string with only its first character capitalized.
type: method
pt: string
mn: center
ms: center(width[, fillchar])
md: Return centered in a string of length width. Padding is done using the specified fillchar (default is a space). 
type: method
pt: string
mn: count
ms: count(sub[, start[, end]])
md: Return the number of occurrences of substring sub in string S[start:end]. Optional arguments start and end are interpreted as in slice notation.
type: method
pt: string
mn: decode
ms: decode([encoding[, errors]])
md: Decodes the string using the codec registered for encoding.
type: method
pt: string
mn: encode
ms: encode([encoding[,errors]])
md: Return an encoded version of the string. 
type: method
pt: string
mn: endsWith
ms: endswith(suffix[, start[, end]])
md: Return True if the string ends with the specified suffix, otherwise return False.
type: method
pt: string
mn: expandtabs
ms: expandtabs([tabsize])
md: Return a copy of the string where all tab characters are expanded using spaces.
type: method
pt: string
mn: find
ms: find(sub[, start[, end]])
md: Return the lowest index in the string where substring sub is found, such that sub is contained in the range [start, end]. Optional arguments start and end are interpreted as in slice notation. Return -1 if sub is not found.
type: method
pt: string
mn: index
ms: index(sub[, start[, end]])
md: Like find(), but raise ValueError when the substring is not found.
type: method
pt: string
mn: isalnum
ms: isalnum()
md: Return true if all characters in the string are alphanumeric and there is at least one character, false otherwise.
type: method
pt: string
mn: isalpha
ms: isalpha()
md: Return true if all characters in the string are alphabetic and there is at least one character, false otherwise.
type: method
pt: string
mn: isdigit
ms: isdigit()
md: Return true if all characters in the string are digits and there is at least one character, false otherwise.
type: method 
pt: string
mn: isLower
ms: islower()
md: Return true if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.
type: method
pt: string
mn: isspace
ms: isspace()
md: Return true if there are only whitespace characters in the string and there is at least one character, false otherwise.
type: method
pt: string
mn: istitle
ms: istitle()
md: Return true if the string is a titlecased string and there is at least one character, for example uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return false otherwise.
type: method
pt: string
mn: isupper
ms: isupper()
md: Return true if all cased characters in the string are uppercase and there is at least one cased character, false otherwise.
type: method
pt: string
mn: join
ms: join(seq)
md: Return a string which is the concatenation of the strings in the sequence seq. The separator between elements is the string providing this method.
type: method
pt: string
mn: ljust
ms: ljust(width[, fillchar])
md: Return the string left justified in a string of length width. Padding is done using the specified fillchar (default is a space). The original string is returned if width is less than len(s). 
type: method
pt: string
mn: lower
ms: lower()
md: Return a copy of the string converted to lowercase.
type: method
pt: string
mn: lstrip
ms: lstrip([chars])
md: Return a copy of the string with leading characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a prefix; rather, all combinations of its values are stripped.
type: method
pt: string
mn: partition
ms: partition(sep)
md: Split the string at the first occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing the string itself, followed by two empty strings. 
type: method
pt: string
mn: replace
ms: replace(old, new[, count])
md: Return a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.
type: method
pt: string
mn: rfind
ms: rfind(sub [,start [,end]])
md: Return the highest index in the string where substring sub is found, such that sub is contained within s[start,end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure.
type: method
pt: string
mn: rindex
ms: rindex(sub[, start[, end]])
md: Like rfind() but raises ValueError when the substring sub is not found.
type: method
pt: string
mn: rjust
ms: rjust(width[, fillchar])
md: Return the string right justified in a string of length width. Padding is done using the specified fillchar (default is a space). The original string is returned if width is less than len(s). 
type: method
pt: string
mn: rpartition
ms: rpartition(sep)
md: Split the string at the last occurrence of sep, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return a 3-tuple containing two empty strings, followed by the string itself. 
type: method
pt: string
mn: rsplit
ms: rsplit([sep [,maxsplit]])
md: Return a list of the words in the string, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done, the rightmost ones. If sep is not specified or None, any whitespace string is a separator. Except for splitting from the right, rsplit() behaves like split() which is described in detail below. 
type: method
pt: string
mn: rstrip
ms: rstrip([chars])
md: Return a copy of the string with trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a suffix; rather, all combinations of its values are stripped:
type: method
pt: string
mn: split
ms: split([sep [,maxsplit]])
md: Return a list of the words in the string, using sep as the delimiter string.
type: method
pt: string
mn: splitlines
ms: splitlines([keepends])
md: Return a list of the lines in the string, breaking at line boundaries. Line breaks are not included in the resulting list unless keepends is given and true.
type: method
pt: string
mn: startswith
ms: startswith(prefix[, start[, end]])
md: Return True if string starts with the prefix, otherwise return False.
type: method
pt: string
mn: strip
ms: strip([chars])
md: Return a copy of the string with the leading and trailing characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped.
type: method
pt: string
mn: swapcase
ms: swapcase()
md: Return a copy of the string with uppercase characters converted to lowercase and vice versa.
type: method
pt: string
mn: title
ms: title()
md: Return a titlecased version of the string: words start with uppercase characters, all remaining cased characters are lowercase.
type: method
pt: string
mn: translate
ms: translate(table[, deletechars])
md: Return a copy of the string where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a string of length 256.
type: method
pt: string
mn: upper
ms: upper()
md: Return a copy of the string converted to uppercase.
type: method
pt: string
mn: zfill
ms: zfill(width)
md: Return the numeric string left filled with zeros in a string of length width. The original string is returned if width is less than len(s). 
type: method
pt: string
mn: close
ms: close()
md: Close the file.
type: method
pt: file
mn: flush
ms: flush()
md: Flush the internal buffer.
type: method
pt: file
mn: fileno
ms: fileno()
md: Return the integer ``file descriptor'' that is used by the underlying implementation to request I/O operations from the operating system.
type: method
pt: file
mn: isatty
ms: isatty()
md: Return True if the file is connected to a tty(-like) device, else False.
type: method
pt: file
mn: next
ms: next()
md: This method returns the next input line, or raises StopIteration when EOF is hit when the file is open for reading (behavior is undefined when the file is open for writing).
type: method
pt: file
mn: read
ms: read()
md: Read at most size bytes from the file (less if the read hits EOF before obtaining size bytes). If the size argument is negative or omitted, read all data until EOF is reached.
type: method
pt: file
mn: readline
ms: readline([size])
md: Read one entire line from the file.
type: method
pt: file
mn: readlines
ms: readlines([sizehint])
md: Read until EOF using readline() and return a list containing the lines thus read.
type: method
pt: file
mn: xreadlines
ms: xreadlines()
md: This method returns the same thing as iter(f). 
type: method
pt: file
mn: seek
ms: seek(offset[,whence])
md: Set the file's current position.
type: method
pt: file
mn: tell
ms: tell()
md: Return the file's current position.
type: method
pt: file
mn: truncate
ms: truncate([size])
md: Truncate the file's size. If the optional size argument is present, the file is truncated to (at most) that size.
type: method
pt: file
mn: write
ms: write(str)
md: Write a string to the file. 
type: method
pt: file
mn: writelines
ms: writelines(sequence)
md: Write a sequence of strings to the file. The sequence can be any iterable object producing strings, typically a list of strings.
type: method
pt: file
mn: api_version
ms: 
md: The C API version for this interpreter. 
type: function
pt: sys
mn: argv
ms: 
md: The list of command line arguments passed to a Python script.
type: function
pt: sys
mn: byteorder
ms: 
md: An indicator of the native byte order.
type: function
pt: sys
mn: subversion
ms: 
md: A triple (repo, branch, version) representing the Subversion information of the Python interpreter.
type: function
pt: sys
mn: builtin_module_names
ms: 
md: A tuple of strings giving the names of all modules that are compiled into this Python interpreter. 
type: function
pt: sys
mn: copyright
ms: 
md: A string containing the copyright pertaining to the Python interpreter.
type: function
pt: sys
mn: _current_frames
ms: _current_frames()
md: Return a dictionary mapping each thread's identifier to the topmost stack frame currently active in that thread at the time the function is called.
type: function
pt: sys
mn: dllhandle
ms: 
md: Integer specifying the handle of the Python DLL.
type: function
pt: sys
mn: displayhook
ms: displayhook(value)
md: If value is not None, this function prints it to sys.stdout, and saves it in __builtin__._.
type: function
pt: sys
mn: excepthook
ms: excepthook(type, value, traceback)
md: This function prints out a given traceback and exception to sys.stderr.
type: function
pt: sys
mn: exc_info
ms: exc_info()
md: This function returns a tuple of three values that give information about the exception that is currently being handled.
type: function
pt: sys
mn: exc_clear
ms: exc_clear()
md: This function clears all information relating to the current or last exception that occurred in the current thread.
type: function
pt: sys
mn: exec_prefix
ms: 
md: A string giving the site-specific directory prefix where the platform-dependent Python files are installed.
type: function
pt: sys
mn: executable
ms: 
md: A string giving the name of the executable binary for the Python interpreter, on systems where this makes sense.
type: function
pt: sys
mn: exit
ms: exit([arg])
md: Exit from Python.
type: function
pt: sys
mn: exitfunc
ms: 
md: This function will be called when the interpreter exits.
type: function
pt: sys
mn: getcheckinterval
ms: getcheckinterval()
md: Return the interpreter's ``check interval''.
type: function
pt: sys
mn: getdefaultencoding
ms: getdefaultencoding()
md: Return the name of the current default string encoding used by the Unicode implementation. 
type: function
pt: sys
mn: getdlopenflags
ms: getdlopenflags()
md: Return the current value of the flags that are used for dlopen() calls.
type: function
pt: sys
mn: getfilesystemencoding
ms: getfilesystemencoding()
md: Return the name of the encoding used to convert Unicode filenames into system file names, or None if the system default encoding is used. 
type: function
pt: sys
mn: getrefcount
ms: getrefcount(object)
md: Return the reference count of the object. 
type: function
pt: sys
mn: getrecursionlimit
ms: getrecursionlimit()
md: Return the current value of the recursion limit, the maximum depth of the Python interpreter stack.
type: function
pt: sys
mn: _getframe
ms: _getframe([depth])
md: Return a frame object from the call stack.
type: function
pt: sys
mn: getwindowsversion
ms: getwindowsversion()
md: Return a tuple containing five components, describing the Windows version currently running.
type: function
pt: sys
mn: hexversion
ms: 
md: The version number encoded as a single integer.
type: function
pt: sys
mn: maxint
ms: 
md: The largest positive integer supported by Python's regular integer type. 
type: function
pt: sys
mn: maxunicode
ms: 
md: An integer giving the largest supported code point for a Unicode character. 
type: function
pt: sys
mn: modules
ms: 
md: This is a dictionary that maps module names to modules which have already been loaded.
type: function
pt: sys
mn: path
ms: 
md: A list of strings that specifies the search path for modules.
type: function
pt: sys
mn: platform
ms: 
md: This string contains a platform identifier.
type: function
pt: sys
mn: prefix
ms: 
md: A string giving the site-specific directory prefix where the platform independent Python files are installed.
type: function
pt: sys
mn: ps1
ms: 
md: The primary prompt of the interpreter.
type: function
pt: sys
mn: ps2
ms: 
md: The secondary prompt of the interpreter
type: function
pt: sys
mn: setcheckinterval
ms: setcheckinterval(interval)
md: Set the interpreter's ``check interval''.
type: function
pt: sys
mn: setdefaultencoding
ms: setdefaultencoding(name)
md: Set the current default string encoding used by the Unicode implementation. 
type: function
pt: sys
mn: setdlopenflags
ms: setdlopenflags(n)
md: Set the flags used by the interpreter for dlopen() calls.
type: function
pt: sys
mn: setprofile
ms: setprofile(profilefunc)
md: Set the system's profile function, which allows you to implement a Python source code profiler in Python.
type: function
pt: sys
mn: setrecursionlimit
ms: setrecursionlimit(limit)
md: Set the maximum depth of the Python interpreter stack to limit.
type: function
pt: sys
mn: settrace
ms: settrace(tracefunc)
md: Set the system's trace function, which allows you to implement a Python source code debugger in Python.
type: function
pt: sys
mn: settscdump
ms: settscdump(on_flag)
md: Activate dumping of VM measurements using the Pentium timestamp counter, if on_flag is true. Deactivate these dumps if on_flag is off.
type: function
pt: sys
mn: stdin
ms: 
md: standard input stream
type: function
pt: sys
mn: stdout
ms: 
md: standard output stream
type: function
pt: sys
mn: stderr
ms: 
md: standard error stream
type: function
pt: sys
mn: tracebacklimit
ms: 
md: Determines the maximum number of levels of traceback information printed when an unhandled exception occurs. 
type: function
pt: sys
mn: version
ms: 
md: A string containing the version number of the Python interpreter plus additional information on the build number and compiler used.
type: function
pt: sys
mn: version_info
ms: 
md: A tuple containing the five components of the version number: major, minor, micro, releaselevel, and serial.
type: function
pt: sys
mn: warnoptions
ms: 
md: This is an implementation detail of the warnings framework; do not modify this value.
type: function
pt: sys
mn: winver
ms: 
md: The version number used to form registry keys on Windows platforms. 
type: function
pt: sys
mn: open
ms: open(file[, mode])
md: Open an AIFF or AIFF-C file and return an object instance with methods that are described below.
type: function
pt: aifc
mn: getnchannels
ms: getnchannels()
md: Return the number of audio channels (1 for mono, 2 for stereo).
type: method
pt: aifc
mn: getsampwidth
ms: getsampwidth()
md: Return the size in bytes of individual samples.
type: method
pt: aifc
mn: getframerate
ms: getframerate()
md: Return the sampling rate (number of audio frames per second).
type: method
pt: aifc
mn: getnframes
ms: getnframes()
md: Return the number of audio frames in the file.
type: method
pt: aifc
mn: getcomptype
ms: getcomptype()
md: Return a four-character string describing the type of compression used in the audio file.
type: method
pt: aifc
mn: getcompname
ms: getcompname()
md: Return a human-readable description of the type of compression used in the audio file.
type: method
pt: aifc
mn: getparams
ms: getparams()
md: Return a tuple consisting of all of the above values in the above order.
type: method
pt: aifc
mn: getmarkers
ms: getmarkers()
md: Return a list of markers in the audio file.
type: method
pt: aifc
mn: getmark
ms: getmark(id)
md: Return the tuple as described in getmarkers() for the mark with the given id.
type: method
pt: aifc
mn: readframes
ms: readframes(nframes)
md: Read and return the next nframes frames from the audio file.
type: method
pt: aifc
mn: rewind
ms: rewind()
md: Rewind the read pointer.
type: method
pt: aifc
mn: setpos
ms: setpos(pos)
md: Seek to the specified frame number.
type: method
pt: aifc
mn: tell
ms: tell()
md: Return the current frame number.
type: method
pt: aifc
mn: close
ms: close()
md: Close the AIFF file.
type: method
pt: aifc
mn: aiff
ms: aiff()
md: Create an AIFF file.
type: method
pt: aifc
mn: aifc
ms: aifc()
md: Create an AIFF-C file.
type: method
pt: aifc
mn: setnchannels
ms: setnchannels(nchannels)
md: Specify the number of channels in the audio file.
type: method
pt: aifc
mn: setsampwidth
ms: setsampwidth(width)
md: Specify the size in bytes of audio samples.
type: method
pt: aifc
mn: setframerate
ms: setframerate(rate)
md: Specify the sampling frequency in frames per second.
type: method
pt: aifc
mn: setnframes
ms: setnframes(nframes)
md: Specify the number of frames that are to be written to the audio file.
type: method
pt: aifc
mn: setcomptype
ms: setcomptype(type, name)
md: Specify the compression type.
type: method
pt: aifc
mn: setparams
ms: setparams(nchannels, sampwidth, framerate, comptype, compname)
md: Set all the above parameters at once.
type: method
pt: aifc
mn: setmark
ms: setmark(id, pos, name)
md: Add a mark with the given id (larger than 0), and the given name at the given position.
type: method
pt: aifc
mn: writeframes
ms: writeframes(data)
md: Write data to the output file.
type: method
pt: aifc
mn: writeframesraw
ms: writeframesraw(data)
md: Like writeframes(), except that the header of the audio file is not updated.
type: method
pt: aifc
mn: open
ms: open(filename[, flag[, mode]])
md: Open the database file filename and return a corresponding object.
type: function
pt: anydbm
mn: array
ms: array(typecode[, initializer])
md: Return a new array whose items are restricted by typecode, and initialized from the optional initializer value, which must be a list, string, or iterable over elements of the appropriate type.
type: function
pt: array
mn: append
ms: append(x)
md: Append a new item with value x to the end of the array.
type: method
pt: array
mn: buffer_info
ms: buffer_info()
md: Return a tuple (address, length) giving the current memory address and the length in elements of the buffer used to hold array's contents.
type: method
pt: array
mn: byteswap
ms: byteswap()
md: ``Byteswap'' all items of the array.
type: method
pt: array
mn: count
ms: count(x)
md: Return the number of occurrences of x in the array.
type: method
pt: array
mn: extend
ms: extend(iterable)
md: Append items from iterable to the end of the array.
type: method
pt: array
mn: fromfile
ms: fromfile(f, n)
md: Read n items (as machine values) from the file object f and append them to the end of the array.
type: method
pt: array
mn: fromlist
ms: fromlist(list)
md: Append items from the list.
type: method
pt: array
mn: fromstring
ms: fromstring(s)
md: Appends items from the string, interpreting the string as an array of machine values (as if it had been read from a file using the fromfile() method).
type: method
pt: array
mn: fromunicode
ms: fromunicode(s)
md: Extends this array with data from the given unicode string.
type: method
pt: array
mn: index
ms: index(x)
md: Return the smallest i such that i is the index of the first occurrence of x in the array.
type: method
pt: array
mn: insert
ms: insert(i, x)
md: Insert a new item with value x in the array before position i.
type: method
pt: array
mn: pop
ms: pop([i])
md: Removes the item with the index i from the array and returns it.
type: method
pt: array
mn: read
ms: read(f, n)
md: Deprecated since release 1.
type: method
pt: array
mn: remove
ms: remove(x)
md: Remove the first occurrence of x from the array.
type: method
pt: array
mn: reverse
ms: reverse()
md: Reverse the order of the items in the array.
type: method
pt: array
mn: tofile
ms: tofile(f)
md: Write all items (as machine values) to the file object f.
type: method
pt: array
mn: tolist
ms: tolist()
md: Convert the array to an ordinary list with the same items.
type: method
pt: array
mn: tostring
ms: tostring()
md: Convert the array to an array of machine values and return the string representation (the same sequence of bytes that would be written to a file by the tofile() method.
type: method
pt: array
mn: tounicode
ms: tounicode()
md: Convert the array to a unicode string.
type: method
pt: array
mn: write
ms: write(f)
md: Deprecated since release 1.
type: method
pt: array
mn: itemsize
ms: itemsize
md: Return a new array whose items are restricted by typecode, and initialized from the optional initializer value, which must be a list, string, or iterable over elements of the appropriate type.
type: member
pt: array
mn: typecode
ms: typecode
md: The typecode character used to create the array.
type: member
pt: array
mn: close_when_done
ms: close_when_done()
md: Pushes a None on to the producer fifo.
type: method
pt: asynchat
mn: collect_incoming_data
ms: collect_incoming_data(data)
md: Called with data holding an arbitrary amount of received data.
type: method
pt: asynchat
mn: discard_buffers
ms: discard_buffers()
md: In emergencies this method will discard any data held in the input and/or   output buffers and the producer fifo.
type: method
pt: asynchat
mn: found_terminator
ms: found_terminator()
md: Called when the incoming data stream  matches the termination condition   set by set_terminator.
type: method
pt: asynchat
mn: get_terminator
ms: get_terminator()
md: Returns the current terminator for the channel.
type: method
pt: asynchat
mn: handle_close
ms: handle_close()
md: Called when the channel is closed.
type: method
pt: asynchat
mn: handle_read
ms: handle_read()
md: Called when a read event fires on the channel's socket in the   asynchronous loop.
type: method
pt: asynchat
mn: handle_write
ms: handle_write()
md: Called when the application may write data to the channel.
type: method
pt: asynchat
mn: push
ms: push(data)
md: Creates a simple_producer object (see below) containing the data and   pushes it on to the channel's producer_fifo to ensure its   transmission.
type: method
pt: asynchat
mn: push_with_producer
ms: push_with_producer(producer)
md: Takes a producer object and adds it to the producer fifo associated with   the channel.
type: method
pt: asynchat
mn: readable
ms: readable()
md: Should return True for the channel to be included in the set of   channels tested by the select() loop for readability.
type: method
pt: asynchat
mn: refill_buffer
ms: refill_buffer()
md: Refills the output buffer by calling the more() method of the   producer at the head of the fifo.
type: method
pt: asynchat
mn: set_terminator
ms: set_terminator(term)
md: Sets the terminating condition to be recognised on the channel.
type: method
pt: asynchat
mn: writable
ms: writable()
md: Should return True as long as items remain on the producer fifo,   or the channel is connected and the channel's output buffer is non-empty.
type: method
pt: asynchat
mn: loop
ms: loop([timeout[, use_poll[,                       map[,count]]]])
md: Enter a polling loop that terminates after count passes or all open   channels have been closed.
type: function
pt: asyncore
mn: handle_read
ms: handle_read()
md: Called when the asynchronous loop detects that a read()   call on the channel's socket will succeed.
type: method
pt: asyncore
mn: handle_write
ms: handle_write()
md: Called when the asynchronous loop detects that a writable socket   can be written.
type: method
pt: asyncore
mn: handle_expt
ms: handle_expt()
md: Called when there is out of band (OOB) data for a socket    connection.
type: method
pt: asyncore
mn: handle_connect
ms: handle_connect()
md: Called when the active opener's socket actually makes a connection.
type: method
pt: asyncore
mn: handle_close
ms: handle_close()
md: Called when the socket is closed.
type: method
pt: asyncore
mn: handle_error
ms: handle_error()
md: Called when an exception is raised and not otherwise handled.
type: method
pt: asyncore
mn: handle_accept
ms: handle_accept()
md: Called on listening channels (passive openers) when a     connection can be established with a new remote endpoint that   has issued a connect() call for the local endpoint.
type: method
pt: asyncore
mn: readable
ms: readable()
md: Called each time around the asynchronous loop to determine whether a   channel's socket should be added to the list on which read events can   occur.
type: method
pt: asyncore
mn: writable
ms: writable()
md: Called each time around the asynchronous loop to determine whether a   channel's socket should be added to the list on which write events can   occur.
type: method
pt: asyncore
mn: create_socket
ms: create_socket(family, type)
md: This is identical to the creation of a normal socket, and    will use the same options for creation.
type: method
pt: asyncore
mn: connect
ms: connect(address)
md: As with the normal socket object, address is a    tuple with the first element the host to connect to, and the    second the port number.
type: method
pt: asyncore
mn: send
ms: send(data)
md: Send data to the remote end-point of the socket.
type: method
pt: asyncore
mn: recv
ms: recv(buffer_size)
md: Read at most buffer_size bytes from the socket's remote end-point.
type: method
pt: asyncore
mn: listen
ms: listen(backlog)
md: Listen for connections made to the socket.
type: method
pt: asyncore
mn: bind
ms: bind(address)
md: Bind the socket to address.
type: method
pt: asyncore
mn: accept
ms: accept()
md: Accept a connection.
type: method
pt: asyncore
mn: close
ms: close()
md: Close the socket.
type: method
pt: asyncore
mn: register
ms: register(func[, *args[, **kargs]])
md: Register func as a function to be executed at termination.
type: function
pt: atexit
mn: add
ms: add(fragment1, fragment2, width)
md: Return a fragment which is the addition of the two samples passed as parameters.
type: function
pt: audioop
mn: adpcm2lin
ms: adpcm2lin(adpcmfragment, width, state)
md: Decode an Intel/DVI ADPCM coded fragment to a linear fragment.
type: function
pt: audioop
mn: alaw2lin
ms: alaw2lin(fragment, width)
md: Convert sound fragments in a-LAW encoding to linearly encoded sound fragments.
type: function
pt: audioop
mn: avg
ms: avg(fragment, width)
md: Return the average over all samples in the fragment.
type: function
pt: audioop
mn: avgpp
ms: avgpp(fragment, width)
md: Return the average peak-peak value over all samples in the fragment.
type: function
pt: audioop
mn: bias
ms: bias(fragment, width, bias)
md: Return a fragment that is the original fragment with a bias added to each sample.
type: function
pt: audioop
mn: cross
ms: cross(fragment, width)
md: Return the number of zero crossings in the fragment passed as an argument.
type: function
pt: audioop
mn: findfactor
ms: findfactor(fragment, reference)
md: Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal, i.
type: function
pt: audioop
mn: findfit
ms: findfit(fragment, reference)
md: Try to match reference as well as possible to a portion of fragment (which should be the longer fragment).
type: function
pt: audioop
mn: findmax
ms: findmax(fragment, length)
md: Search fragment for a slice of length length samples (not bytes!) with maximum energy, i.
type: function
pt: audioop
mn: getsample
ms: getsample(fragment, width, index)
md: Return the value of sample index from the fragment.
type: function
pt: audioop
mn: lin2adpcm
ms: lin2adpcm(fragment, width, state)
md: Convert samples to 4 bit Intel/DVI ADPCM encoding.
type: function
pt: audioop
mn: lin2alaw
ms: lin2alaw(fragment, width)
md: Convert samples in the audio fragment to a-LAW encoding and return this as a Python string.
type: function
pt: audioop
mn: lin2lin
ms: lin2lin(fragment, width, newwidth)
md: Convert samples between 1-, 2- and 4-byte formats.
type: function
pt: audioop
mn: lin2ulaw
ms: lin2ulaw(fragment, width)
md: Convert samples in the audio fragment to u-LAW encoding and return this as a Python string.
type: function
pt: audioop
mn: minmax
ms: minmax(fragment, width)
md: Return a tuple consisting of the minimum and maximum values of all samples in the sound fragment.
type: function
pt: audioop
mn: max
ms: max(fragment, width)
md: Return the maximum of the absolute value of all samples in a fragment.
type: function
pt: audioop
mn: maxpp
ms: maxpp(fragment, width)
md: Return the maximum peak-peak value in the sound fragment.
type: function
pt: audioop
mn: mul
ms: mul(fragment, width, factor)
md: Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor.
type: function
pt: audioop
mn: ratecv
ms: ratecv(fragment, width, nchannels, inrate, outrate,                         state[, weightA[, weightB]])
md: Convert the frame rate of the input fragment.
type: function
pt: audioop
mn: reverse
ms: reverse(fragment, width)
md: Reverse the samples in a fragment and returns the modified fragment.
type: function
pt: audioop
mn: rms
ms: rms(fragment, width)
md: Return the root-mean-square of the fragment, i.
type: function
pt: audioop
mn: tomono
ms: tomono(fragment, width, lfactor, rfactor)
md: Convert a stereo fragment to a mono fragment.
type: function
pt: audioop
mn: tostereo
ms: tostereo(fragment, width, lfactor, rfactor)
md: Generate a stereo fragment from a mono fragment.
type: function
pt: audioop
mn: ulaw2lin
ms: ulaw2lin(fragment, width)
md: Convert sound fragments in u-LAW encoding to linearly encoded sound fragments.
type: function
pt: audioop
mn: b64encode
ms: b64encode(s[, altchars])
md: Encode a string use Base64.
type: function
pt: base64
mn: b64decode
ms: b64decode(s[, altchars])
md: Decode a Base64 encoded string.
type: function
pt: base64
mn: standard_b64encode
ms: standard_b64encode(s)
md: Encode string s using the standard Base64 alphabet.
type: function
pt: base64
mn: standard_b64decode
ms: standard_b64decode(s)
md: Decode string s using the standard Base64 alphabet.
type: function
pt: base64
mn: urlsafe_b64encode
ms: urlsafe_b64encode(s)
md: Encode string s using a URL-safe alphabet, which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
type: function
pt: base64
mn: urlsafe_b64decode
ms: urlsafe_b64decode(s)
md: Decode string s using a URL-safe alphabet, which substitutes - instead of + and _ instead of / in the standard Base64 alphabet.
type: function
pt: base64
mn: b32encode
ms: b32encode(s)
md: Encode a string using Base32.
type: function
pt: base64
mn: b32decode
ms: b32decode(s[, casefold[, map01]])
md: Decode a Base32 encoded string.
type: function
pt: base64
mn: b16encode
ms: b16encode(s)
md: Encode a string using Base16.
type: function
pt: base64
mn: b16decode
ms: b16decode(s[, casefold])
md: Decode a Base16 encoded string.
type: function
pt: base64
mn: decode
ms: decode(input, output)
md: Decode the contents of the input file and write the resulting binary data to the output file.
type: function
pt: base64
mn: decodestring
ms: decodestring(s)
md: Decode the string s, which must contain one or more lines of base64 encoded data, and return a string containing the resulting binary data.
type: function
pt: base64
mn: encode
ms: encode(input, output)
md: Encode the contents of the input file and write the resulting base64 encoded data to the output file.
type: function
pt: base64
mn: encodestring
ms: encodestring(s)
md: Encode the string s, which can contain arbitrary binary data, and return a string containing one or more lines of base64-encoded data.
type: function
pt: base64
mn: handle
ms: handle()
md: Calls handle_one_request() once (or, if persistent connections are enabled, multiple times) to handle incoming HTTP requests.
type: method
pt: BaseHTTPServer
mn: handle_one_request
ms: handle_one_request()
md: This method will parse and dispatch the request to the appropriate do_*() method.
type: method
pt: BaseHTTPServer
mn: send_error
ms: send_error(code[, message])
md: Sends and logs a complete error reply to the client.
type: method
pt: BaseHTTPServer
mn: send_response
ms: send_response(code[, message])
md: Sends a response header and logs the accepted request.
type: method
pt: BaseHTTPServer
mn: send_header
ms: send_header(keyword, value)
md: Writes a specific HTTP header to the output stream.
type: method
pt: BaseHTTPServer
mn: end_headers
ms: end_headers()
md: Sends a blank line, indicating the end of the HTTP headers in the response.
type: method
pt: BaseHTTPServer
mn: log_request
ms: log_request([code[, size]])
md: Logs an accepted (successful) request.
type: method
pt: BaseHTTPServer
mn: version_string
ms: version_string()
md: Returns the server software's version string.
type: method
pt: BaseHTTPServer
mn: date_time_string
ms: date_time_string([timestamp])
md: Returns the date and time given by timestamp (which must be in the format returned by time.
type: method
pt: BaseHTTPServer
mn: log_date_time_string
ms: log_date_time_string()
md: Returns the current date and time, formatted for logging.
type: method
pt: BaseHTTPServer
mn: address_string
ms: address_string()
md: Returns the client address, formatted for logging.
type: method
pt: BaseHTTPServer
mn: server_name
ms: server_name
md: This class is used to handle the HTTP requests that arrive at the server.
type: member
pt: BaseHTTPServer
mn: client_address
ms: client_address
md: Contains a tuple of the form (host, port) referring to the client's address.
type: member
pt: BaseHTTPServer
mn: command
ms: command
md: Contains the command (request type).
type: member
pt: BaseHTTPServer
mn: path
ms: path
md: Contains the request path.
type: member
pt: BaseHTTPServer
mn: request_version
ms: request_version
md: Contains the version string from the request.
type: member
pt: BaseHTTPServer
mn: headers
ms: headers
md: Holds an instance of the class specified by the MessageClass class variable.
type: member
pt: BaseHTTPServer
mn: rfile
ms: rfile
md: Contains an input stream, positioned at the start of the optional input data.
type: member
pt: BaseHTTPServer
mn: wfile
ms: wfile
md: Contains the output stream for writing a response back to the client.
type: member
pt: BaseHTTPServer
mn: server_version
ms: server_version
md: Specifies the server software version.
type: member
pt: BaseHTTPServer
mn: sys_version
ms: sys_version
md: Contains the Python system version, in a form usable by the version_string method and the server_version class variable.
type: member
pt: BaseHTTPServer
mn: error_message_format
ms: error_message_format
md: Specifies a format string for building an error response to the client.
type: member
pt: BaseHTTPServer
mn: protocol_version
ms: protocol_version
md: This specifies the HTTP protocol version used in responses.
type: member
pt: BaseHTTPServer
mn: MessageClass
ms: MessageClass
md: Specifies a rfc822.
type: member
pt: BaseHTTPServer
mn: responses
ms: responses
md: This variable contains a mapping of error code integers to two-element tuples containing a short and long message.
type: member
pt: BaseHTTPServer
mn: Bastion
ms: Bastion(object[, filter[,                          name[, class]]])
md: Protect the object object, returning a bastion for the object.
type: function
pt: Bastion
mn: a2b_uu
ms: a2b_uu(string)
md: Convert a single line of uuencoded data back to binary and return the binary data.
type: function
pt: binascii
mn: b2a_uu
ms: b2a_uu(data)
md: Convert binary data to a line of ASCII characters, the return value is the converted line, including a newline char.
type: function
pt: binascii
mn: a2b_base64
ms: a2b_base64(string)
md: Convert a block of base64 data back to binary and return the binary data.
type: function
pt: binascii
mn: b2a_base64
ms: b2a_base64(data)
md: Convert binary data to a line of ASCII characters in base64 coding.
type: function
pt: binascii
mn: a2b_qp
ms: a2b_qp(string[, header])
md: Convert a block of quoted-printable data back to binary and return the binary data.
type: function
pt: binascii
mn: b2a_qp
ms: b2a_qp(data[, quotetabs, istext, header])
md: Convert binary data to a line(s) of ASCII characters in quoted-printable encoding.
type: function
pt: binascii
mn: a2b_hqx
ms: a2b_hqx(string)
md: Convert binhex4 formatted ASCII data to binary, without doing RLE-decompression.
type: function
pt: binascii
mn: rledecode_hqx
ms: rledecode_hqx(data)
md: Perform RLE-decompression on the data, as per the binhex4 standard.
type: function
pt: binascii
mn: rlecode_hqx
ms: rlecode_hqx(data)
md: Perform binhex4 style RLE-compression on data and return the result.
type: function
pt: binascii
mn: b2a_hqx
ms: b2a_hqx(data)
md: Perform hexbin4 binary-to-ASCII translation and return the resulting string.
type: function
pt: binascii
mn: crc_hqx
ms: crc_hqx(data, crc)
md: Compute the binhex4 crc value of data, starting with an initial crc and returning the result.
type: function
pt: binascii
mn: crc32
ms: crc32(data[, crc])
md: Compute CRC-32, the 32-bit checksum of data, starting with an initial crc.
type: function
pt: binascii
mn: b2a_hex
ms: b2a_hex(data)
md: 
type: function
pt: binascii
mn: a2b_hex
ms: a2b_hex(hexstr)
md: 
type: function
pt: binascii
mn: binhex
ms: binhex(input, output)
md: Convert a binary file with filename input to binhex file output.
type: function
pt: binhex
mn: hexbin
ms: hexbin(input[, output])
md: Decode a binhex file input.
type: function
pt: binhex
mn: bisect_left
ms: bisect_left(list, item[, lo[, hi]])
md: Locate the proper insertion point for item in list to   maintain sorted order.
type: function
pt: bisect
mn: bisect_right
ms: bisect_right(list, item[, lo[, hi]])
md: Similar to bisect_left(), but returns an insertion point   which comes after (to the right of) any existing entries of   item in list.
type: function
pt: bisect
mn: insort_left
ms: insort_left(list, item[, lo[, hi]])
md: Insert item in list in sorted order.
type: function
pt: bisect
mn: insort_right
ms: insort_right(list, item[, lo[, hi]])
md: Similar to insort_left(), but inserting item in   list after any existing entries of item.
type: function
pt: bisect
mn: hashopen
ms: hashopen(filename[, flag[,                           mode[, pgsize[,                           ffactor[, nelem[,                           cachesize[, lorder[,                           hflags]]]]]]]])
md: Open the hash format file named filename.
type: function
pt: bsddb
mn: btopen
ms: btopen(filename[, flag[,mode[, btflags[, cachesize[, maxkeypage[,minkeypage[, pgsize[, lorder]]]]]]]])
md: 
type: function
pt: bsddb
mn: rnopen
ms: rnopen(filename[, flag[, mode[,rnflags[, cachesize[, pgsize[, lorder[,rlen[, delim[, source[, pad]]]]]]]]]])
md: 
type: function
pt: bsddb
mn: setfirstweekday
ms: setfirstweekday(weekday)
md: Sets the weekday (0 is Monday, 6 is Sunday) to start each week.
type: function
pt: calendar
mn: firstweekday
ms: firstweekday()
md: Returns the current setting for the weekday to start each week.
type: function
pt: calendar
mn: isleap
ms: isleap(year)
md: Returns True if year is a leap year, otherwise False.
type: function
pt: calendar
mn: leapdays
ms: leapdays(y1, y2)
md: Returns the number of leap years in the range [y1.
type: function
pt: calendar
mn: weekday
ms: weekday(year, month, day)
md: Returns the day of the week (0 is Monday) for year (1970-.
type: function
pt: calendar
mn: weekheader
ms: weekheader(n)
md: Return a header containing abbreviated weekday names.
type: function
pt: calendar
mn: monthrange
ms: monthrange(year, month)
md: Returns weekday of first day of the month and number of days in month,  for the specified year and month.
type: function
pt: calendar
mn: monthcalendar
ms: monthcalendar(year, month)
md: Returns a matrix representing a month's calendar.
type: function
pt: calendar
mn: prmonth
ms: prmonth(theyear, themonth[, w[, l]])
md: Prints a month's calendar as returned by month().
type: function
pt: calendar
mn: month
ms: month(theyear, themonth[, w[, l]])
md: Returns a month's calendar in a multi-line string using the formatmonth of the TextCalendar class.
type: function
pt: calendar
mn: prcal
ms: prcal(year[, w[, l[c]]])
md: Prints the calendar for an entire year as returned by  calendar().
type: function
pt: calendar
mn: calendar
ms: calendar(year[, w[, l[c]]])
md: Returns a 3-column calendar for an entire year as a multi-line string using the formatyear of the TextCalendar class.
type: function
pt: calendar
mn: timegm
ms: timegm(tuple)
md: An unrelated but handy function that takes a time tuple such as returned by the gmtime() function in the time module.
type: function
pt: calendar
mn: iterweekdays
ms: iterweekdays(weekday)
md: Return an iterator for the week day numbers that will be used for one week.
type: method
pt: calendar
mn: itermonthdates
ms: itermonthdates(year, month)
md: Return an iterator for the month month (1-12) in the year year.
type: method
pt: calendar
mn: itermonthdays2
ms: itermonthdays2(year, month)
md: Return an iterator for the month month in the year year similar to itermonthdates().
type: method
pt: calendar
mn: itermonthdays
ms: itermonthdays(year, month)
md: Return an iterator for the month month in the year year similar to itermonthdates().
type: method
pt: calendar
mn: monthdatescalendar
ms: monthdatescalendar(year, month)
md: Return a list of the weeks in the month month of the year as full weeks.
type: method
pt: calendar
mn: monthdays2calendar
ms: monthdays2calendar(year, month)
md: Return a list of the weeks in the month month of the year as full weeks.
type: method
pt: calendar
mn: monthdayscalendar
ms: monthdayscalendar(year, month)
md: Return a list of the weeks in the month month of the year as full weeks.
type: method
pt: calendar
mn: yeardatescalendar
ms: yeardatescalendar(year[, width])
md: Return the data for the specified year ready for formatting.
type: method
pt: calendar
mn: yeardays2calendar
ms: yeardays2calendar(year[, width])
md: Return the data for the specified year ready for formatting (similar to yeardatescalendar()).
type: method
pt: calendar
mn: yeardayscalendar
ms: yeardayscalendar(year[, width])
md: Return the data for the specified year ready for formatting (similar to yeardatescalendar()).
type: method
pt: calendar
mn: formatmonth
ms: formatmonth(theyear, themonth[, w[, l]])
md: Return a month's calendar in a multi-line string.
type: method
pt: calendar
mn: prmonth
ms: prmonth(theyear, themonth[, w[, l]])
md: Print a month's calendar as returned by formatmonth().
type: method
pt: calendar
mn: formatyear
ms: formatyear(theyear, themonth[, w[,                               l[, c[, m]]]])
md: Return a m-column calendar for an entire year as a multi-line string.
type: method
pt: calendar
mn: pryear
ms: pryear(theyear[, w[, l[,                           c[, m]]]])
md: Print the calendar for an entire year as returned by formatyear().
type: method
pt: calendar
mn: formatyearpage
ms: formatyearpage(theyear, themonth[,                                   width[, css[, encoding]]])
md: Return a year's calendar as a complete HTML page.
type: method
pt: calendar
mn: firstweekday
ms: firstweekday
md: Return an iterator for the month month (1-12) in the year year.
type: member
pt: calendar
mn: do_POST
ms: do_POST()
md: This method serves the 'POST' request type, only allowed for CGI scripts.
type: method
pt: CGIHTTPServer
mn: cgi_directories
ms: cgi_directories
md: This defaults to ['/cgi-bin', '/htbin'] and describes directories to treat as containing CGI scripts.
type: member
pt: CGIHTTPServer
mn: enable
ms: enable([display[, logdir[,                         context[, format]]]])
md: This function causes the cgitb module to take over the   interpreter's default handling for exceptions.
type: function
pt: cgitb
mn: handler
ms: handler([info])
md: This function handles an exception using the default settings   (that is, show a report in the browser, but don't log to a file).
type: function
pt: cgitb
mn: getname
ms: getname()
md: Returns the name (ID) of the chunk.
type: method
pt: chunk
mn: getsize
ms: getsize()
md: Returns the size of the chunk.
type: method
pt: chunk
mn: close
ms: close()
md: Close and skip to the end of the chunk.
type: method
pt: chunk
mn: isatty
ms: isatty()
md: Returns False.
type: method
pt: chunk
mn: seek
ms: seek(pos[, whence])
md: Set the chunk's current position.
type: method
pt: chunk
mn: tell
ms: tell()
md: Return the current position into the chunk.
type: method
pt: chunk
mn: read
ms: read([size])
md: Read at most size bytes from the chunk (less if the read hits the end of the chunk before obtaining size bytes).
type: method
pt: chunk
mn: skip
ms: skip()
md: Skip to the end of the chunk.
type: method
pt: chunk
mn: acos
ms: acos(x)
md: Return the arc cosine of x.
type: function
pt: cmath
mn: acosh
ms: acosh(x)
md: Return the hyperbolic arc cosine of x.
type: function
pt: cmath
mn: asin
ms: asin(x)
md: Return the arc sine of x.
type: function
pt: cmath
mn: asinh
ms: asinh(x)
md: Return the hyperbolic arc sine of x.
type: function
pt: cmath
mn: atan
ms: atan(x)
md: Return the arc tangent of x.
type: function
pt: cmath
mn: atanh
ms: atanh(x)
md: Return the hyperbolic arc tangent of x.
type: function
pt: cmath
mn: cos
ms: cos(x)
md: Return the cosine of x.
type: function
pt: cmath
mn: cosh
ms: cosh(x)
md: Return the hyperbolic cosine of x.
type: function
pt: cmath
mn: exp
ms: exp(x)
md: Return the exponential value e**x.
type: function
pt: cmath
mn: log
ms: log(x[, base])
md: Returns the logarithm of x to the given base.
type: function
pt: cmath
mn: log10
ms: log10(x)
md: Return the base-10 logarithm of x.
type: function
pt: cmath
mn: sin
ms: sin(x)
md: Return the sine of x.
type: function
pt: cmath
mn: sinh
ms: sinh(x)
md: Return the hyperbolic sine of x.
type: function
pt: cmath
mn: sqrt
ms: sqrt(x)
md: Return the square root of x.
type: function
pt: cmath
mn: tan
ms: tan(x)
md: Return the tangent of x.
type: function
pt: cmath
mn: tanh
ms: tanh(x)
md: Return the hyperbolic tangent of x.
type: function
pt: cmath
mn: interact
ms: interact([banner[,                           readfunc[, local]]])
md: Convenience function to run a read-eval-print loop.
type: function
pt: code
mn: compile_command
ms: compile_command(source[,                                  filename[, symbol]])
md: This function is useful for programs that want to emulate Python's interpreter main loop (a.
type: function
pt: code
mn: register
ms: register(search_function)
md: Register a codec search function.
type: function
pt: codecs
mn: lookup
ms: lookup(encoding)
md: Looks up the codec info in the Python codec registry and returns a CodecInfo object as defined above.
type: function
pt: codecs
mn: getencoder
ms: getencoder(encoding)
md: Look up the codec for the given encoding and return its encoder function.
type: function
pt: codecs
mn: getdecoder
ms: getdecoder(encoding)
md: Look up the codec for the given encoding and return its decoder function.
type: function
pt: codecs
mn: getincrementalencoder
ms: getincrementalencoder(encoding)
md: Look up the codec for the given encoding and return its incremental encoder class or factory function.
type: function
pt: codecs
mn: getincrementaldecoder
ms: getincrementaldecoder(encoding)
md: Look up the codec for the given encoding and return its incremental decoder class or factory function.
type: function
pt: codecs
mn: getreader
ms: getreader(encoding)
md: Look up the codec for the given encoding and return its StreamReader class or factory function.
type: function
pt: codecs
mn: getwriter
ms: getwriter(encoding)
md: Look up the codec for the given encoding and return its StreamWriter class or factory function.
type: function
pt: codecs
mn: register_error
ms: register_error(name, error_handler)
md: Register the error handling function error_handler under the name name.
type: function
pt: codecs
mn: lookup_error
ms: lookup_error(name)
md: Return the error handler previously registered under the name name.
type: function
pt: codecs
mn: strict_errors
ms: strict_errors(exception)
md: Implements the strict error handling.
type: function
pt: codecs
mn: replace_errors
ms: replace_errors(exception)
md: Implements the replace error handling.
type: function
pt: codecs
mn: ignore_errors
ms: ignore_errors(exception)
md: Implements the ignore error handling.
type: function
pt: codecs
mn: xmlcharrefreplace_errors_errors
ms: xmlcharrefreplace_errors_errors(exception)
md: Implements the xmlcharrefreplace error handling.
type: function
pt: codecs
mn: backslashreplace_errors_errors
ms: backslashreplace_errors_errors(exception)
md: Implements the backslashreplace error handling.
type: function
pt: codecs
mn: open
ms: open(filename, mode[, encoding[,                       errors[, buffering]]])
md: Open an encoded file using the given mode and return a wrapped version providing transparent encoding/decoding.
type: function
pt: codecs
mn: EncodedFile
ms: EncodedFile(file, input[,                              output[, errors]])
md: Return a wrapped version of file which provides transparent encoding translation.
type: function
pt: codecs
mn: iterencode
ms: iterencode(iterable, encoding[, errors])
md: Uses an incremental encoder to iteratively encode the input provided by iterable.
type: function
pt: codecs
mn: iterdecode
ms: iterdecode(iterable, encoding[, errors])
md: Uses an incremental decoder to iteratively decode the input provided by iterable.
type: function
pt: codecs
mn: compile_command
ms: compile_command(source[, filename[, symbol]])
md: Tries to compile source, which should be a string of Python code and return a code object if source is valid Python code.
type: function
pt: codeop
mn: rgb_to_yiq
ms: rgb_to_yiq(r, g, b)
md: Convert the color from RGB coordinates to YIQ coordinates.
type: function
pt: colorsys
mn: yiq_to_rgb
ms: yiq_to_rgb(y, i, q)
md: Convert the color from YIQ coordinates to RGB coordinates.
type: function
pt: colorsys
mn: rgb_to_hls
ms: rgb_to_hls(r, g, b)
md: Convert the color from RGB coordinates to HLS coordinates.
type: function
pt: colorsys
mn: hls_to_rgb
ms: hls_to_rgb(h, l, s)
md: Convert the color from HLS coordinates to RGB coordinates.
type: function
pt: colorsys
mn: rgb_to_hsv
ms: rgb_to_hsv(r, g, b)
md: Convert the color from RGB coordinates to HSV coordinates.
type: function
pt: colorsys
mn: hsv_to_rgb
ms: hsv_to_rgb(h, s, v)
md: Convert the color from HSV coordinates to RGB coordinates.
type: function
pt: colorsys
mn: compile_dir
ms: compile_dir(dir[, maxlevels[,                              ddir[, force[,                               rx[, quiet]]]]])
md: 
type: function
pt: compileall
mn: compile_path
ms: compile_path([skip_curdir[,                               maxlevels[, force]]])
md: 
type: function
pt: compileall
mn: getChildren
ms: getChildren()
md: Returns a flattened list of the child nodes and objects in the   order they occur.
type: method
pt: compiler.ast
mn: getChildNodes
ms: getChildNodes()
md: Returns a flattened list of the child nodes in the order they   occur.
type: method
pt: compiler.ast
mn: bases
ms: bases
md: Returns a flattened list of the child nodes and objects in the   order they occur.
type: member
pt: compiler.ast
mn: test
ms: test
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: doc
ms: doc
md: Returns a flattened list of the child nodes and objects in the   order they occur.
type: member
pt: compiler.ast
mn: body
ms: body
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: lineno
ms: lineno
md: Returns a flattened list of the child nodes and objects in the   order they occur.
type: member
pt: compiler.ast
mn: else_
ms: else_
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: tests
ms: tests
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: left
ms: left
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: right
ms: right
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: nodes
ms: nodes
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: expr
ms: expr
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: attrname
ms: attrname
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: flags
ms: flags
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: name
ms: name
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: fail
ms: fail
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: node
ms: node
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: op
ms: op
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: args
ms: args
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: star_args
ms: star_args
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: dstar_args
ms: dstar_args
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: code
ms: code
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: ops
ms: ops
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: value
ms: value
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: items
ms: items
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: locals
ms: locals
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: globals
ms: globals
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: assign
ms: assign
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: list
ms: list
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: modname
ms: modname
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: names
ms: names
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: decorators
ms: decorators
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: argnames
ms: argnames
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: defaults
ms: defaults
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: iter
ms: iter
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: ifs
ms: ifs
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: quals
ms: quals
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: dest
ms: dest
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: expr1
ms: expr1
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: expr2
ms: expr2
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: expr3
ms: expr3
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: lower
ms: lower
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: upper
ms: upper
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: subs
ms: subs
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: handlers
ms: handlers
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: final
ms: final
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: vars
ms: vars
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: compiler.ast
mn: walk
ms: walk(tree, visitor[, verbose])
md: 
type: function
pt: compiler.visitor
mn: preorder
ms: preorder(tree, visitor)
md: 
type: method
pt: compiler.visitor
mn: parse
ms: parse(buf)
md: Returns an abstract syntax tree for the Python source code in buf.
type: function
pt: compiler
mn: parseFile
ms: parseFile(path)
md: Return an abstract syntax tree for the Python source code in the file specified by path.
type: function
pt: compiler
mn: walk
ms: walk(ast, visitor[, verbose])
md: Do a pre-order walk over the abstract syntax tree ast.
type: function
pt: compiler
mn: compile
ms: compile(source, filename, mode, flags=None, 			dont_inherit=None)
md: Compile the string source, a Python module, statement or expression, into a code object that can be executed by the exec statement or eval().
type: function
pt: compiler
mn: compileFile
ms: compileFile(source)
md: Compiles the file source and generates a .
type: function
pt: compiler
mn: contextmanager
ms: contextmanager(func)
md: This function is a decorator that can be used to define a factory function for with statement context managers, without needing to create a class or separate __enter__() and __exit__() methods.
type: function
pt: contextlib
mn: closing
ms: closing(thing)
md: Return a context manager that closes thing upon completion of the block.
type: function
pt: contextlib
mn: rfc2109_as_netscape
ms: rfc2109_as_netscape
md: This class represents Netscape, RFC 2109 and RFC 2965 cookies.
type: member
pt: cookielib
mn: constructor
ms: constructor(object)
md: Declares object to be a valid constructor.
type: function
pt: copyreg
mn: pickle
ms: pickle(type, function[, constructor])
md: Declares that function should be used as a ``reduction''   function for objects of type type; type must not be a   ``classic'' class object.
type: function
pt: copyreg
mn: crypt
ms: crypt(word, salt)
md: word will usually be a user's password as typed at a prompt or    in a graphical interface.
type: function
pt: crypt
mn: isalnum
ms: isalnum(c)
md: Checks for an ASCII alphanumeric character; it is equivalent to "isalpha(c) or isdigit(c)".
type: function
pt: curses.ascii
mn: isalpha
ms: isalpha(c)
md: Checks for an ASCII alphabetic character; it is equivalent to "isupper(c) or islower(c)".
type: function
pt: curses.ascii
mn: isascii
ms: isascii(c)
md: Checks for a character value that fits in the 7-bit ASCII set.
type: function
pt: curses.ascii
mn: isblank
ms: isblank(c)
md: Checks for an ASCII whitespace character.
type: function
pt: curses.ascii
mn: iscntrl
ms: iscntrl(c)
md: Checks for an ASCII control character (in the range 0x00 to 0x1f).
type: function
pt: curses.ascii
mn: isdigit
ms: isdigit(c)
md: Checks for an ASCII decimal digit, "0" through "9".
type: function
pt: curses.ascii
mn: isgraph
ms: isgraph(c)
md: Checks for ASCII any printable character except space.
type: function
pt: curses.ascii
mn: islower
ms: islower(c)
md: Checks for an ASCII lower-case character.
type: function
pt: curses.ascii
mn: isprint
ms: isprint(c)
md: Checks for any ASCII printable character including space.
type: function
pt: curses.ascii
mn: ispunct
ms: ispunct(c)
md: Checks for any printable ASCII character which is not a space or an alphanumeric character.
type: function
pt: curses.ascii
mn: isspace
ms: isspace(c)
md: Checks for ASCII white-space characters; space, line feed, carriage return, form feed, horizontal tab, vertical tab.
type: function
pt: curses.ascii
mn: isupper
ms: isupper(c)
md: Checks for an ASCII uppercase letter.
type: function
pt: curses.ascii
mn: isxdigit
ms: isxdigit(c)
md: Checks for an ASCII hexadecimal digit.
type: function
pt: curses.ascii
mn: isctrl
ms: isctrl(c)
md: Checks for an ASCII control character (ordinal values 0 to 31).
type: function
pt: curses.ascii
mn: ismeta
ms: ismeta(c)
md: Checks for a non-ASCII character (ordinal values 0x80 and above).
type: function
pt: curses.ascii
mn: ascii
ms: ascii(c)
md: Return the ASCII value corresponding to the low 7 bits of c.
type: function
pt: curses.ascii
mn: ctrl
ms: ctrl(c)
md: Return the control character corresponding to the given character (the character bit value is bitwise-anded with 0x1f).
type: function
pt: curses.ascii
mn: alt
ms: alt(c)
md: Return the 8-bit character corresponding to the given ASCII character (the character bit value is bitwise-ored with 0x80).
type: function
pt: curses.ascii
mn: unctrl
ms: unctrl(c)
md: Return a string representation of the ASCII character c.
type: function
pt: curses.ascii
mn: rectangle
ms: rectangle(win, uly, ulx, lry, lrx)
md: Draw a rectangle.
type: function
pt: curses.textpad
mn: tzinfo
ms: tzinfo
md: The smallest year number allowed in a date or   datetime object.
type: member
pt: datetime
mn: open
ms: open(path[, flag[, mode]])
md: Open a db database and return the database object.
type: function
pt: dbhash
mn: open
ms: open(filename[, flag[, mode]])
md: Open a dbm database and return a dbm object.
type: function
pt: dbm
mn: __init__
ms: __init__([tabsize][,    wrapcolumn][, linejunk][, charjunk])
md: 
type: function
pt: difflib
mn: make_file
ms: make_file(fromlines, tolines    [, fromdesc][, todesc][, context][,    numlines])
md: Compares fromlines and tolines (lists of strings) and returns     a string which is a complete HTML file containing a table showing line by     line differences with inter-line and intra-line changes highlighted.
type: function
pt: difflib
mn: make_table
ms: make_table(fromlines, tolines    [, fromdesc][, todesc][, context][,    numlines])
md: Compares fromlines and tolines (lists of strings) and returns     a string which is a complete HTML table showing line by line differences     with inter-line and intra-line changes highlighted.
type: function
pt: difflib
mn: context_diff
ms: context_diff(a, b[, fromfile][,    tofile][, fromfiledate][, tofiledate][,    n][, lineterm])
md: Compare a and b (lists of strings); return a   delta (a generator generating the delta lines) in context diff   format.
type: function
pt: difflib
mn: get_close_matches
ms: get_close_matches(word, possibilities[,                 n][, cutoff])
md: Return a list of the best ``good enough'' matches.
type: function
pt: difflib
mn: ndiff
ms: ndiff(a, b[, linejunk][, charjunk])
md: Compare a and b (lists of strings); return a   Differ-style delta (a generator generating the delta lines).
type: function
pt: difflib
mn: restore
ms: restore(sequence, which)
md: Return one of the two sequences that generated a delta.
type: function
pt: difflib
mn: unified_diff
ms: unified_diff(a, b[, fromfile][,    tofile][, fromfiledate][, tofiledate][,    n][, lineterm])
md: Compare a and b (lists of strings); return a   delta (a generator generating the delta lines) in unified diff   format.
type: function
pt: difflib
mn: IS_LINE_JUNK
ms: IS_LINE_JUNK(line)
md: Return true for ignorable lines.
type: function
pt: difflib
mn: IS_CHARACTER_JUNK
ms: IS_CHARACTER_JUNK(ch)
md: Return true for ignorable characters.
type: function
pt: difflib
mn: reset
ms: reset()
md: Resets the directory cache.
type: function
pt: dircache
mn: listdir
ms: listdir(path)
md: Return a directory listing of path, as gotten from os.
type: function
pt: dircache
mn: opendir
ms: opendir(path)
md: Same as listdir().
type: function
pt: dircache
mn: annotate
ms: annotate(head, list)
md: Assume list is a list of paths relative to head, and append, in place, a "/" to each path which points to a directory.
type: function
pt: dircache
mn: dis
ms: dis([bytesource])
md: Disassemble the bytesource object.
type: function
pt: dis
mn: distb
ms: distb([tb])
md: Disassembles the top-of-stack function of a traceback, using the last traceback if none was passed.
type: function
pt: dis
mn: disassemble
ms: disassemble(code[, lasti])
md: Disassembles a code object, indicating the last instruction if lasti was provided.
type: function
pt: dis
mn: disco
ms: disco(code[, lasti])
md: A synonym for disassemble.
type: function
pt: dis
mn: open
ms: open(name[, mode = RTLD_LAZY])
md: Open a shared object file, and return a handle.
type: function
pt: dl
mn: open
ms: open(filename[, flag[, mode]])
md: Open a dumbdbm database and return a dumbdbm object.
type: function
pt: dumbdbm
mn: add_charset
ms: add_charset(charset[, header_enc[,    body_enc[, output_charset]]])
md: Add character properties to the global registry.
type: function
pt: email.charset
mn: add_alias
ms: add_alias(alias, canonical)
md: Add a character set alias.
type: function
pt: email.charset
mn: add_codec
ms: add_codec(charset, codecname)
md: Add a codec that map characters in the given character set to and from Unicode.
type: function
pt: email.charset
mn: get_body_encoding
ms: get_body_encoding()
md: Return the content transfer encoding used for body encoding.
type: method
pt: email.charset
mn: convert
ms: convert(s)
md: Convert the string s from the input_codec to the output_codec.
type: method
pt: email.charset
mn: to_splittable
ms: to_splittable(s)
md: Convert a possibly multibyte string to a safely splittable format.
type: method
pt: email.charset
mn: from_splittable
ms: from_splittable(ustr[, to_output])
md: Convert a splittable string back into an encoded string.
type: method
pt: email.charset
mn: get_output_charset
ms: get_output_charset()
md: Return the output character set.
type: method
pt: email.charset
mn: encoded_header_len
ms: encoded_header_len()
md: Return the length of the encoded header string, properly calculating for quoted-printable or base64 encoding.
type: method
pt: email.charset
mn: header_encode
ms: header_encode(s[, convert])
md: Header-encode the string s.
type: method
pt: email.charset
mn: body_encode
ms: body_encode(s[, convert])
md: Body-encode the string s.
type: method
pt: email.charset
mn: __str__
ms: __str__()
md: Returns input_charset as a string coerced to lower case.
type: method
pt: email.charset
mn: __eq__
ms: __eq__(other)
md: This method allows you to compare two Charset instances for equality.
type: method
pt: email.charset
mn: __ne__
ms: __ne__(other)
md: This method allows you to compare two Charset instances for inequality.
type: method
pt: email.charset
mn: encode_quopri
ms: encode_quopri(msg)
md: 
type: function
pt: email.encoders
mn: encode_base64
ms: encode_base64(msg)
md: 
type: function
pt: email.encoders
mn: encode_7or8bit
ms: encode_7or8bit(msg)
md: 
type: function
pt: email.encoders
mn: encode_noop
ms: encode_noop(msg)
md: 
type: function
pt: email.encoders
mn: flatten
ms: flatten(msg[, unixfrom])
md: Print the textual representation of the message object structure rooted at msg to the output file specified when the Generator instance was created.
type: method
pt: email.generator
mn: clone
ms: clone(fp)
md: Return an independent clone of this Generator instance with the exact same options.
type: method
pt: email.generator
mn: write
ms: write(s)
md: Write the string s to the underlying file object, i.
type: method
pt: email.generator
mn: decode_header
ms: decode_header(header)
md: Decode a message header value without converting the character set.
type: function
pt: email.header
mn: make_header
ms: make_header(decoded_seq[, maxlinelen[,    header_name[, continuation_ws]]])
md: Create a Header instance from a sequence of pairs as returned by decode_header().
type: function
pt: email.header
mn: append
ms: append(s[, charset[, errors]])
md: Append the string s to the MIME header.
type: method
pt: email.header
mn: encode
ms: encode([splitchars])
md: Encode a message header into an RFC-compliant format, possibly wrapping long lines and encapsulating non-ASCII parts in base64 or quoted-printable encodings.
type: method
pt: email.header
mn: __str__
ms: __str__()
md: A synonym for Header.
type: method
pt: email.header
mn: __unicode__
ms: __unicode__()
md: A helper for the built-in unicode() function.
type: method
pt: email.header
mn: __eq__
ms: __eq__(other)
md: This method allows you to compare two Header instances for equality.
type: method
pt: email.header
mn: __ne__
ms: __ne__(other)
md: This method allows you to compare two Header instances for inequality.
type: method
pt: email.header
mn: body_line_iterator
ms: body_line_iterator(msg[, decode])
md: This iterates over all the payloads in all the subparts of msg, returning the string payloads line-by-line.
type: function
pt: email.iterators
mn: typed_subpart_iterator
ms: typed_subpart_iterator(msg[,    maintype[, subtype]])
md: This iterates over all the subparts of msg, returning only those subparts that match the MIME type specified by maintype and subtype.
type: function
pt: email.iterators
mn: _structure
ms: _structure(msg[, fp[, level]])
md: Prints an indented representation of the content types of the message object structure.
type: function
pt: email.iterators
mn: as_string
ms: as_string([unixfrom])
md: Return the entire message flatten as a string.
type: method
pt: email.message
mn: __str__
ms: __str__()
md: Equivalent to as_string(unixfrom=True).
type: method
pt: email.message
mn: is_multipart
ms: is_multipart()
md: Return True if the message's payload is a list of sub-Message objects, otherwise return False.
type: method
pt: email.message
mn: set_unixfrom
ms: set_unixfrom(unixfrom)
md: Set the message's envelope header to unixfrom, which should be a string.
type: method
pt: email.message
mn: get_unixfrom
ms: get_unixfrom()
md: Return the message's envelope header.
type: method
pt: email.message
mn: attach
ms: attach(payload)
md: Add the given payload to the current payload, which must be None or a list of Message objects before the call.
type: method
pt: email.message
mn: get_payload
ms: get_payload([i[, decode]])
md: Return a reference the current payload, which will be a list of Message objects when is_multipart() is True, or a string when is_multipart() is False.
type: method
pt: email.message
mn: set_payload
ms: set_payload(payload[, charset])
md: Set the entire message object's payload to payload.
type: method
pt: email.message
mn: set_charset
ms: set_charset(charset)
md: Set the character set of the payload to charset
type: method
pt: email.message
mn: get_charset
ms: get_charset()
md: Return the Charset instance associated with the message's payload.
type: method
pt: email.message
mn: __len__
ms: __len__()
md: Return the total number of headers, including duplicates.
type: method
pt: email.message
mn: __contains__
ms: __contains__(name)
md: Return true if the message object has a field named name.
type: method
pt: email.message
mn: __getitem__
ms: __getitem__(name)
md: Return the value of the named header field.
type: method
pt: email.message
mn: __setitem__
ms: __setitem__(name, val)
md: Add a header to the message with field name name and value val.
type: method
pt: email.message
mn: __delitem__
ms: __delitem__(name)
md: Delete all occurrences of the field with name name from the message's headers.
type: method
pt: email.message
mn: has_key
ms: has_key(name)
md: Return true if the message contains a header field named name, otherwise return false.
type: method
pt: email.message
mn: keys
ms: keys()
md: Return a list of all the message's header field names.
type: method
pt: email.message
mn: values
ms: values()
md: Return a list of all the message's field values.
type: method
pt: email.message
mn: items
ms: items()
md: Return a list of 2-tuples containing all the message's field headers and values.
type: method
pt: email.message
mn: get
ms: get(name[, failobj])
md: Return the value of the named header field.
type: method
pt: email.message
mn: get_all
ms: get_all(name[, failobj])
md: Return a list of all the values for the field named name.
type: method
pt: email.message
mn: add_header
ms: add_header(_name, _value, **_params)
md: Extended header setting.
type: method
pt: email.message
mn: replace_header
ms: replace_header(_name, _value)
md: Replace a header.
type: method
pt: email.message
mn: get_content_type
ms: get_content_type()
md: Return the message's content type.
type: method
pt: email.message
mn: get_content_maintype
ms: get_content_maintype()
md: Return the message's main content type.
type: method
pt: email.message
mn: get_content_subtype
ms: get_content_subtype()
md: Return the message's sub-content type.
type: method
pt: email.message
mn: get_default_type
ms: get_default_type()
md: Return the default content type.
type: method
pt: email.message
mn: set_default_type
ms: set_default_type(ctype)
md: Set the default content type.
type: method
pt: email.message
mn: get_params
ms: get_params([failobj[,    header[, unquote]]])
md: Return the message's Content-Type: parameters, as a list.
type: method
pt: email.message
mn: get_param
ms: get_param(param[,    failobj[, header[, unquote]]])
md: Return the value of the Content-Type: header's parameter param as a string.
type: method
pt: email.message
mn: set_param
ms: set_param(param, value[,    header[, requote[, charset[, language]]]])
md: 
type: method
pt: email.message
mn: del_param
ms: del_param(param[, header[,    requote]])
md: Remove the given parameter completely from theContent-Type: header.
type: method
pt: email.message
mn: set_type
ms: set_type(type[, header][,    requote])
md: Set the main type and subtype for the Content-Type: header.
type: method
pt: email.message
mn: get_filename
ms: get_filename([failobj])
md: Return the value of the filename parameter of the Content-Disposition: header of the message.
type: method
pt: email.message
mn: get_boundary
ms: get_boundary([failobj])
md: Return the value of the boundary parameter of the Content-Type:header of the message, or failobj if either the header is missing, or has no boundary parameter.
type: method
pt: email.message
mn: set_boundary
ms: set_boundary(boundary)
md: Set the boundary parameter of the Content-Type: header to boundary.
type: method
pt: email.message
mn: get_content_charset
ms: get_content_charset([failobj])
md: Return the charset parameter of the Content-Type: header, coerced to lower case.
type: method
pt: email.message
mn: get_charsets
ms: get_charsets([failobj])
md: Return a list containing the character set names in the message.
type: method
pt: email.message
mn: walk
ms: walk()
md: The walk() method is an all-purpose generator which can be used to iterate over all the parts and subparts of a message object tree, in depth-first traversal order.
type: method
pt: email.message
mn: quote
ms: quote(str)
md: Return a new string with backslashes in str replaced by two backslashes, and double quotes replaced by backslash-double quote.
type: function
pt: email.utils
mn: unquote
ms: unquote(str)
md: Return a new string which is an unquoted version of str.
type: function
pt: email.utils
mn: parseaddr
ms: parseaddr(address)
md: Parse address - which should be the value of some address-containing field such as To: or Cc: - into its constituent realname and email address parts.
type: function
pt: email.utils
mn: formataddr
ms: formataddr(pair)
md: The inverse of parseaddr(), this takes a 2-tuple of the form (realname, email_address) and returns the string value suitable for a To: or Cc: header.
type: function
pt: email.utils
mn: getaddresses
ms: getaddresses(fieldvalues)
md: This method returns a list of 2-tuples of the form returned by parseaddr().
type: function
pt: email.utils
mn: parsedate
ms: parsedate(date)
md: Attempts to parse a date
type: function
pt: email.utils
mn: parsedate_tz
ms: parsedate_tz(date)
md: Performs the same function as parsedate(), but returns either None or a 10-tuple; the first 9 elements make up a tuple that can be passed directly to time.
type: function
pt: email.utils
mn: mktime_tz
ms: mktime_tz(tuple)
md: Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp.
type: function
pt: email.utils
mn: formatdate
ms: formatdate([timeval[, localtime][, usegmt]])
md: Returns a date string
type: function
pt: email.utils
mn: make_msgid
ms: make_msgid([idstring])
md: 
type: function
pt: email.utils
mn: decode_rfc2231
ms: decode_rfc2231(s)
md: Decode the string s
type: function
pt: email.utils
mn: encode_rfc2231
ms: encode_rfc2231(s[, charset[, language]])
md: Encode the string s
type: function
pt: email.utils
mn: collapse_rfc2231_value
ms: collapse_rfc2231_value(value[, errors[,    fallback_charset]])
md: 
type: function
pt: email.utils
mn: decode_params
ms: decode_params(params)
md: Decode parameters list
type: function
pt: email.utils
mn: nameprep
ms: nameprep(label)
md: Return the nameprepped version of label.
type: function
pt: encodings.idna
mn: ToASCII
ms: ToASCII(label)
md: Convert a label to ASCII
type: function
pt: encodings.idna
mn: ToUnicode
ms: ToUnicode(label)
md: Convert a label to Unicode
type: function
pt: encodings.idna
mn: args
ms: args
md: The base class for all built-in exceptions.
type: member
pt: exceptions
mn: message
ms: message
md: All built-in, non-system-exiting exceptions are derived from this class.
type: member
pt: exceptions
mn: errno
ms: errno
md: 
type: member
pt: exceptions
mn: filename
ms: filename
md: Raised when the interpreter finds an internal error, but the   situation does not look so serious to cause it to abandon all hope.
type: member
pt: exceptions
mn: code
ms: code
md: Raised when an operation or function is applied to an object   of inappropriate type.
type: member
pt: exceptions
mn: winerror
ms: winerror
md: Raised when the second argument of a division or modulo operation is   zero.
type: member
pt: exceptions
mn: fcntl
ms: fcntl(fd, op[, arg])
md: Perform the requested operation on file descriptor fd (file   objects providing a fileno() method are accepted as well).
type: function
pt: fcntl
mn: ioctl
ms: ioctl(fd, op[, arg[, mutate_flag]])
md: This function is identical to the fcntl() function
type: function
pt: fcntl
mn: flock
ms: flock(fd, op)
md: Perform the lock operation op on file descriptor fd (file   objects providing a fileno() method are accepted as well).
type: function
pt: fcntl
mn: lockf
ms: lockf(fd, operation,    [length, [start, [whence]]])
md: This is essentially a wrapper around the fcntl() locking calls.
type: function
pt: fcntl
mn: cmp
ms: cmp(f1, f2[, shallow])
md: Compare the files named f1 and f2, returning True if they seem equal, False otherwise.
type: function
pt: filecmp
mn: cmpfiles
ms: cmpfiles(dir1, dir2, common[,                           shallow])
md: Returns three lists of file names: match, mismatch, errors.
type: function
pt: filecmp
mn: input
ms: input([files[, inplace[,                        backup[, mode[, openhook]]]]])
md: Create an instance of the FileInput class.
type: function
pt: fileinput
mn: filename
ms: filename()
md: Return the name of the file currently being read.
type: function
pt: fileinput
mn: fileno
ms: fileno()
md: Return the integer ``file descriptor'' for the current file.
type: function
pt: fileinput
mn: lineno
ms: lineno()
md: Return the cumulative line number of the line that has just been   read.
type: function
pt: fileinput
mn: filelineno
ms: filelineno()
md: Return the line number in the current file.
type: function
pt: fileinput
mn: isfirstline
ms: isfirstline()
md: Returns true if the line just read is the first line of its file,   otherwise returns false.
type: function
pt: fileinput
mn: isstdin
ms: isstdin()
md: Returns true if the last line was read from sys.
type: function
pt: fileinput
mn: nextfile
ms: nextfile()
md: Close the current file so that the next iteration will read the   first line from the next file (if any); lines not read from the file   will not count towards the cumulative line count.
type: function
pt: fileinput
mn: close
ms: close()
md: Close the sequence.
type: function
pt: fileinput
mn: hook_compressed
ms: hook_compressed(filename, mode)
md: Transparently opens files compressed with gzip and bzip2 (recognized   by the extensions '.
type: function
pt: fileinput
mn: hook_encoded
ms: hook_encoded(encoding)
md: Returns a hook which opens each file with codecs.
type: function
pt: fileinput
mn: fnmatch
ms: fnmatch(filename, pattern)
md: Test whether the filename string matches the pattern string, returning true or false.
type: function
pt: fnmatch
mn: fnmatchcase
ms: fnmatchcase(filename, pattern)
md: Test whether filename matches pattern, returning true or false; the comparison is case-sensitive.
type: function
pt: fnmatch
mn: filter
ms: filter(names, pattern)
md: Return the subset of the list of names that match pattern.
type: function
pt: fnmatch
mn: translate
ms: translate(pattern)
md: Return the shell-style pattern converted to a regular expression.
type: function
pt: fnmatch
mn: turnon_sigfpe
ms: turnon_sigfpe()
md: Turn on the generation of SIGFPE, and set up an appropriate signal handler.
type: function
pt: fpectl
mn: turnoff_sigfpe
ms: turnoff_sigfpe()
md: Reset default handling of floating point exceptions.
type: function
pt: fpectl
mn: fix
ms: fix(x, digs)
md: Format x as [-]ddd.
type: function
pt: fpformat
mn: sci
ms: sci(x, digs)
md: Format x as [-]d.
type: function
pt: fpformat
mn: partial
ms: partial(func[,*args][, **keywords])
md: Return a new partial object which when called will behave like func called with the positional arguments args and keyword arguments keywords.
type: function
pt: functools
mn: update_wrapper
ms: update_wrapper(wrapper, wrapped[, assigned][, updated])
md: Update a wrapper function to look like the wrapped function.
type: function
pt: functools
mn: wraps
ms: wraps(wrapped[, assigned][, updated])
md: This is a convenience function for invoking partial(update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated) as a function decorator when defining a wrapper function.
type: function
pt: functools
mn: enable
ms: enable()
md: Enable automatic garbage collection.
type: function
pt: gc
mn: disable
ms: disable()
md: Disable automatic garbage collection.
type: function
pt: gc
mn: isenabled
ms: isenabled()
md: Returns true if automatic collection is enabled.
type: function
pt: gc
mn: collect
ms: collect([generation])
md: With no arguments, run a full collection.
type: function
pt: gc
mn: set_debug
ms: set_debug(flags)
md: Set the garbage collection debugging flags.
type: function
pt: gc
mn: get_debug
ms: get_debug()
md: Return the debugging flags currently set.
type: function
pt: gc
mn: get_objects
ms: get_objects()
md: Returns a list of all objects tracked by the collector, excluding the list returned.
type: function
pt: gc
mn: set_threshold
ms: set_threshold(threshold0[,                                threshold1[, threshold2]])
md: Set the garbage collection thresholds (the collection frequency).
type: function
pt: gc
mn: get_count
ms: get_count()
md: Return the current collection  counts as a tuple of (count0, count1, count2).
type: function
pt: gc
mn: get_threshold
ms: get_threshold()
md: Return the current collection thresholds as a tuple of (threshold0, threshold1, threshold2).
type: function
pt: gc
mn: get_referrers
ms: get_referrers(*objs)
md: Return the list of objects that directly refer to any of objs.
type: function
pt: gc
mn: get_referents
ms: get_referents(*objs)
md: Return a list of objects directly referred to by any of the arguments.
type: function
pt: gc
mn: tp_traverse
ms: tp_traverse
md: A list of objects which the collector found to be unreachable but could not be freed (uncollectable objects).
type: member
pt: gc
mn: open
ms: open(filename, [flag, [mode]])
md: Open a gdbm database and return a gdbm object.
type: function
pt: gdbm
mn: firstkey
ms: firstkey()
md: It's possible to loop over every key in the database using this method  and the nextkey() method.
type: function
pt: gdbm
mn: nextkey
ms: nextkey(key)
md: Returns the key that follows key in the traversal.
type: function
pt: gdbm
mn: reorganize
ms: reorganize()
md: If you have carried out a lot of deletions and would like to shrink the space used by the gdbm file, this routine will reorganize the database.
type: function
pt: gdbm
mn: sync
ms: sync()
md: When the database has been opened in fast mode, this method forces any  unwritten data to be written to the disk.
type: function
pt: gdbm
mn: getopt
ms: getopt(args, options[, long_options])
md: Parses command line options and parameter list.
type: function
pt: getopt
mn: gnu_getopt
ms: gnu_getopt(args, options[, long_options])
md: This function works like getopt(), except that GNU style scanning mode is used by default.
type: function
pt: getopt
mn: msg
ms: msg
md: Alias for GetoptError; for backward compatibility.
type: member
pt: getopt
mn: getpass
ms: getpass([prompt[, stream]])
md: Prompt the user for a password without echoing.
type: function
pt: getpass
mn: getuser
ms: getuser()
md: Return the ``login name'' of the user.
type: function
pt: getpass
mn: glob
ms: glob(pathname)
md: Return a possibly-empty list of path names that match pathname, which must be a string containing a path specification.
type: function
pt: glob
mn: iglob
ms: iglob(pathname)
md: Return an iterator which yields the same values as glob() without actually storing them all simultaneously.
type: function
pt: glob
mn: send_selector
ms: send_selector(selector, host[, port])
md: Send a selector string to the gopher server at host and port (default 70).
type: function
pt: gopherlib
mn: send_query
ms: send_query(selector, query, host[, port])
md: Send a selector string and a query string to a gopher server at host and port (default 70).
type: function
pt: gopherlib
mn: getgrgid
ms: getgrgid(gid)
md: Return the group database entry for the given numeric group ID.
type: function
pt: grp
mn: getgrnam
ms: getgrnam(name)
md: Return the group database entry for the given group name.
type: function
pt: grp
mn: getgrall
ms: getgrall()
md: Return a list of all available group entries, in arbitrary order.
type: function
pt: grp
mn: open
ms: open(filename[, mode[, compresslevel]])
md: This is a shorthand for GzipFile(filename, mode, compresslevel).
type: function
pt: gzip
mn: update
ms: update(arg)
md: Update the hash object with the string arg.
type: method
pt: hashlib
mn: digest
ms: digest()
md: Return the digest of the strings passed to the update() method so far.
type: method
pt: hashlib
mn: hexdigest
ms: hexdigest()
md: Like digest() except the digest is returned as a string of double length, containing only hexadecimal digits.
type: method
pt: hashlib
mn: copy
ms: copy()
md: Return a copy (``clone'') of the hash object.
type: method
pt: hashlib
mn: digest_size
ms: digest_size
md: Like digest() except the digest is returned as a string of double length, containing only hexadecimal digits.
type: member
pt: hashlib
mn: heappush
ms: heappush(heap, item)
md: Push the value item onto the heap, maintaining the heap invariant.
type: function
pt: heapq
mn: heappop
ms: heappop(heap)
md: Pop and return the smallest item from the heap, maintaining the heap invariant.
type: function
pt: heapq
mn: heapify
ms: heapify(x)
md: Transform list x into a heap, in-place, in linear time.
type: function
pt: heapq
mn: heapreplace
ms: heapreplace(heap, item)
md: Pop and return the smallest item from the heap, and also push the new item.
type: function
pt: heapq
mn: nlargest
ms: nlargest(n, iterable[, key])
md: Return a list with the n largest elements from the dataset defined by iterable.
type: function
pt: heapq
mn: nsmallest
ms: nsmallest(n, iterable[, key])
md: Return a list with the n smallest elements from the dataset defined by iterable.
type: function
pt: heapq
mn: new
ms: new(key[, msg[, digestmod]])
md: Return a new hmac object.
type: function
pt: hmac
mn: update
ms: update(msg)
md: Update the hmac object with the string msg.
type: method
pt: hmac
mn: digest
ms: digest()
md: Return the digest of the strings passed to the update()   method so far.
type: method
pt: hmac
mn: hexdigest
ms: hexdigest()
md: Like digest() except the digest is returned as a string   twice the length containing   only hexadecimal digits.
type: method
pt: hmac
mn: copy
ms: copy()
md: Return a copy (``clone'') of the hmac object.
type: method
pt: hmac
mn: load
ms: load(filename)
md: Load hotshot data from filename.
type: function
pt: hotshot.stats
mn: entitydefs
ms: entitydefs
md: A dictionary mapping XHTML 1.
type: member
pt: htmlentitydefs
mn: reset
ms: reset()
md: Reset the instance.
type: method
pt: HTMLParser
mn: feed
ms: feed(data)
md: Feed some text to the parser.
type: method
pt: HTMLParser
mn: close
ms: close()
md: Force processing of all buffered data as if it were followed by an end-of-file mark.
type: method
pt: HTMLParser
mn: getpos
ms: getpos()
md: Return current line number and offset.
type: method
pt: HTMLParser
mn: get_starttag_text
ms: get_starttag_text()
md: Return the text of the most recently opened start tag.
type: method
pt: HTMLParser
mn: handle_starttag
ms: handle_starttag(tag, attrs)
md: This method is called to handle the start of a tag.
type: method
pt: HTMLParser
mn: handle_startendtag
ms: handle_startendtag(tag, attrs)
md: Similar to handle_starttag(), but called when the parser encounters an XHTML-style empty tag (&lt;a .
type: method
pt: HTMLParser
mn: handle_endtag
ms: handle_endtag(tag)
md: This method is called to handle the end tag of an element.
type: method
pt: HTMLParser
mn: handle_data
ms: handle_data(data)
md: This method is called to process arbitrary data.
type: method
pt: HTMLParser
mn: handle_charref
ms: handle_charref(name)
md: This method is called to process a character reference of the form "&amp;#ref;".
type: method
pt: HTMLParser
mn: handle_entityref
ms: handle_entityref(name)
md: This method is called to process a general entity reference of the form "&amp;name;" where name is an general entity reference.
type: method
pt: HTMLParser
mn: handle_comment
ms: handle_comment(data)
md: This method is called when a comment is encountered.
type: method
pt: HTMLParser
mn: handle_decl
ms: handle_decl(decl)
md: Method called when an SGML declaration is read by the parser.
type: method
pt: HTMLParser
mn: handle_pi
ms: handle_pi(data)
md: Method called when a processing instruction is encountered.
type: method
pt: HTMLParser
mn: msg
ms: msg
md: Reset the instance.
type: member
pt: HTMLParser
mn: crop
ms: crop(image, psize, width, height, x0, y0, x1, y1)
md: Return the selected part of image, which should be width by height in size and consist of pixels of psize bytes.
type: function
pt: imageop
mn: scale
ms: scale(image, psize, width, height, newwidth, newheight)
md: Return image scaled to size newwidth by newheight.
type: function
pt: imageop
mn: tovideo
ms: tovideo(image, psize, width, height)
md: Run a vertical low-pass filter over an image.
type: function
pt: imageop
mn: grey2mono
ms: grey2mono(image, width, height, threshold)
md: Convert a 8-bit deep greyscale image to a 1-bit deep image by thresholding all the pixels.
type: function
pt: imageop
mn: dither2mono
ms: dither2mono(image, width, height)
md: Convert an 8-bit greyscale image to a 1-bit monochrome image using a (simple-minded) dithering algorithm.
type: function
pt: imageop
mn: mono2grey
ms: mono2grey(image, width, height, p0, p1)
md: Convert a 1-bit monochrome image to an 8 bit greyscale or color image.
type: function
pt: imageop
mn: grey2grey4
ms: grey2grey4(image, width, height)
md: Convert an 8-bit greyscale image to a 4-bit greyscale image without dithering.
type: function
pt: imageop
mn: grey2grey2
ms: grey2grey2(image, width, height)
md: Convert an 8-bit greyscale image to a 2-bit greyscale image without dithering.
type: function
pt: imageop
mn: dither2grey2
ms: dither2grey2(image, width, height)
md: Convert an 8-bit greyscale image to a 2-bit greyscale image with dithering.
type: function
pt: imageop
mn: grey42grey
ms: grey42grey(image, width, height)
md: Convert a 4-bit greyscale image to an 8-bit greyscale image.
type: function
pt: imageop
mn: grey22grey
ms: grey22grey(image, width, height)
md: Convert a 2-bit greyscale image to an 8-bit greyscale image.
type: function
pt: imageop
mn: Internaldate2tuple
ms: Internaldate2tuple(datestr)
md: Converts an IMAP4 INTERNALDATE string to Coordinated Universal   Time.
type: function
pt: imaplib
mn: Int2AP
ms: Int2AP(num)
md: Converts an integer into a string representation using characters   from the set [A .
type: function
pt: imaplib
mn: ParseFlags
ms: ParseFlags(flagstr)
md: Converts an IMAP4 "FLAGS" response to a tuple of individual   flags.
type: function
pt: imaplib
mn: Time2Internaldate
ms: Time2Internaldate(date_time)
md: 
type: function
pt: imaplib
mn: what
ms: what(filename[, h])
md: Tests the image data contained in the file named by filename, and returns a string describing the image type.
type: function
pt: imghdr
mn: get_magic
ms: get_magic()
md: 
type: function
pt: imp
mn: get_suffixes
ms: get_suffixes()
md: Return a list of triples, each describing a particular type of module.
type: function
pt: imp
mn: find_module
ms: find_module(name[, path])
md: Try to find the module name on the search path path.
type: function
pt: imp
mn: load_module
ms: load_module(name, file, filename, description)
md: Load a module that was previously found by find_module() (or by an otherwise conducted search yielding compatible results).
type: function
pt: imp
mn: new_module
ms: new_module(name)
md: Return a new empty module object called name.
type: function
pt: imp
mn: lock_held
ms: lock_held()
md: Return True if the import lock is currently held, else False.
type: function
pt: imp
mn: acquire_lock
ms: acquire_lock()
md: Acquires the interpreter's import lock for the current thread.
type: function
pt: imp
mn: release_lock
ms: release_lock()
md: Release the interpreter's import lock.
type: function
pt: imp
mn: init_builtin
ms: init_builtin(name)
md: Initialize the built-in module called name and return its module object.
type: function
pt: imp
mn: init_frozen
ms: init_frozen(name)
md: Initialize the frozen module called name and return its module object.
type: function
pt: imp
mn: is_builtin
ms: is_builtin(name)
md: Return 1 if there is a built-in module called name which can be initialized again.
type: function
pt: imp
mn: is_frozen
ms: is_frozen(name)
md: Return True if there is a frozen module (see init_frozen()) called name, or False if there is no such module.
type: function
pt: imp
mn: load_compiled
ms: load_compiled(name, pathname, [file])
md: 
type: function
pt: imp
mn: load_dynamic
ms: load_dynamic(name, pathname[, file])
md: Load and initialize a module implemented as a dynamically loadable shared library and return its module object.
type: function
pt: imp
mn: load_source
ms: load_source(name, pathname[, file])
md: Load and initialize a module implemented as a Python source file and return its module object.
type: function
pt: imp
mn: find_module
ms: find_module(fullname [, path])
md: This method always returns None, indicating that the requested module could not be found.
type: method
pt: imp
mn: iskeyword
ms: iskeyword(s)
md: Return true if s is a Python keyword.
type: function
pt: keyword
mn: getline
ms: getline(filename, lineno[, module_globals])
md: Get line lineno from file named filename.
type: function
pt: linecache
mn: clearcache
ms: clearcache()
md: Clear the cache.
type: function
pt: linecache
mn: checkcache
ms: checkcache([filename])
md: Check the cache for validity.
type: function
pt: linecache
mn: setlocale
ms: setlocale(category[, locale])
md: If locale is specified, it may be a string, a tuple of the   form (language code, encoding), or None.
type: function
pt: locale
mn: localeconv
ms: localeconv()
md: Returns the database of the local conventions as a dictionary.
type: function
pt: locale
mn: nl_langinfo
ms: nl_langinfo(option)
md: 
type: function
pt: locale
mn: getdefaultlocale
ms: getdefaultlocale([envvars])
md: Tries to determine the default locale settings and returns   them as a tuple of the form (language code,   encoding).
type: function
pt: locale
mn: getlocale
ms: getlocale([category])
md: Returns the current setting for the given locale category as   sequence containing language code, encoding.
type: function
pt: locale
mn: getpreferredencoding
ms: getpreferredencoding([do_setlocale])
md: Return the encoding used for text data, according to user   preferences.
type: function
pt: locale
mn: resetlocale
ms: resetlocale([category])
md: Sets the locale for category to the default setting.
type: function
pt: locale
mn: strcoll
ms: strcoll(string1, string2)
md: Compares two strings according to the current   LC_COLLATE setting.
type: function
pt: locale
mn: strxfrm
ms: strxfrm(string)
md: Transforms a string to one that can be used for the built-in   function cmp()
type: function
pt: locale
mn: format
ms: format(format, val[, grouping[, monetary]])
md: Formats a number val according to the current   LC_NUMERIC setting.
type: function
pt: locale
mn: format_string
ms: format_string(format, val[, grouping])
md: Processes formatting specifiers as in format % val,   but takes the current locale settings into account.
type: function
pt: locale
mn: currency
ms: currency(val[, symbol[, grouping[, international]]])
md: Formats a number val according to the current LC_MONETARY   settings.
type: function
pt: locale
mn: str
ms: str(float)
md: Formats a floating point number using the same format as the   built-in function str(float), but takes the decimal   point into account.
type: function
pt: locale
mn: atof
ms: atof(string)
md: Converts a string to a floating point number, following the   LC_NUMERIC settings.
type: function
pt: locale
mn: atoi
ms: atoi(string)
md: Converts a string to an integer, following the   LC_NUMERIC conventions.
type: function
pt: locale
mn: getLogger
ms: getLogger([name])
md: Return a logger with the specified name or, if no name is specified, return a logger which is the root logger of the hierarchy.
type: function
pt: logging
mn: getLoggerClass
ms: getLoggerClass()
md: Return either the standard Logger class, or the last class passed to setLoggerClass().
type: function
pt: logging
mn: debug
ms: debug(msg[, *args[, **kwargs]])
md: Logs a message with level DEBUG on the root logger.
type: function
pt: logging
mn: info
ms: info(msg[, *args[, **kwargs]])
md: Logs a message with level INFO on the root logger.
type: function
pt: logging
mn: warning
ms: warning(msg[, *args[, **kwargs]])
md: Logs a message with level WARNING on the root logger.
type: function
pt: logging
mn: error
ms: error(msg[, *args[, **kwargs]])
md: Logs a message with level ERROR on the root logger.
type: function
pt: logging
mn: critical
ms: critical(msg[, *args[, **kwargs]])
md: Logs a message with level CRITICAL on the root logger.
type: function
pt: logging
mn: exception
ms: exception(msg[, *args])
md: Logs a message with level ERROR on the root logger.
type: function
pt: logging
mn: log
ms: log(level, msg[, *args[, **kwargs]])
md: Logs a message with level level on the root logger.
type: function
pt: logging
mn: disable
ms: disable(lvl)
md: Provides an overriding level lvl for all loggers which takes precedence over the logger's own level.
type: function
pt: logging
mn: addLevelName
ms: addLevelName(lvl, levelName)
md: Associates level lvl with text levelName in an internal dictionary, which is used to map numeric levels to a textual representation, for example when a Formatter formats a message.
type: function
pt: logging
mn: getLevelName
ms: getLevelName(lvl)
md: Returns the textual representation of logging level lvl.
type: function
pt: logging
mn: makeLogRecord
ms: makeLogRecord(attrdict)
md: Creates and returns a new LogRecord instance whose attributes are defined by attrdict.
type: function
pt: logging
mn: basicConfig
ms: basicConfig([**kwargs])
md: Does basic configuration for the logging system by creating a StreamHandler with a default Formatter and adding it to the root logger.
type: function
pt: logging
mn: shutdown
ms: shutdown()
md: Informs the logging system to perform an orderly shutdown by flushing and closing all handlers.
type: function
pt: logging
mn: setLoggerClass
ms: setLoggerClass(klass)
md: Tells the logging system to use the class klass when instantiating a logger.
type: function
pt: logging
mn: findmatch
ms: findmatch(caps, MIMEtype[, key[,                            filename[, plist]]])
md: Return a 2-tuple; the first element is a string containing the command line to be executed (which can be passed to os.
type: function
pt: mailcap
mn: getcaps
ms: getcaps()
md: Returns a dictionary mapping MIME types to a list of mailcap file entries.
type: function
pt: mailcap
mn: dump
ms: dump(value, file[, version])
md: Write the value on the open file.
type: function
pt: marshal
mn: load
ms: load(file)
md: Read one value from the open file and return it.
type: function
pt: marshal
mn: dumps
ms: dumps(value[, version])
md: Return the string that would be written to a file by   dump(value, file).
type: function
pt: marshal
mn: loads
ms: loads(string)
md: Convert the string to a value.
type: function
pt: marshal
mn: ceil
ms: ceil(x)
md: Return the ceiling of x as a float, the smallest integer value greater than or equal to x.
type: function
pt: math
mn: fabs
ms: fabs(x)
md: Return the absolute value of x.
type: function
pt: math
mn: floor
ms: floor(x)
md: Return the floor of x as a float, the largest integer value less than or equal to x.
type: function
pt: math
mn: fmod
ms: fmod(x, y)
md: Return fmod(x, y), as defined by the platform C library.
type: function
pt: math
mn: frexp
ms: frexp(x)
md: Return the mantissa and exponent of x as the pair (m, e).
type: function
pt: math
mn: ldexp
ms: ldexp(x, i)
md: Return x * (2**i).
type: function
pt: math
mn: modf
ms: modf(x)
md: Return the fractional and integer parts of x.
type: function
pt: math
mn: exp
ms: exp(x)
md: Return e**x.
type: function
pt: math
mn: log
ms: log(x[, base])
md: Return the logarithm of x to the given base.
type: function
pt: math
mn: log10
ms: log10(x)
md: Return the base-10 logarithm of x.
type: function
pt: math
mn: pow
ms: pow(x, y)
md: Return x**y.
type: function
pt: math
mn: sqrt
ms: sqrt(x)
md: Return the square root of x.
type: function
pt: math
mn: acos
ms: acos(x)
md: Return the arc cosine of x, in radians.
type: function
pt: math
mn: asin
ms: asin(x)
md: Return the arc sine of x, in radians.
type: function
pt: math
mn: atan
ms: atan(x)
md: Return the arc tangent of x, in radians.
type: function
pt: math
mn: atan2
ms: atan2(y, x)
md: Return atan(y / x), in radians.
type: function
pt: math
mn: cos
ms: cos(x)
md: Return the cosine of x radians.
type: function
pt: math
mn: hypot
ms: hypot(x, y)
md: Return the Euclidean norm, sqrt(x*x + y*y).
type: function
pt: math
mn: sin
ms: sin(x)
md: Return the sine of x radians.
type: function
pt: math
mn: tan
ms: tan(x)
md: Return the tangent of x radians.
type: function
pt: math
mn: degrees
ms: degrees(x)
md: Converts angle x from radians to degrees.
type: function
pt: math
mn: radians
ms: radians(x)
md: Converts angle x from degrees to radians.
type: function
pt: math
mn: cosh
ms: cosh(x)
md: Return the hyperbolic cosine of x.
type: function
pt: math
mn: sinh
ms: sinh(x)
md: Return the hyperbolic sine of x.
type: function
pt: math
mn: tanh
ms: tanh(x)
md: Return the hyperbolic tangent of x.
type: function
pt: math
mn: new
ms: new([arg])
md: Return a new md5 object.
type: function
pt: md5
mn: md5
ms: md5([arg])
md: For backward compatibility reasons, this is an alternative name for the new() function.
type: function
pt: md5
mn: update
ms: update(arg)
md: Update the md5 object with the string arg.
type: method
pt: md5
mn: digest
ms: digest()
md: Return the digest of the strings passed to the update() method so far.
type: method
pt: md5
mn: hexdigest
ms: hexdigest()
md: Like digest() except the digest is returned as a string of length 32, containing only hexadecimal digits.
type: method
pt: md5
mn: copy
ms: copy()
md: Return a copy (``clone'') of the md5 object.
type: method
pt: md5
mn: choose_boundary
ms: choose_boundary()
md: Return a unique string that has a high likelihood of being usable as a part boundary.
type: function
pt: mimetools
mn: decode
ms: decode(input, output, encoding)
md: Read data encoded using the allowed MIME encoding from open file object input and write the decoded data to open file object output.
type: function
pt: mimetools
mn: encode
ms: encode(input, output, encoding)
md: Read data from open file object input and write it encoded using the allowed MIME encoding to open file object output.
type: function
pt: mimetools
mn: copyliteral
ms: copyliteral(input, output)
md: Read lines from open file input until EOF and write them to open file output.
type: function
pt: mimetools
mn: copybinary
ms: copybinary(input, output)
md: Read blocks until EOF from open file input and write them to open file output.
type: function
pt: mimetools
mn: guess_type
ms: guess_type(filename[, strict])
md: Guess the type of a file based on its filename or URL, given by filename.
type: function
pt: mimetypes
mn: guess_all_extensions
ms: guess_all_extensions(type[, strict])
md: Guess the extensions for a file based on its MIME type, given by type.
type: function
pt: mimetypes
mn: guess_extension
ms: guess_extension(type[, strict])
md: Guess the extension for a file based on its MIME type, given by type.
type: function
pt: mimetypes
mn: init
ms: init([files])
md: Initialize the internal data structures.
type: function
pt: mimetypes
mn: read_mime_types
ms: read_mime_types(filename)
md: Load the type map given in the file filename, if it exists.
type: function
pt: mimetypes
mn: add_type
ms: add_type(type, ext[, strict])
md: Add a mapping from the mimetype type to the extension ext.
type: function
pt: mimetypes
mn: mimify
ms: mimify(infile, outfile)
md: Copy the message in infile to outfile, converting parts to quoted-printable and adding MIME mail headers when necessary.
type: function
pt: mimify
mn: unmimify
ms: unmimify(infile, outfile[, decode_base64])
md: Copy the message in infile to outfile, decoding all quoted-printable parts.
type: function
pt: mimify
mn: mime_decode_header
ms: mime_decode_header(line)
md: Return a decoded version of the encoded header line in line.
type: function
pt: mimify
mn: mime_encode_header
ms: mime_encode_header(line)
md: Return a MIME-encoded version of the header line in line.
type: function
pt: mimify
mn: mmap
ms: mmap(fileno, length[, tagname[, access]])
md: 
type: function
pt: mmap
mn: close
ms: close()
md: Close the file.
type: method
pt: mmap
mn: find
ms: find(string[, start])
md: Returns the lowest index in the object where the substring   string is found.
type: method
pt: mmap
mn: flush
ms: flush([offset, size])
md: Flushes changes made to the in-memory copy of a file back to disk.
type: method
pt: mmap
mn: move
ms: move(dest, src, count)
md: Copy the count bytes starting at offset src to the   destination index dest.
type: method
pt: mmap
mn: read
ms: read(num)
md: Return a string containing up to num bytes starting from the   current file position; the file position is updated to point after the   bytes that were returned.
type: method
pt: mmap
mn: read_byte
ms: read_byte()
md: Returns a string of length 1 containing the character at the current   file position, and advances the file position by 1.
type: method
pt: mmap
mn: readline
ms: readline()
md: Returns a single line, starting at the current file position and up to   the next newline.
type: method
pt: mmap
mn: resize
ms: resize(newsize)
md: Resizes the map and the underlying file, if any.
type: method
pt: mmap
mn: seek
ms: seek(pos[, whence])
md: Set the file's current position.
type: method
pt: mmap
mn: size
ms: size()
md: Return the length of the file, which can be larger than the size of   the memory-mapped area.
type: method
pt: mmap
mn: tell
ms: tell()
md: Returns the current position of the file pointer.
type: method
pt: mmap
mn: write
ms: write(string)
md: Write the bytes in string into memory at the current position   of the file pointer; the file position is updated to point after the   bytes that were written.
type: method
pt: mmap
mn: write_byte
ms: write_byte(byte)
md: Write the single-character string byte into memory at the   current position of the file pointer; the file position is advanced   by 1.
type: method
pt: mmap
mn: AddPackagePath
ms: AddPackagePath(pkg_name, path)
md: Record that the package named pkg_name can be found in the specified path.
type: function
pt: modulefinder
mn: ReplacePackage
ms: ReplacePackage(oldname, newname)
md: Allows specifying that the module named oldname is in fact the package named newname.
type: function
pt: modulefinder
mn: report
ms: report()
md: Print a report to standard output that lists the modules imported by the script and their paths, as well as modules that are missing or seem to be missing.
type: method
pt: modulefinder
mn: run_script
ms: run_script(pathname)
md: Analyze the contents of the pathname file, which must contain  Python code.
type: method
pt: modulefinder
mn: FCICreate
ms: FCICreate(cabname, files)
md: Create a new CAB file named cabname.
type: function
pt: msilib
mn: UUIDCreate
ms: UUIDCreate()
md: Return the string representation of a new unique identifier.
type: function
pt: msilib
mn: OpenDatabase
ms: OpenDatabase(path, persist)
md: Return a new database object by calling MsiOpenDatabase.
type: function
pt: msilib
mn: CreateRecord
ms: CreateRecord(count)
md: Return a new record object by calling MSICreateRecord.
type: function
pt: msilib
mn: init_database
ms: init_database(name, schema, ProductName, ProductCode, ProductVersion, Manufacturer)
md: Create and return a new database name, initialize it    with schema,  and set the properties ProductName,   ProductCode, ProductVersion, and Manufacturer.
type: function
pt: msilib
mn: add_data
ms: add_data(database, records)
md: Add all records to database.
type: function
pt: msilib
mn: add_stream
ms: add_stream(database, name, path)
md: Add the file path into the _Stream table   of database, with the stream name name.
type: function
pt: msilib
mn: gen_uuid
ms: gen_uuid()
md: Return a new UUID, in the format that MSI typically   requires (i.
type: function
pt: msilib
mn: msg
ms: msg
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: netrc
mn: filename
ms: filename
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: netrc
mn: lineno
ms: lineno
md: OCTYPE html PUBLIC "-//W3C//DTD HTML 4.
type: member
pt: netrc
mn: instance
ms: instance(class[, dict])
md: This function creates an instance of class with dictionary dict without calling the __init__() constructor.
type: function
pt: new
mn: instancemethod
ms: instancemethod(function, instance, class)
md: This function will return a method object, bound to instance, or unbound if instance is None.
type: function
pt: new
mn: function
ms: function(code, globals[, name[,                           argdefs[, closure]]])
md: Returns a (Python) function with the given code and globals.
type: function
pt: new
mn: code
ms: code(argcount, nlocals, stacksize, flags, codestring,                       constants, names, varnames, filename, name, firstlineno,                       lnotab)
md: This function is an interface to the PyCode_New() C function.
type: function
pt: new
mn: module
ms: module(name[, doc])
md: This function returns a new module object with name name.
type: function
pt: new
mn: classobj
ms: classobj(name, baseclasses, dict)
md: This function returns a new class object, with name name, derived from baseclasses (which should be a tuple of classes) and with namespace dict.
type: function
pt: new
mn: match
ms: match(key, mapname[, domain=default_domain])
md: Return the match for key in map mapname, or raise an error
type: function
pt: nis
mn: cat
ms: cat(mapname[, domain=default_domain])
md: Return a dictionary mapping key to value such that match(key, mapname)==value.
type: function
pt: nis
mn: maps
ms: maps([domain=default_domain])
md: Return a list of all valid maps.
type: function
pt: nis
mn: get_default_domain
ms: get_default_domain()
md: Return the system default NIS domain.
type: function
pt: nis
mn: lt
ms: lt(a, b)
md: 
type: function
pt: operator
mn: not_
ms: not_(o)
md: 
type: function
pt: operator
mn: truth
ms: truth(o)
md: Return True if o is true, and False otherwise.
type: function
pt: operator
mn: is_
ms: is_(a, b)
md: Return a is b.
type: function
pt: operator
mn: is_not
ms: is_not(a, b)
md: Return a is not b.
type: function
pt: operator
mn: abs
ms: abs(o)
md: 
type: function
pt: operator
mn: add
ms: add(a, b)
md: 
type: function
pt: operator
mn: and_
ms: and_(a, b)
md: 
type: function
pt: operator
mn: div
ms: div(a, b)
md: 
type: function
pt: operator
mn: floordiv
ms: floordiv(a, b)
md: 
type: function
pt: operator
mn: inv
ms: inv(o)
md: 
type: function
pt: operator
mn: lshift
ms: lshift(a, b)
md: 
type: function
pt: operator
mn: mod
ms: mod(a, b)
md: 
type: function
pt: operator
mn: mul
ms: mul(a, b)
md: 
type: function
pt: operator
mn: neg
ms: neg(o)
md: 
type: function
pt: operator
mn: or_
ms: or_(a, b)
md: 
type: function
pt: operator
mn: pos
ms: pos(o)
md: 
type: function
pt: operator
mn: pow
ms: pow(a, b)
md: 
type: function
pt: operator
mn: rshift
ms: rshift(a, b)
md: 
type: function
pt: operator
mn: sub
ms: sub(a, b)
md: 
type: function
pt: operator
mn: truediv
ms: truediv(a, b)
md: 
type: function
pt: operator
mn: xor
ms: xor(a, b)
md: 
type: function
pt: operator
mn: index
ms: index(a)
md: 
type: function
pt: operator
mn: concat
ms: concat(a, b)
md: 
type: function
pt: operator
mn: contains
ms: contains(a, b)
md: 
type: function
pt: operator
mn: countOf
ms: countOf(a, b)
md: Return the number of occurrences of b in a.
type: function
pt: operator
mn: delitem
ms: delitem(a, b)
md: 
type: function
pt: operator
mn: delslice
ms: delslice(a, b, c)
md: 
type: function
pt: operator
mn: getitem
ms: getitem(a, b)
md: 
type: function
pt: operator
mn: getslice
ms: getslice(a, b, c)
md: 
type: function
pt: operator
mn: indexOf
ms: indexOf(a, b)
md: Return the index of the first of occurrence of b in a.
type: function
pt: operator
mn: repeat
ms: repeat(a, b)
md: 
type: function
pt: operator
mn: setitem
ms: setitem(a, b, c)
md: 
type: function
pt: operator
mn: setslice
ms: setslice(a, b, c, v)
md: 
type: function
pt: operator
mn: iadd
ms: iadd(a, b)
md: 
type: function
pt: operator
mn: iand
ms: iand(a, b)
md: 
type: function
pt: operator
mn: iconcat
ms: iconcat(a, b)
md: 
type: function
pt: operator
mn: idiv
ms: idiv(a, b)
md: 
type: function
pt: operator
mn: ifloordiv
ms: ifloordiv(a, b)
md: 
type: function
pt: operator
mn: ilshift
ms: ilshift(a, b)
md: 
type: function
pt: operator
mn: imod
ms: imod(a, b)
md: 
type: function
pt: operator
mn: imul
ms: imul(a, b)
md: 
type: function
pt: operator
mn: ior
ms: ior(a, b)
md: 
type: function
pt: operator
mn: ipow
ms: ipow(a, b)
md: 
type: function
pt: operator
mn: irepeat
ms: irepeat(a, b)
md: 
type: function
pt: operator
mn: irshift
ms: irshift(a, b)
md: 
type: function
pt: operator
mn: isub
ms: isub(a, b)
md: 
type: function
pt: operator
mn: itruediv
ms: itruediv(a, b)
md: 
type: function
pt: operator
mn: ixor
ms: ixor(a, b)
md: 
type: function
pt: operator
mn: isCallable
ms: isCallable(o)
md: Deprecated since release 2.
type: function
pt: operator
mn: isMappingType
ms: isMappingType(o)
md: Returns true if the object o supports the mapping interface.
type: function
pt: operator
mn: isNumberType
ms: isNumberType(o)
md: Returns true if the object o represents a number.
type: function
pt: operator
mn: isSequenceType
ms: isSequenceType(o)
md: Returns true if the object o supports the sequence protocol.
type: function
pt: operator
mn: chdir
ms: chdir(path)
md: 
type: function
pt: os
mn: ctermid
ms: ctermid()
md: Return the filename corresponding to the controlling terminal of the process.
type: function
pt: os
mn: getegid
ms: getegid()
md: Return the effective group id of the current process.
type: function
pt: os
mn: geteuid
ms: geteuid()
md: 
type: function
pt: os
mn: getgid
ms: getgid()
md: 
type: function
pt: os
mn: getgroups
ms: getgroups()
md: Return list of supplemental group ids associated with the current process.
type: function
pt: os
mn: getlogin
ms: getlogin()
md: Return the actual login name for the current process, even if there are multiple login names which map to the same user id.
type: function
pt: os
mn: getpgrp
ms: getpgrp()
md: 
type: function
pt: os
mn: getpid
ms: getpid()
md: 
type: function
pt: os
mn: getppid
ms: getppid()
md: 
type: function
pt: os
mn: getuid
ms: getuid()
md: 
type: function
pt: os
mn: getenv
ms: getenv(varname[, value])
md: Return the value of the environment variable varname if it exists, or value if it doesn't.
type: function
pt: os
mn: putenv
ms: putenv(varname, value)
md: 
type: function
pt: os
mn: setegid
ms: setegid(egid)
md: Set the current process's effective group id.
type: function
pt: os
mn: seteuid
ms: seteuid(euid)
md: Set the current process's effective user id.
type: function
pt: os
mn: setgid
ms: setgid(gid)
md: Set the current process' group id.
type: function
pt: os
mn: setgroups
ms: setgroups(groups)
md: Set the list of supplemental group ids associated with the current process to groups.
type: function
pt: os
mn: setpgrp
ms: setpgrp()
md: Calls the system call setpgrp() or setpgrp(0, 0) depending on which version is implemented (if any).
type: function
pt: os
mn: setpgid
ms: setpgid(pid, pgrp)
md: Calls the system call setpgid() to set the process group id of the process with id pid to the process group with id pgrp.
type: function
pt: os
mn: setreuid
ms: setreuid(ruid, euid)
md: Set the current process's real and effective user ids.
type: function
pt: os
mn: setregid
ms: setregid(rgid, egid)
md: Set the current process's real and effective group ids.
type: function
pt: os
mn: setsid
ms: setsid()
md: Calls the system call setsid().
type: function
pt: os
mn: setuid
ms: setuid(uid)
md: 
type: function
pt: os
mn: strerror
ms: strerror(code)
md: Return the error message corresponding to the error code in code.
type: function
pt: os
mn: umask
ms: umask(mask)
md: Set the current numeric umask and returns the previous umask.
type: function
pt: os
mn: uname
ms: uname()
md: Return a 5-tuple containing information identifying the current operating system.
type: function
pt: os
mn: fdopen
ms: fdopen(fd[, mode[, bufsize]])
md: Return an open file object connected to the file descriptor fd.
type: function
pt: os
mn: popen
ms: popen(command[, mode[, bufsize]])
md: Open a pipe to or from command.
type: function
pt: os
mn: tmpfile
ms: tmpfile()
md: Return a new file object opened in update mode ("w+b").
type: function
pt: os
mn: popen2
ms: popen2(cmd[, mode[, bufsize]])
md: Executes cmd as a sub-process.
type: function
pt: os
mn: popen3
ms: popen3(cmd[, mode[, bufsize]])
md: Executes cmd as a sub-process.
type: function
pt: os
mn: popen4
ms: popen4(cmd[, mode[, bufsize]])
md: Executes cmd as a sub-process.
type: function
pt: os
mn: close
ms: close(fd)
md: Close file descriptor fd.
type: function
pt: os
mn: dup
ms: dup(fd)
md: Return a duplicate of file descriptor fd.
type: function
pt: os
mn: dup2
ms: dup2(fd, fd2)
md: Duplicate file descriptor fd to fd2, closing the latter first if necessary.
type: function
pt: os
mn: fdatasync
ms: fdatasync(fd)
md: Force write of file with filedescriptor fd to disk.
type: function
pt: os
mn: fpathconf
ms: fpathconf(fd, name)
md: Return system configuration information relevant to an open file.
type: function
pt: os
mn: fstat
ms: fstat(fd)
md: Return status for file descriptor fd, like stat().
type: function
pt: os
mn: fstatvfs
ms: fstatvfs(fd)
md: Return information about the filesystem containing the file associated with file descriptor fd, like statvfs().
type: function
pt: os
mn: fsync
ms: fsync(fd)
md: Force write of file with filedescriptor fd to disk.
type: function
pt: os
mn: ftruncate
ms: ftruncate(fd, length)
md: Truncate the file corresponding to file descriptor fd,  so that it is at most length bytes in size.
type: function
pt: os
mn: isatty
ms: isatty(fd)
md: Return 1 if the file descriptor fd is open and connected to a tty(-like) device, else 0.
type: function
pt: os
mn: lseek
ms: lseek(fd, pos, how)
md: Set the current position of file descriptor fd to position pos, modified by how: 0 to set the position relative to the beginning of the file; 1 to set it relative to the current position; 2 to set it relative to the end of the file.
type: function
pt: os
mn: open
ms: open(file, flags[, mode])
md: Open the file file and set various flags according to flags and possibly its mode according to mode.
type: function
pt: os
mn: openpty
ms: openpty()
md: Open a new pseudo-terminal pair.
type: function
pt: os
mn: pipe
ms: pipe()
md: Create a pipe.
type: function
pt: os
mn: read
ms: read(fd, n)
md: Read at most n bytes from file descriptor fd.
type: function
pt: os
mn: tcgetpgrp
ms: tcgetpgrp(fd)
md: Return the process group associated with the terminal given by fd (an open file descriptor as returned by open()).
type: function
pt: os
mn: tcsetpgrp
ms: tcsetpgrp(fd, pg)
md: Set the process group associated with the terminal given by fd (an open file descriptor as returned by open()) to pg.
type: function
pt: os
mn: ttyname
ms: ttyname(fd)
md: Return a string which specifies the terminal device associated with file-descriptor fd.
type: function
pt: os
mn: write
ms: write(fd, str)
md: Write the string str to file descriptor fd.
type: function
pt: os
mn: access
ms: access(path, mode)
md: Use the real uid/gid to test for access to path.
type: function
pt: os
mn: chdir
ms: chdir(path)
md: 
type: function
pt: os
mn: getcwd
ms: getcwd()
md: Return a string representing the current working directory.
type: function
pt: os
mn: chroot
ms: chroot(path)
md: Change the root directory of the current process to path.
type: function
pt: os
mn: chmod
ms: chmod(path, mode)
md: Change the mode of path to the numeric mode.
type: function
pt: os
mn: chown
ms: chown(path, uid, gid)
md: Change the owner and group id of path to the numeric uid and gid.
type: function
pt: os
mn: link
ms: link(src, dst)
md: Create a hard link pointing to src named dst.
type: function
pt: os
mn: listdir
ms: listdir(path)
md: Return a list containing the names of the entries in the directory.
type: function
pt: os
mn: lstat
ms: lstat(path)
md: Like stat(), but do not follow symbolic links.
type: function
pt: os
mn: mkfifo
ms: mkfifo(path[, mode])
md: Create a FIFO (a named pipe) named path with numeric mode mode.
type: function
pt: os
mn: mkdir
ms: mkdir(path[, mode])
md: Create a directory named path with numeric mode mode.
type: function
pt: os
mn: makedirs
ms: makedirs(path[, mode])
md: 
type: function
pt: os
mn: pathconf
ms: pathconf(path, name)
md: Return system configuration information relevant to a named file.
type: function
pt: os
mn: readlink
ms: readlink(path)
md: Return a string representing the path to which the symbolic link points.
type: function
pt: os
mn: remove
ms: remove(path)
md: Remove the file path.
type: function
pt: os
mn: removedirs
ms: removedirs(path)
md: 
type: function
pt: os
mn: rename
ms: rename(src, dst)
md: Rename the file or directory src to dst.
type: function
pt: os
mn: renames
ms: renames(old, new)
md: Recursive directory or file renaming function.
type: function
pt: os
mn: rmdir
ms: rmdir(path)
md: Remove the directory path.
type: function
pt: os
mn: stat
ms: stat(path)
md: Perform a stat() system call on the given path.
type: function
pt: os
mn: statvfs
ms: statvfs(path)
md: Perform a statvfs() system call on the given path.
type: function
pt: os
mn: symlink
ms: symlink(src, dst)
md: Create a symbolic link pointing to src named dst.
type: function
pt: os
mn: tempnam
ms: tempnam([dir[, prefix]])
md: Return a unique path name that is reasonable for creating a temporary file.
type: function
pt: os
mn: tmpnam
ms: tmpnam()
md: Return a unique path name that is reasonable for creating a temporary file.
type: function
pt: os
mn: unlink
ms: unlink(path)
md: Remove the file path.
type: function
pt: os
mn: utime
ms: utime(path, times)
md: Set the access and modified times of the file specified by path.
type: function
pt: os
mn: st_mode
ms: st_mode
md: Perform a statvfs() system call on the given path.
type: member
pt: os
mn: f_frsize
ms: f_frsize
md: Create a symbolic link pointing to src named dst.
type: member
pt: os
mn: abort
ms: abort()
md: Generate a <tt class="constant">SIGABRT signal to the current process.
type: function
pt: os
mn: execv
ms: execv(path, args)
md: 
type: function
pt: os
mn: _exit
ms: _exit(n)
md: Exit to the system with status n, without calling cleanup handlers, flushing stdio buffers, etc.
type: function
pt: os
mn: fork
ms: fork()
md: Fork a child process.
type: function
pt: os
mn: forkpty
ms: forkpty()
md: Fork a child process, using a new pseudo-terminal as the child's controlling terminal.
type: function
pt: os
mn: kill
ms: kill(pid, sig)
md: 
type: function
pt: os
mn: nice
ms: nice(increment)
md: Add increment to the process's ``niceness''.
type: function
pt: os
mn: plock
ms: plock(op)
md: Lock program segments into memory.
type: function
pt: os
mn: spawnv
ms: spawnv(mode, path, args)
md: 
type: function
pt: os
mn: startfile
ms: startfile(path)
md: Start a file with its associated application.
type: function
pt: os
mn: system
ms: system(command)
md: Execute the command (a string) in a subshell.
type: function
pt: os
mn: times
ms: times()
md: Return a 5-tuple of floating point numbers indicating accumulated (processor or other) times, in seconds.
type: function
pt: os
mn: wait
ms: wait()
md: Wait for completion of a child process, and return a tuple containing its pid and exit status indication: a 16-bit number, whose low byte is the signal number that killed the process, and whose high byte is the exit status (if the signal number is zero); the high bit of the low byte is set if a core file was produced.
type: function
pt: os
mn: waitpid
ms: waitpid(pid, options)
md: Wait for completion of a child process given by process id pid, and return a tuple containing its process id and exit status indication (encoded as for wait()).
type: function
pt: os
mn: WIFSTOPPED
ms: WIFSTOPPED(status)
md: Return true if the process has been stopped.
type: function
pt: os
mn: WIFSIGNALED
ms: WIFSIGNALED(status)
md: Return true if the process exited due to a signal.
type: function
pt: os
mn: WIFEXITED
ms: WIFEXITED(status)
md: Return true if the process exited using the system call.
type: function
pt: os
mn: WEXITSTATUS
ms: WEXITSTATUS(status)
md: If WIFEXITED(status) is true, return the integer parameter to the system call.
type: function
pt: os
mn: WSTOPSIG
ms: WSTOPSIG(status)
md: Return the signal which caused the process to stop.
type: function
pt: os
mn: WTERMSIG
ms: WTERMSIG(status)
md: Return the signal which caused the process to exit.
type: function
pt: os
mn: abspath
ms: abspath(path)
md: Return a normalized absolutized version of the pathname path.
type: function
pt: os.path
mn: basename
ms: basename(path)
md: Return the base name of pathname path.
type: function
pt: os.path
mn: commonprefix
ms: commonprefix(list)
md: Return the longest path prefix (taken character-by-character) that is a prefix of all paths in  list.
type: function
pt: os.path
mn: dirname
ms: dirname(path)
md: Return the directory name of pathname path.
type: function
pt: os.path
mn: exists
ms: exists(path)
md: Return True if path refers to an existing path.
type: function
pt: os.path
mn: lexists
ms: lexists(path)
md: Return True if path refers to an existing path.
type: function
pt: os.path
mn: expanduser
ms: expanduser(path)
md: On Unix, return the argument with an initial component of "~" or "~user" replaced by that user's home directory.
type: function
pt: os.path
mn: expandvars
ms: expandvars(path)
md: Return the argument with environment variables expanded.
type: function
pt: os.path
mn: getatime
ms: getatime(path)
md: Return the time of last access of path.
type: function
pt: os.path
mn: getmtime
ms: getmtime(path)
md: Return the time of last modification of path.
type: function
pt: os.path
mn: getctime
ms: getctime(path)
md: Return the system's ctime which, on some systems (like Unix) is the time of the last change, and, on others (like Windows), is the creation time for path.
type: function
pt: os.path
mn: getsize
ms: getsize(path)
md: Return the size, in bytes, of path.
type: function
pt: os.path
mn: isabs
ms: isabs(path)
md: Return True if path is an absolute pathname (begins with a slash).
type: function
pt: os.path
mn: isfile
ms: isfile(path)
md: Return True if path is an existing regular file.
type: function
pt: os.path
mn: isdir
ms: isdir(path)
md: Return True if path is an existing directory.
type: function
pt: os.path
mn: islink
ms: islink(path)
md: Return True if path refers to a directory entry that is a symbolic link.
type: function
pt: os.path
mn: ismount
ms: ismount(path)
md: Return True if pathname path is a mount point: a point in a file system where a different file system has been mounted.
type: function
pt: os.path
mn: normcase
ms: normcase(path)
md: Normalize the case of a pathname.
type: function
pt: os.path
mn: normpath
ms: normpath(path)
md: Normalize a pathname.
type: function
pt: os.path
mn: realpath
ms: realpath(path)
md: Return the canonical path of the specified filename, eliminating any symbolic links encountered in the path (if they are supported by the operating system).
type: function
pt: os.path
mn: samefile
ms: samefile(path1, path2)
md: Return True if both pathname arguments refer to the same file or directory (as indicated by device number and i-node number).
type: function
pt: os.path
mn: sameopenfile
ms: sameopenfile(fp1, fp2)
md: Return True if the file descriptors fp1 and fp2 refer to the same file.
type: function
pt: os.path
mn: samestat
ms: samestat(stat1, stat2)
md: Return True if the stat tuples stat1 and stat2 refer to the same file.
type: function
pt: os.path
mn: split
ms: split(path)
md: Split the pathname path into a pair, (head, tail) where tail is the last pathname component and head is everything leading up to that.
type: function
pt: os.path
mn: splitdrive
ms: splitdrive(path)
md: Split the pathname path into a pair (drive, tail) where drive is either a drive specification or the empty string.
type: function
pt: os.path
mn: splitext
ms: splitext(path)
md: Split the pathname path into a pair (root, ext)  such that root + ext == path, and ext is empty or begins with a period and contains at most one period.
type: function
pt: os.path
mn: splitunc
ms: splitunc(path)
md: Split the pathname path into a pair (unc, rest) so that unc is the UNC mount point (such as r'\\host\mount'), if present, and rest the rest of the path (such as  r'\path\file.
type: function
pt: os.path
mn: walk
ms: walk(path, visit, arg)
md: Calls the function visit with arguments (arg, dirname, names) for each directory in the directory tree rooted at path (including path itself, if it is a directory).
type: function
pt: os.path
mn: errno
ms: errno
md: The name of the operating system dependent module imported.
type: member
pt: os
mn: open
ms: open([device, ]mode)
md: Open an audio device and return an OSS audio device object.
type: function
pt: ossaudiodev
mn: openmixer
ms: openmixer([device])
md: Open a mixer device and return an OSS mixer device object.
type: function
pt: ossaudiodev
mn: run
ms: run(statement[, globals[, locals]])
md: Execute the statement (given as a string) under debugger control.
type: function
pt: pdb
mn: runeval
ms: runeval(expression[, globals[, locals]])
md: Evaluate the expression (given as a string) under debugger control.
type: function
pt: pdb
mn: set_trace
ms: set_trace()
md: Enter the debugger at the calling stack frame.
type: function
pt: pdb
mn: post_mortem
ms: post_mortem(traceback)
md: Enter post-mortem debugging of the given traceback object.
type: function
pt: pdb
mn: pm
ms: pm()
md: Enter post-mortem debugging of the traceback found in sys.
type: function
pt: pdb
mn: dis
ms: dis(pickle[, out=None, memo=None, indentlevel=4])
md: Outputs a symbolic disassembly of the pickle to the file-like object out, defaulting to sys.
type: function
pt: pickletools
mn: genops
ms: genops(pickle)
md: Provides an iterator over all of the opcodes in a pickle, returning a sequence of (opcode, arg, pos) triples.
type: function
pt: pickletools
mn: extend_path
ms: extend_path(path, name)
md: Extend the search path for the modules which comprise a package.
type: function
pt: pkgutil
mn: popen2
ms: popen2(cmd[, bufsize[, mode]])
md: Executes cmd as a sub-process.
type: function
pt: popen2
mn: popen3
ms: popen3(cmd[, bufsize[, mode]])
md: Executes cmd as a sub-process.
type: function
pt: popen2
mn: popen4
ms: popen4(cmd[, bufsize[, mode]])
md: Executes cmd as a sub-process.
type: function
pt: popen2
mn: open
ms: open(filename[, mode[, bufsize]])
md: Create a new posixfile object with the given filename and mode.
type: function
pt: posixfile
mn: fileopen
ms: fileopen(fileobject)
md: Create a new posixfile object with the given standard file object.
type: function
pt: posixfile
mn: lock
ms: lock(fmt, [len[, start[, whence]]])
md: Lock the specified section of the file that the file object is  referring to.
type: function
pt: posixfile
mn: flags
ms: flags([flags])
md: Set the specified flags for the file that the file object is referring  to.
type: function
pt: posixfile
mn: dup
ms: dup()
md: Duplicate the file object and the underlying file pointer and file  descriptor.
type: function
pt: posixfile
mn: dup2
ms: dup2(fd)
md: Duplicate the file object and the underlying file pointer and file  descriptor.
type: function
pt: posixfile
mn: file
ms: file()
md: Return the standard file object that the posixfile object is based  on.
type: function
pt: posixfile
mn: pformat
ms: pformat(object[, indent[,width[, depth]]])
md: Return the formatted representation of object as a string.
type: function
pt: pprint
mn: pprint
ms: pprint(object[, stream[,indent[, width[, depth]]]])
md: Prints the formatted representation of object on stream, followed by a newline.
type: function
pt: pprint
mn: isreadable
ms: isreadable(object)
md: Determine if the formatted representation of object is ``readable,'' or can be used to reconstruct the value using eval()
type: function
pt: pprint
mn: isrecursive
ms: isrecursive(object)
md: Determine if object requires a recursive representation.
type: function
pt: pprint
mn: saferepr
ms: saferepr(object)
md: Return a string representation of object, protected against recursive data structures.
type: function
pt: pprint
mn: run
ms: run(command[, filename])
md: 
type: function
pt: profile
mn: runctx
ms: runctx(command, globals, locals[, filename])
md: This function is similar to run(), with added arguments to supply the globals and locals dictionaries for the command string.
type: function
pt: profile
mn: fork
ms: fork()
md: Fork.
type: function
pt: pty
mn: openpty
ms: openpty()
md: Open a new pseudo-terminal pair, using os.
type: function
pt: pty
mn: spawn
ms: spawn(argv[, master_read[, stdin_read]])
md: Spawn a process, and connect its controlling terminal with the current  process's standard io.
type: function
pt: pty
mn: getpwuid
ms: getpwuid(uid)
md: Return the password database entry for the given numeric user ID.
type: function
pt: pwd
mn: getpwnam
ms: getpwnam(name)
md: Return the password database entry for the given user name.
type: function
pt: pwd
mn: getpwall
ms: getpwall()
md: Return a list of all available password database entries, in arbitrary order.
type: function
pt: pwd
mn: compile
ms: compile(file[, cfile[, dfile[, doraise]]])
md: Compile a source file to byte-code and write out the byte-code cache    file.
type: function
pt: pycompile
mn: main
ms: main([args])
md: Compile several source files.
type: function
pt: pycompile
mn: readmodule
ms: readmodule(module[, path])
md: Read a module and return a dictionary mapping class names to class   descriptor objects.
type: function
pt: pyclbr
mn: readmodule_ex
ms: readmodule_ex(module[, path])
md: Like readmodule(), but the returned dictionary, in addition   to mapping class names to class descriptor objects, also maps   top-level function names to function descriptor objects.
type: function
pt: pyclbr
mn: decode
ms: decode(input, output[,header])
md: Decode the contents of the input file and write the resulting decoded binary data to the output file.
type: function
pt: quopri
mn: encode
ms: encode(input, output, quotetabs)
md: Encode the contents of the input file and write the resulting quoted-printable data to the output file.
type: function
pt: quopri
mn: decodestring
ms: decodestring(s[,header])
md: Like decode(), except that it accepts a source string and returns the corresponding decoded string.
type: function
pt: quopri
mn: encodestring
ms: encodestring(s[, quotetabs])
md: Like encode(), except that it accepts a source string and returns the corresponding encoded string.
type: function
pt: quopri
mn: seed
ms: seed([x])
md: Initialize the basic random number generator.
type: function
pt: random
mn: getstate
ms: getstate()
md: Return an object capturing the current internal state of the   generator.
type: function
pt: random
mn: setstate
ms: setstate(state)
md: state should have been obtained from a previous call to   getstate(), and setstate() restores the   internal state of the generator to what it was at the time   setstate() was called.
type: function
pt: random
mn: jumpahead
ms: jumpahead(n)
md: Change the internal state to one different from and likely far away from   the current state.
type: function
pt: random
mn: getrandbits
ms: getrandbits(k)
md: Returns a python long int with k random bits.
type: function
pt: random
mn: randrange
ms: randrange([start,] stop[, step])
md: Return a randomly selected element from range(start,   stop, step).
type: function
pt: random
mn: randint
ms: randint(a, b)
md: Return a random integer N such that   a &lt;= N &lt;= b.
type: function
pt: random
mn: choice
ms: choice(seq)
md: Return a random element from the non-empty sequence seq.
type: function
pt: random
mn: shuffle
ms: shuffle(x[, random])
md: Shuffle the sequence x in place.
type: function
pt: random
mn: sample
ms: sample(population, k)
md: Return a k length list of unique elements chosen from the   population sequence.
type: function
pt: random
mn: random
ms: random()
md: Return the next random floating point number in the range [0.
type: function
pt: random
mn: uniform
ms: uniform(a, b)
md: Return a random real number N such that   a &lt;= N &lt; b.
type: function
pt: random
mn: betavariate
ms: betavariate(alpha, beta)
md: Beta distribution.
type: function
pt: random
mn: expovariate
ms: expovariate(lambd)
md: Exponential distribution.
type: function
pt: random
mn: gammavariate
ms: gammavariate(alpha, beta)
md: Gamma distribution.
type: function
pt: random
mn: gauss
ms: gauss(mu, sigma)
md: Gaussian distribution.
type: function
pt: random
mn: lognormvariate
ms: lognormvariate(mu, sigma)
md: Log normal distribution.
type: function
pt: random
mn: normalvariate
ms: normalvariate(mu, sigma)
md: Normal distribution.
type: function
pt: random
mn: vonmisesvariate
ms: vonmisesvariate(mu, kappa)
md: mu is the mean angle, expressed in radians between 0 and   2*pi, and kappa is the concentration parameter, which   must be greater than or equal to zero.
type: function
pt: random
mn: paretovariate
ms: paretovariate(alpha)
md: Pareto distribution.
type: function
pt: random
mn: weibullvariate
ms: weibullvariate(alpha, beta)
md: Weibull distribution.
type: function
pt: random
mn: whseed
ms: whseed([x])
md: This is obsolete, supplied for bit-level compatibility with versions   of Python prior to 2.
type: function
pt: random
mn: parse_and_bind
ms: parse_and_bind(string)
md: Parse and execute single line of a readline init file.
type: function
pt: readline
mn: get_line_buffer
ms: get_line_buffer()
md: Return the current contents of the line buffer.
type: function
pt: readline
mn: insert_text
ms: insert_text(string)
md: Insert text into the command line.
type: function
pt: readline
mn: read_init_file
ms: read_init_file([filename])
md: Parse a readline initialization file.
type: function
pt: readline
mn: read_history_file
ms: read_history_file([filename])
md: Load a readline history file.
type: function
pt: readline
mn: write_history_file
ms: write_history_file([filename])
md: Save a readline history file.
type: function
pt: readline
mn: clear_history
ms: clear_history()
md: Clear the current history.
type: function
pt: readline
mn: get_history_length
ms: get_history_length()
md: Return the desired length of the history file.
type: function
pt: readline
mn: set_history_length
ms: set_history_length(length)
md: Set the number of lines to save in the history file.
type: function
pt: readline
mn: get_current_history_length
ms: get_current_history_length()
md: Return the number of lines currently in the history.
type: function
pt: readline
mn: get_history_item
ms: get_history_item(index)
md: Return the current contents of history item at index.
type: function
pt: readline
mn: remove_history_item
ms: remove_history_item(pos)
md: Remove history item specified by its position from the history.
type: function
pt: readline
mn: replace_history_item
ms: replace_history_item(pos, line)
md: Replace history item specified by its position with the given line.
type: function
pt: readline
mn: redisplay
ms: redisplay()
md: Change what's displayed on the screen to reflect the current contents of the line buffer.
type: function
pt: readline
mn: set_startup_hook
ms: set_startup_hook([function])
md: Set or remove the startup_hook function.
type: function
pt: readline
mn: set_pre_input_hook
ms: set_pre_input_hook([function])
md: Set or remove the pre_input_hook function.
type: function
pt: readline
mn: set_completer
ms: set_completer([function])
md: Set or remove the completer function.
type: function
pt: readline
mn: get_completer
ms: get_completer()
md: Get the completer function, or None if no completer function has been set.
type: function
pt: readline
mn: get_begidx
ms: get_begidx()
md: Get the beginning index of the readline tab-completion scope.
type: function
pt: readline
mn: get_endidx
ms: get_endidx()
md: Get the ending index of the readline tab-completion scope.
type: function
pt: readline
mn: set_completer_delims
ms: set_completer_delims(string)
md: Set the readline word delimiters for tab-completion.
type: function
pt: readline
mn: get_completer_delims
ms: get_completer_delims()
md: Get the readline word delimiters for tab-completion.
type: function
pt: readline
mn: add_history
ms: add_history(line)
md: Append a line to the history buffer, as if it was the last line typed.
type: function
pt: readline
mn: repr
ms: repr(obj)
md: This is the repr() method of aRepr.
type: function
pt: repr
mn: quote
ms: quote(str)
md: Return a new string with backslashes in str replaced by two backslashes and double quotes replaced by backslash-double quote.
type: function
pt: rfc822
mn: unquote
ms: unquote(str)
md: Return a new string which is an unquoted version of str.
type: function
pt: rfc822
mn: parseaddr
ms: parseaddr(address)
md: Parse address, which should be the value of some address-containing field such as To: or Cc:, into its constituent ``realname'' and ``email address'' parts.
type: function
pt: rfc822
mn: dump_address_pair
ms: dump_address_pair(pair)
md: The inverse of parseaddr(), this takes a 2-tuple of the form (realname, email_address) and returns the string value suitable for a To: or Cc: header.
type: function
pt: rfc822
mn: parsedate
ms: parsedate(date)
md: Attempts to parse a date
type: function
pt: rfc822
mn: parsedate_tz
ms: parsedate_tz(date)
md: Performs the same function as parsedate(), but returns either None or a 10-tuple; the first 9 elements make up a tuple that can be passed directly to time.
type: function
pt: rfc822
mn: mktime_tz
ms: mktime_tz(tuple)
md: Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp.
type: function
pt: rfc822
mn: sizeofimage
ms: sizeofimage(file)
md: This function returns a tuple (x, y) where x and y are the size of the image in pixels.
type: function
pt: rgbimg
mn: longimagedata
ms: longimagedata(file)
md: This function reads and decodes the image on the specified file, and returns it as a Python string.
type: function
pt: rgbimg
mn: longstoimage
ms: longstoimage(data, x, y, z, file)
md: This function writes the RGBA data in data to image file file.
type: function
pt: rgbimg
mn: ttob
ms: ttob(flag)
md: This function sets a global flag which defines whether the scan lines of the image are read or written from bottom to top (flag is zero, compatible with SGI GL) or from top to bottom (flag is one, compatible with X).
type: function
pt: rgbimg
mn: set_url
ms: set_url(url)
md: Sets the URL referring to a robots.
type: method
pt: robotparser
mn: read
ms: read()
md: Reads the robots.
type: method
pt: robotparser
mn: parse
ms: parse(lines)
md: Parses the lines argument.
type: method
pt: robotparser
mn: can_fetch
ms: can_fetch(useragent, url)
md: Returns True if the useragent is allowed to fetch the url according to the rules contained in the parsed robots.
type: method
pt: robotparser
mn: mtime
ms: mtime()
md: Returns the time the robots.
type: method
pt: robotparser
mn: modified
ms: modified()
md: Sets the time the robots.
type: method
pt: robotparser
mn: run_module
ms: run_module(mod_name[, init_globals][, run_name][, alter_sys])
md: Execute the code of the specified module and return the resulting module globals dictionary.
type: function
pt: runpy
mn: frame
ms: frame
md: The frame which surrounds the text and scroll bar widgets.
type: member
pt: ScrolledText
mn: vbar
ms: vbar
md: The scroll bar widget.
type: member
pt: ScrolledText
mn: poll
ms: poll()
md: (Not supported by all operating systems.
type: function
pt: select
mn: select
ms: select(iwtd, owtd, ewtd[, timeout])
md: This is a straightforward interface to the Unix select() system call.
type: function
pt: select
mn: reset
ms: reset()
md: Reset the instance.
type: method
pt: sgmllib
mn: setnomoretags
ms: setnomoretags()
md: Stop processing tags.
type: method
pt: sgmllib
mn: setliteral
ms: setliteral()
md: Enter literal mode (CDATA mode).
type: method
pt: sgmllib
mn: feed
ms: feed(data)
md: Feed some text to the parser.
type: method
pt: sgmllib
mn: close
ms: close()
md: Force processing of all buffered data as if it were followed by an end-of-file mark.
type: method
pt: sgmllib
mn: get_starttag_text
ms: get_starttag_text()
md: Return the text of the most recently opened start tag.
type: method
pt: sgmllib
mn: handle_starttag
ms: handle_starttag(tag, method, attributes)
md: This method is called to handle start tags for which either a start_tag() or do_tag() method has been defined.
type: method
pt: sgmllib
mn: handle_endtag
ms: handle_endtag(tag, method)
md: This method is called to handle endtags for which an end_tag() method has been defined.
type: method
pt: sgmllib
mn: handle_data
ms: handle_data(data)
md: This method is called to process arbitrary data.
type: method
pt: sgmllib
mn: handle_charref
ms: handle_charref(ref)
md: This method is called to process a character reference of the form "&amp;#ref;".
type: method
pt: sgmllib
mn: convert_charref
ms: convert_charref(ref)
md: Convert a character reference to a string, or None.
type: method
pt: sgmllib
mn: convert_codepoint
ms: convert_codepoint(codepoint)
md: Convert a codepoint to a str value.
type: method
pt: sgmllib
mn: handle_entityref
ms: handle_entityref(ref)
md: This method is called to process a general entity reference of the form "&amp;ref;" where ref is an general entity reference.
type: method
pt: sgmllib
mn: convert_entityref
ms: convert_entityref(ref)
md: Convert a named entity reference to a str value, or None.
type: method
pt: sgmllib
mn: handle_comment
ms: handle_comment(comment)
md: This method is called when a comment is encountered.
type: method
pt: sgmllib
mn: handle_decl
ms: handle_decl(data)
md: Method called when an SGML declaration is read by the parser.
type: method
pt: sgmllib
mn: report_unbalanced
ms: report_unbalanced(tag)
md: This method is called when an end tag is found which does not correspond to any open element.
type: method
pt: sgmllib
mn: unknown_starttag
ms: unknown_starttag(tag, attributes)
md: This method is called to process an unknown start tag.
type: method
pt: sgmllib
mn: unknown_endtag
ms: unknown_endtag(tag)
md: This method is called to process an unknown end tag.
type: method
pt: sgmllib
mn: unknown_charref
ms: unknown_charref(ref)
md: This method is called to process unresolvable numeric character references.
type: method
pt: sgmllib
mn: unknown_entityref
ms: unknown_entityref(ref)
md: This method is called to process an unknown entity reference.
type: method
pt: sgmllib
mn: entitydefs
ms: entitydefs
md: Convert a named entity reference to a str value, or None.
type: member
pt: sgmllib
mn: new
ms: new([string])
md: Return a new sha object.
type: function
pt: sha
mn: update
ms: update(arg)
md: Update the sha object with the string arg.
type: method
pt: sha
mn: digest
ms: digest()
md: Return the digest of the strings passed to the update() method so far.
type: method
pt: sha
mn: hexdigest
ms: hexdigest()
md: Like digest() except the digest is returned as a string of length 40, containing only hexadecimal digits.
type: method
pt: sha
mn: copy
ms: copy()
md: Return a copy (``clone'') of the sha object.
type: method
pt: sha
mn: open
ms: open(filename[,flag='c'[,protocol=None[,writeback=False]]])
md: Open a persistent dictionary.
type: function
pt: shelve
mn: sync
ms: sync()
md: Write back all entries in the cache if the shelf was opened with writeback set to True.
type: method
pt: shelve
mn: split
ms: split(s[, comments])
md: Split the string s using shell-like syntax.
type: function
pt: shlex
mn: commenters
ms: commenters
md: A shlex instance or subclass instance is a lexical analyzer object.
type: member
pt: shlex
mn: infile
ms: infile
md: 
type: member
pt: shlex
mn: copyfile
ms: copyfile(src, dst)
md: Copy the contents of the file named src to a file named   dst.
type: function
pt: shutil
mn: copyfileobj
ms: copyfileobj(fsrc, fdst[, length])
md: Copy the contents of the file-like object fsrc to the   file-like object fdst.
type: function
pt: shutil
mn: copymode
ms: copymode(src, dst)
md: Copy the permission bits from src to dst.
type: function
pt: shutil
mn: copystat
ms: copystat(src, dst)
md: Copy the permission bits, last access time, and last modification   time from src to dst.
type: function
pt: shutil
mn: copy
ms: copy(src, dst)
md: Copy the file src to the file or directory dst.
type: function
pt: shutil
mn: copy2
ms: copy2(src, dst)
md: Similar to copy(), but last access time and last   modification time are copied as well.
type: function
pt: shutil
mn: copytree
ms: copytree(src, dst[, symlinks])
md: Recursively copy an entire directory tree rooted at src.
type: function
pt: shutil
mn: rmtree
ms: rmtree(path[, ignore_errors[, onerror]])
md: 
type: function
pt: shutil
mn: move
ms: move(src, dst)
md: Recursively move a file or directory to another location.
type: function
pt: shutil
mn: alarm
ms: alarm(time)
md: If time is non-zero, this function requests that a   SIGALRM signal be sent to the process in time seconds.
type: function
pt: signal
mn: getsignal
ms: getsignal(signalnum)
md: Return the current signal handler for the signal signalnum.
type: function
pt: signal
mn: pause
ms: pause()
md: Cause the process to sleep until a signal is received; the   appropriate handler will then be called.
type: function
pt: signal
mn: signal
ms: signal(signalnum, handler)
md: Set the handler for signal signalnum to the function   handler.
type: function
pt: signal
mn: do_HEAD
ms: do_HEAD()
md: This method serves the 'HEAD' request type: it sends the headers it would send for the equivalent GET request.
type: method
pt: SimpleHTTPServer
mn: do_GET
ms: do_GET()
md: The request is mapped to a local file by interpreting the request as a path relative to the current working directory.
type: method
pt: SimpleHTTPServer
mn: server_version
ms: server_version
md: This will be "SimpleHTTP/" + __version__, where __version__ is defined in the module.
type: member
pt: SimpleHTTPServer
mn: extensions_map
ms: extensions_map
md: A dictionary mapping suffixes into MIME types.
type: member
pt: SimpleHTTPServer
mn: smtp_code
ms: smtp_code
md: Sender address refused.
type: member
pt: smtplib
mn: recipients
ms: recipients
md: The SMTP server refused to accept the message data.
type: member
pt: smtplib
mn: what
ms: what(filename)
md: Determines the type of sound data stored in the file filename   using whathdr().
type: function
pt: sndhdr
mn: whathdr
ms: whathdr(filename)
md: Determines the type of sound data stored in a file based on the file    header.
type: function
pt: sndhdr
mn: getaddrinfo
ms: getaddrinfo(host, port[, family[,                              socktype[, proto[,                              flags]]]])
md: Resolves the host/port argument, into a sequence of 5-tuples that contain all the necessary argument for the sockets manipulation.
type: function
pt: socket
mn: getfqdn
ms: getfqdn([name])
md: Return a fully qualified domain name for name.
type: function
pt: socket
mn: gethostbyname
ms: gethostbyname(hostname)
md: Translate a host name to IPv4 address format.
type: function
pt: socket
mn: gethostbyname_ex
ms: gethostbyname_ex(hostname)
md: Translate a host name to IPv4 address format, extended interface.
type: function
pt: socket
mn: gethostname
ms: gethostname()
md: Return a string containing the hostname of the machine where  the Python interpreter is currently executing.
type: function
pt: socket
mn: gethostbyaddr
ms: gethostbyaddr(ip_address)
md: Return a triple (hostname, aliaslist, ipaddrlist) where hostname is the primary host name responding to the given ip_address, aliaslist is a (possibly empty) list of alternative host names for the same address, and ipaddrlist is a list of IPv4/v6 addresses for the same interface on the same host (most likely containing only a single address).
type: function
pt: socket
mn: getprotobyname
ms: getprotobyname(protocolname)
md: Translate an Internet protocol name (for example, 'icmp') to a constant suitable for passing as the (optional) third argument to the socket() function.
type: function
pt: socket
mn: getservbyname
ms: getservbyname(servicename[, protocolname])
md: Translate an Internet service name and protocol name to a port number for that service.
type: function
pt: socket
mn: getservbyport
ms: getservbyport(port[, protocolname])
md: Translate an Internet port number and protocol name to a service name for that service.
type: function
pt: socket
mn: socket
ms: socket([family[,                         type[, proto]]])
md: Create a new socket using the given address family, socket type and protocol number.
type: function
pt: socket
mn: ssl
ms: ssl(sock[, keyfile, certfile])
md: Initiate a SSL connection over the socket sock.
type: function
pt: socket
mn: socketpair
ms: socketpair([family[, type[, proto]]])
md: Build a pair of connected socket objects using the given address family, socket type, and protocol number.
type: function
pt: socket
mn: fromfd
ms: fromfd(fd, family, type[, proto])
md: Duplicate the file descriptor fd (an integer as returned by a file object's fileno() method) and build a socket object from the result.
type: function
pt: socket
mn: ntohl
ms: ntohl(x)
md: Convert 32-bit integers from network to host byte order.
type: function
pt: socket
mn: ntohs
ms: ntohs(x)
md: Convert 16-bit integers from network to host byte order.
type: function
pt: socket
mn: htonl
ms: htonl(x)
md: Convert 32-bit integers from host to network byte order.
type: function
pt: socket
mn: htons
ms: htons(x)
md: Convert 16-bit integers from host to network byte order.
type: function
pt: socket
mn: inet_aton
ms: inet_aton(ip_string)
md: Convert an IPv4 address from dotted-quad string format (for example, '123.
type: function
pt: socket
mn: inet_ntoa
ms: inet_ntoa(packed_ip)
md: Convert a 32-bit packed IPv4 address (a string four characters in length) to its standard dotted-quad string representation (for example, '123.
type: function
pt: socket
mn: inet_pton
ms: inet_pton(address_family, ip_string)
md: Convert an IP address from its family-specific string format to a packed, binary format.
type: function
pt: socket
mn: inet_ntop
ms: inet_ntop(address_family, packed_ip)
md: Convert a packed IP address (a string of some number of characters) to its standard, family-specific string representation (for example, '7.
type: function
pt: socket
mn: getdefaulttimeout
ms: getdefaulttimeout()
md: Return the default timeout in floating seconds for new socket objects.
type: function
pt: socket
mn: setdefaulttimeout
ms: setdefaulttimeout(timeout)
md: Set the default timeout in floating seconds for new socket objects.
type: function
pt: socket
mn: getspnam
ms: getspnam(name)
md: Return the shadow password database entry for the given user name.
type: function
pt: spwd (Unix)
mn: getspall
ms: getspall()
md: Return a list of all available shadow password database entries, in arbitrary order.
type: function
pt: spwd (Unix)
mn: S_ISDIR
ms: S_ISDIR(mode)
md: Return non-zero if the mode is from a directory.
type: function
pt: stat
mn: S_ISCHR
ms: S_ISCHR(mode)
md: Return non-zero if the mode is from a character special device file.
type: function
pt: stat
mn: S_ISBLK
ms: S_ISBLK(mode)
md: Return non-zero if the mode is from a block special device file.
type: function
pt: stat
mn: S_ISREG
ms: S_ISREG(mode)
md: Return non-zero if the mode is from a regular file.
type: function
pt: stat
mn: S_ISFIFO
ms: S_ISFIFO(mode)
md: Return non-zero if the mode is from a FIFO (named pipe).
type: function
pt: stat
mn: S_ISLNK
ms: S_ISLNK(mode)
md: Return non-zero if the mode is from a symbolic link.
type: function
pt: stat
mn: S_ISSOCK
ms: S_ISSOCK(mode)
md: Return non-zero if the mode is from a socket.
type: function
pt: stat
mn: S_IMODE
ms: S_IMODE(mode)
md: Return the portion of the file's mode that can be set by os.
type: function
pt: stat
mn: S_IFMT
ms: S_IFMT(mode)
md: Return the portion of the file's mode that describes the file type (used by the S_IS*() functions above).
type: function
pt: stat
mn: getvalue
ms: getvalue()
md: Retrieve the entire contents of the ``file'' at any time before the StringIO object's close() method is called.
type: method
pt: StringIO
mn: close
ms: close()
md: Free the memory buffer.
type: method
pt: StringIO
mn: in_table_a1
ms: in_table_a1(code)
md: Determine whether code is in tableA.
type: function
pt: stringprep
mn: in_table_b1
ms: in_table_b1(code)
md: Determine whether code is in tableB.
type: function
pt: stringprep
mn: map_table_b2
ms: map_table_b2(code)
md: Return the mapped value for code according to tableB.
type: function
pt: stringprep
mn: map_table_b3
ms: map_table_b3(code)
md: Return the mapped value for code according to tableB.
type: function
pt: stringprep
mn: in_table_c11
ms: in_table_c11(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c12
ms: in_table_c12(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c11_c12
ms: in_table_c11_c12(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c21
ms: in_table_c21(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c22
ms: in_table_c22(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c21_c22
ms: in_table_c21_c22(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c3
ms: in_table_c3(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c4
ms: in_table_c4(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c5
ms: in_table_c5(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c6
ms: in_table_c6(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c7
ms: in_table_c7(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c8
ms: in_table_c8(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_c9
ms: in_table_c9(code)
md: Determine whether code is in tableC.
type: function
pt: stringprep
mn: in_table_d1
ms: in_table_d1(code)
md: Determine whether code is in tableD.
type: function
pt: stringprep
mn: in_table_d2
ms: in_table_d2(code)
md: Determine whether code is in tableD.
type: function
pt: stringprep
mn: unpack
ms: unpack(fmt, string)
md: Unpack the string (presumably packed by pack(fmt,    .
type: function
pt: struct
mn: unpack_from
ms: unpack_from(fmt, buffer[,offset = 0])
md: Unpack the buffer according to tthe given format.
type: function
pt: struct
mn: calcsize
ms: calcsize(fmt)
md: Return the size of the struct (and hence of the string)   corresponding to the given format.
type: function
pt: struct
mn: open
ms: open(file, mode)
md: If file is a string, open the file by that name, otherwise treat it as a seekable file-like object.
type: function
pt: sunau
mn: openfp
ms: openfp(file, mode)
md: A synonym for open, maintained for backwards compatibility.
type: function
pt: sunau
mn: open
ms: open(mode)
md: This function opens the audio device and returns a Sun audio device object.
type: function
pt: sunaudiodev
mn: syslog
ms: syslog([priority,] message)
md: Send the string message to the system logger.
type: function
pt: syslog
mn: openlog
ms: openlog(ident[, logopt[, facility]])
md: Logging options other than the defaults can be set by explicitly opening the log file with openlog() prior to calling syslog().
type: function
pt: syslog
mn: closelog
ms: closelog()
md: Close the log file.
type: function
pt: syslog
mn: setlogmask
ms: setlogmask(maskpri)
md: Set the priority mask to maskpri and return the previous mask value.
type: function
pt: syslog
mn: check
ms: check(file_or_dir)
md: 
type: function
pt: tabnanny
mn: tokeneater
ms: tokeneater(type, token, start, end, line)
md: This function is used by check() as a callback parameter to   the function tokenize.
type: function
pt: tabnanny
mn: open
ms: open([name[, mode                       [, fileobj[, bufsize]]]])
md: Return a TarFile object for the pathname name.
type: function
pt: tarfile
mn: is_tarfile
ms: is_tarfile(name)
md: 
type: function
pt: tarfile
mn: TemporaryFile
ms: TemporaryFile([mode='w+b'[,                                bufsize=-1[,                                suffix[, prefix[, dir]]]]])
md: Return a file (or file-like) object that can be used as a temporary storage area.
type: function
pt: tempfile
mn: NamedTemporaryFile
ms: NamedTemporaryFile([mode='w+b'[,                                     bufsize=-1[,                                     suffix[, prefix[,                                     dir]]]]])
md: This function operates exactly as TemporaryFile() does, except that the file is guaranteed to have a visible name in the file system (on Unix, the directory entry is not unlinked).
type: function
pt: tempfile
mn: mkstemp
ms: mkstemp([suffix[,                          prefix[, dir[, text]]]])
md: Creates a temporary file in the most secure manner possible.
type: function
pt: tempfile
mn: mkdtemp
ms: mkdtemp([suffix[, prefix[, dir]]])
md: Creates a temporary directory in the most secure manner possible.
type: function
pt: tempfile
mn: mktemp
ms: mktemp([suffix[, prefix[, dir]]])
md: Deprecated since release 2.
type: function
pt: tempfile
mn: gettempdir
ms: gettempdir()
md: Return the directory currently selected to create temporary files in.
type: function
pt: tempfile
mn: gettempprefix
ms: gettempprefix()
md: Return the filename prefix used to create temporary files.
type: function
pt: tempfile
mn: name
ms: name
md: Creates a temporary file in the most secure manner possible.
type: member
pt: tempfile
mn: tcgetattr
ms: tcgetattr(fd)
md: Return a list containing the tty attributes for file descriptor fd, as follows: [iflag, oflag, cflag, lflag, ispeed, ospeed, cc] where cc is a list of the tty special characters (each a string of length 1, except the items with indices VMIN and VTIME, which are integers when these fields are defined).
type: function
pt: termios
mn: tcsetattr
ms: tcsetattr(fd, when, attributes)
md: Set the tty attributes for file descriptor fd from the attributes, which is a list like the one returned by tcgetattr().
type: function
pt: termios
mn: tcsendbreak
ms: tcsendbreak(fd, duration)
md: Send a break on file descriptor fd.
type: function
pt: termios
mn: tcdrain
ms: tcdrain(fd)
md: Wait until all output written to file descriptor fd has been transmitted.
type: function
pt: termios
mn: tcflush
ms: tcflush(fd, queue)
md: Discard queued data on file descriptor fd.
type: function
pt: termios
mn: tcflow
ms: tcflow(fd, action)
md: Suspend or resume input or output on file descriptor fd.
type: function
pt: termios
mn: forget
ms: forget(module_name)
md: Removes the module named module_name from sys.
type: function
pt: test.testsupport
mn: is_resource_enabled
ms: is_resource_enabled(resource)
md: Returns True if resource is enabled and available.
type: function
pt: test.testsupport
mn: requires
ms: requires(resource[, msg])
md: Raises ResourceDenied if resource is not available.
type: function
pt: test.testsupport
mn: findfile
ms: findfile(filename)
md: Return the path to the file named filename.
type: function
pt: test.testsupport
mn: run_unittest
ms: run_unittest(*classes)
md: Execute unittest.
type: function
pt: test.testsupport
mn: run_suite
ms: run_suite(suite[, testclass])
md: Execute the unittest.
type: function
pt: test.testsupport
mn: dedent
ms: dedent(text)
md: Remove any common leading whitespace from every line in text.
type: function
pt: textwrap
mn: wrap
ms: wrap(text)
md: Wraps the single paragraph in text (a string) so every line is at most width characters long.
type: method
pt: textwrap
mn: fill
ms: fill(text)
md: Wraps the single paragraph in text, and returns a single string containing the wrapped paragraph.
type: method
pt: textwrap
mn: width
ms: width
md: (default: 70) The maximum length of wrapped lines.
type: member
pt: textwrap
mn: expand_tabs
ms: expand_tabs
md: (default: True) If true, then all tab characters in text will be expanded to spaces using the expandtabs() method of text.
type: member
pt: textwrap
mn: replace_whitespace
ms: replace_whitespace
md: (default: True) If true, each whitespace character (as defined by string.
type: member
pt: textwrap
mn: initial_indent
ms: initial_indent
md: (default: '') String that will be prepended to the first line of wrapped output.
type: member
pt: textwrap
mn: subsequent_indent
ms: subsequent_indent
md: (default: '') String that will be prepended to all lines of wrapped output except the first.
type: member
pt: textwrap
mn: fix_sentence_endings
ms: fix_sentence_endings
md: (default: False) If true, TextWrapper attempts to detect sentence endings and ensure that sentences are always separated by exactly two spaces.
type: member
pt: textwrap
mn: break_long_words
ms: break_long_words
md: (default: True) If true, then words longer than width will be broken in order to ensure that no lines are longer than width.
type: member
pt: textwrap
mn: start_new_thread
ms: start_new_thread(function, args[, kwargs])
md: Start a new thread and return its identifier.
type: function
pt: thread
mn: interrupt_main
ms: interrupt_main()
md: Raise a KeyboardInterrupt exception in the main thread.
type: function
pt: thread
mn: exit
ms: exit()
md: Raise the SystemExit exception.
type: function
pt: thread
mn: allocate_lock
ms: allocate_lock()
md: Return a new lock object.
type: function
pt: thread
mn: get_ident
ms: get_ident()
md: Return the `thread identifier' of the current thread.
type: function
pt: thread
mn: stack_size
ms: stack_size([size])
md: Return the thread stack size used when creating new threads.
type: function
pt: thread
mn: acquire
ms: acquire([waitflag])
md: Without the optional argument, this method acquires the lock unconditionally, if necessary waiting until it is released by another thread (only one thread at a time can acquire a lock -- that's their reason for existence).
type: method
pt: thread
mn: release
ms: release()
md: Releases the lock.
type: method
pt: thread
mn: locked
ms: locked()
md: Return the status of the lock: True if it has been acquired by some thread, False if not.
type: method
pt: thread
mn: activeCount
ms: activeCount()
md: Return the number of Thread objects currently alive.
type: function
pt: threading
mn: Condition
ms: Condition()
md: A factory function that returns a new condition variable object.
type: function
pt: threading
mn: currentThread
ms: currentThread()
md: Return the current Thread object, corresponding to the caller's thread of control.
type: function
pt: threading
mn: enumerate
ms: enumerate()
md: Return a list of all Thread objects currently alive.
type: function
pt: threading
mn: Event
ms: Event()
md: A factory function that returns a new event object.
type: function
pt: threading
mn: Lock
ms: Lock()
md: A factory function that returns a new primitive lock object.
type: function
pt: threading
mn: RLock
ms: RLock()
md: A factory function that returns a new reentrant lock object.
type: function
pt: threading
mn: Semaphore
ms: Semaphore([value])
md: A factory function that returns a new semaphore object.
type: function
pt: threading
mn: BoundedSemaphore
ms: BoundedSemaphore([value])
md: A factory function that returns a new bounded semaphore object.
type: function
pt: threading
mn: settrace
ms: settrace(func)
md: Set a trace function for all threads started from the threading module.
type: function
pt: threading
mn: setprofile
ms: setprofile(func)
md: Set a profile function for all threads started from the threading module.
type: function
pt: threading
mn: stack_size
ms: stack_size([size])
md: Return the thread stack size used when creating new threads.
type: function
pt: threading
mn: asctime
ms: asctime([t])
md: Convert a tuple or struct_time representing a time as returned by gmtime() or localtime() to a 24-character string of the following form: 'Sun Jun 20 23:21:05 1993'.
type: function
pt: time
mn: clock
ms: clock()
md: On Unix, return the current processor time as a floating point number expressed in seconds.
type: function
pt: time
mn: ctime
ms: ctime([secs])
md: Convert a time expressed in seconds since the epoch to a string representing local time.
type: function
pt: time
mn: gmtime
ms: gmtime([secs])
md: Convert a time expressed in seconds since the epoch to a struct_time in UTC in which the dst flag is always zero.
type: function
pt: time
mn: localtime
ms: localtime([secs])
md: Like gmtime() but converts to local time.
type: function
pt: time
mn: mktime
ms: mktime(t)
md: This is the inverse function of localtime().
type: function
pt: time
mn: sleep
ms: sleep(secs)
md: Suspend execution for the given number of seconds.
type: function
pt: time
mn: strftime
ms: strftime(format[, t])
md: Convert a tuple or struct_time representing a time as returned by gmtime() or localtime() to a string as specified by the format argument.
type: function
pt: time
mn: strptime
ms: strptime(string[, format])
md: Parse a string representing a time according to a format.
type: function
pt: time
mn: time
ms: time()
md: Return the time as a floating point number expressed in seconds since the epoch, in UTC.
type: function
pt: time
mn: tzset
ms: tzset()
md: Resets the time conversion rules used by the library routines.
type: function
pt: time
mn: tm_year
ms: tm_year
md: Boolean value indicating whether two-digit year values will be accepted.
type: member
pt: time
mn: print_exc
ms: print_exc([file=None])
md: Helper to print a traceback from the timed code.
type: method
pt: timeit
mn: repeat
ms: repeat([repeat=3 [,                           number=1000000]])
md: Call timeit() a few times.
type: method
pt: timeit
mn: timeit
ms: timeit([number=1000000])
md: Time number executions of the main statement.
type: method
pt: timeit
mn: ISTERMINAL
ms: ISTERMINAL(x)
md: Return true for terminal token values.
type: function
pt: token
mn: ISNONTERMINAL
ms: ISNONTERMINAL(x)
md: Return true for non-terminal token values.
type: function
pt: token
mn: ISEOF
ms: ISEOF(x)
md: Return true if x is the marker indicating the end of input.
type: function
pt: token
mn: generate_tokens
ms: generate_tokens(readline)
md: The generate_tokens() generator requires one argment,   readline, which must be a callable object which   provides the same interface as the readline() method of   built-in file objects
type: function
pt: tokenize
mn: tokenize
ms: tokenize(readline[, tokeneater])
md: The tokenize() function accepts two parameters: one   representing the input stream, and one providing an output mechanism   for tokenize().
type: function
pt: tokenize
mn: untokenize
ms: untokenize(iterable)
md: Converts tokens back into Python source code.
type: function
pt: tokenize
mn: print_tb
ms: print_tb(traceback[, limit[, file]])
md: Print up to limit stack trace entries from traceback.
type: function
pt: traceback
mn: print_exception
ms: print_exception(type, value, traceback[,                                  limit[, file]])
md: Print exception information and up to limit stack trace entries from traceback to file.
type: function
pt: traceback
mn: print_exc
ms: print_exc([limit[, file]])
md: This is a shorthand for print_exception(sys.
type: function
pt: traceback
mn: format_exc
ms: format_exc([limit])
md: This is like print_exc(limit) but returns a string instead of printing to a file.
type: function
pt: traceback
mn: print_last
ms: print_last([limit[, file]])
md: This is a shorthand for print_exception(sys.
type: function
pt: traceback
mn: print_stack
ms: print_stack([f[, limit[, file]]])
md: This function prints a stack trace from its invocation point.
type: function
pt: traceback
mn: extract_tb
ms: extract_tb(traceback[, limit])
md: Return a list of up to limit ``pre-processed'' stack trace entries extracted from the traceback object traceback.
type: function
pt: traceback
mn: extract_stack
ms: extract_stack([f[, limit]])
md: Extract the raw traceback from the current stack frame.
type: function
pt: traceback
mn: format_list
ms: format_list(list)
md: Given a list of tuples as returned by extract_tb() or extract_stack(), return a list of strings ready for printing.
type: function
pt: traceback
mn: format_exception_only
ms: format_exception_only(type, value)
md: Format the exception part of a traceback.
type: function
pt: traceback
mn: format_exception
ms: format_exception(type, value, tb[, limit])
md: Format a stack trace and the exception information.
type: function
pt: traceback
mn: format_tb
ms: format_tb(tb[, limit])
md: A shorthand for format_list(extract_tb(tb, limit)).
type: function
pt: traceback
mn: format_stack
ms: format_stack([f[, limit]])
md: A shorthand for format_list(extract_stack(f, limit)).
type: function
pt: traceback
mn: tb_lineno
ms: tb_lineno(tb)
md: This function returns the current line number set in the traceback object.
type: function
pt: traceback
mn: setraw
ms: setraw(fd[, when])
md: Change the mode of the file descriptor fd to raw.
type: function
pt: tty
mn: setcbreak
ms: setcbreak(fd[, when])
md: Change the mode of file descriptor fd to cbreak.
type: function
pt: tty
mn: degrees
ms: degrees()
md: Set angle measurement units to degrees.
type: function
pt: turtle
mn: radians
ms: radians()
md: Set angle measurement units to radians.
type: function
pt: turtle
mn: setup
ms: setup(**kwargs)
md: Sets the size and position of the main window.
type: function
pt: turtle
mn: title
ms: title(title_str)
md: Set the window's title to title.
type: function
pt: turtle
mn: done
ms: done()
md: Enters the Tk main loop.
type: function
pt: turtle
mn: reset
ms: reset()
md: Clear the screen, re-center the pen, and set variables to the default values.
type: function
pt: turtle
mn: clear
ms: clear()
md: Clear the screen.
type: function
pt: turtle
mn: tracer
ms: tracer(flag)
md: Set tracing on/off (according to whether flag is true or not).
type: function
pt: turtle
mn: speed
ms: speed(speed)
md: Set the speed of the turtle.
type: function
pt: turtle
mn: delay
ms: delay(delay)
md: Set the speed of the turtle to delay, which is given in ms.
type: function
pt: turtle
mn: forward
ms: forward(distance)
md: Go forward distance steps.
type: function
pt: turtle
mn: backward
ms: backward(distance)
md: Go backward distance steps.
type: function
pt: turtle
mn: left
ms: left(angle)
md: Turn left angle units.
type: function
pt: turtle
mn: right
ms: right(angle)
md: Turn right angle units.
type: function
pt: turtle
mn: up
ms: up()
md: Move the pen up -- stop drawing.
type: function
pt: turtle
mn: down
ms: down()
md: Move the pen down -- draw when moving.
type: function
pt: turtle
mn: width
ms: width(width)
md: Set the line width to width.
type: function
pt: turtle
mn: color
ms: color(s)
md: 
type: function
pt: turtle
mn: write
ms: write(text[, move])
md: Write text at the current pen position.
type: function
pt: turtle
mn: fill
ms: fill(flag)
md: The complete specifications are rather complex, but the recommended  usage is: call fill(1) before drawing a path you want to fill, and call fill(0) when you finish to draw the path.
type: function
pt: turtle
mn: begin_fill
ms: begin_fill()
md: Switch turtle into filling mode;  Must eventually be followed by a corresponding end_fill() call.
type: function
pt: turtle
mn: end_fill
ms: end_fill()
md: End filling mode, and fill the shape; equivalent to fill(0).
type: function
pt: turtle
mn: circle
ms: circle(radius[, extent])
md: Draw a circle with radius radius whose center-point is radius units left of the turtle.
type: function
pt: turtle
mn: goto
ms: goto(x, y)
md: 
type: function
pt: turtle
mn: towards
ms: towards(x, y)
md: Return the angle of the line from the turtle's position to the point x, y.
type: function
pt: turtle
mn: heading
ms: heading()
md: Return the current orientation of the turtle.
type: function
pt: turtle
mn: setheading
ms: setheading(angle)
md: Set the orientation of the turtle to angle.
type: function
pt: turtle
mn: position
ms: position()
md: Return the current location of the turtle as an (x,y) pair.
type: function
pt: turtle
mn: setx
ms: setx(x)
md: Set the x coordinate of the turtle to x.
type: function
pt: turtle
mn: sety
ms: sety(y)
md: Set the y coordinate of the turtle to y.
type: function
pt: turtle
mn: window_width
ms: window_width()
md: Return the width of the canvas window.
type: function
pt: turtle
mn: window_height
ms: window_height()
md: Return the height of the canvas window.
type: function
pt: turtle
mn: demo
ms: demo()
md: Exercise the module a bit.
type: function
pt: turtle
mn: lookup
ms: lookup(name)
md: Look up character by name.
type: function
pt: unicodedata
mn: name
ms: name(unichr[, default])
md: Returns the name assigned to the Unicode character   unichr as a string.
type: function
pt: unicodedata
mn: decimal
ms: decimal(unichr[, default])
md: Returns the decimal value assigned to the Unicode character   unichr as integer.
type: function
pt: unicodedata
mn: digit
ms: digit(unichr[, default])
md: Returns the digit value assigned to the Unicode character   unichr as integer.
type: function
pt: unicodedata
mn: numeric
ms: numeric(unichr[, default])
md: Returns the numeric value assigned to the Unicode character   unichr as float.
type: function
pt: unicodedata
mn: category
ms: category(unichr)
md: Returns the general category assigned to the Unicode character   unichr as string.
type: function
pt: unicodedata
mn: bidirectional
ms: bidirectional(unichr)
md: Returns the bidirectional category assigned to the Unicode character   unichr as string.
type: function
pt: unicodedata
mn: combining
ms: combining(unichr)
md: Returns the canonical combining class assigned to the Unicode   character unichr as integer.
type: function
pt: unicodedata
mn: east_asian_width
ms: east_asian_width(unichr)
md: Returns the east asian width assigned to the Unicode character   unichr as string.
type: function
pt: unicodedata
mn: mirrored
ms: mirrored(unichr)
md: Returns the mirrored property assigned to the Unicode character   unichr as integer.
type: function
pt: unicodedata
mn: decomposition
ms: decomposition(unichr)
md: Returns the character decomposition mapping assigned to the Unicode   character unichr as string.
type: function
pt: unicodedata
mn: normalize
ms: normalize(form, unistr)
md: 
type: function
pt: unicodedata
mn: urlopen
ms: urlopen(url[, data])
md: Open the URL url, which can be either a string or a Request object.
type: function
pt: urllib2
mn: install_opener
ms: install_opener(opener)
md: Install an OpenerDirector instance as the default global opener.
type: function
pt: urllib2
mn: handler_order
ms: handler_order
md: The handlers raise this exception (or derived exceptions) when they run into a problem.
type: member
pt: urllib2
mn: urlopen
ms: urlopen(url[, data[, proxies]])
md: Open a network object denoted by a URL for reading.
type: function
pt: urllib
mn: urlretrieve
ms: urlretrieve(url[, filename[,                              reporthook[, data]]])
md: Copy a network object denoted by a URL to a local file, if necessary.
type: function
pt: urllib
mn: urlcleanup
ms: urlcleanup()
md: Clear the cache that may have been built up by previous calls to urlretrieve().
type: function
pt: urllib
mn: quote
ms: quote(string[, safe])
md: Replace special characters in string using the "%xx" escape.
type: function
pt: urllib
mn: quote_plus
ms: quote_plus(string[, safe])
md: Like quote(), but also replaces spaces by plus signs, as required for quoting HTML form values.
type: function
pt: urllib
mn: unquote
ms: unquote(string)
md: Replace "%xx" escapes by their single-character equivalent.
type: function
pt: urllib
mn: unquote_plus
ms: unquote_plus(string)
md: Like unquote(), but also replaces plus signs by spaces, as required for unquoting HTML form values.
type: function
pt: urllib
mn: urlencode
ms: urlencode(query[, doseq])
md: Convert a mapping object or a sequence of two-element tuples  to a ``url-encoded'' string, suitable to pass to urlopen() above as the optional data argument.
type: function
pt: urllib
mn: pathname2url
ms: pathname2url(path)
md: Convert the pathname path from the local syntax for a path to the form used in the path component of a URL.
type: function
pt: urllib
mn: url2pathname
ms: url2pathname(path)
md: Convert the path component path from an encoded URL to the local syntax for a path.
type: function
pt: urllib
mn: content
ms: content
md: The public functions urlopen() and urlretrieve() create an instance of the FancyURLopener class and use it to perform their requested actions.
type: member
pt: urllib
mn: version
ms: version
md: 
type: member
pt: urllib
mn: urlparse
ms: urlparse(urlstring[,                           default_scheme[, allow_fragments]])
md: Parse a URL into six components, returning a 6-tuple.
type: function
pt: urlparse
mn: urlunparse
ms: urlunparse(parts)
md: Construct a URL from a tuple as returned by urlparse().
type: function
pt: urlparse
mn: urlsplit
ms: urlsplit(urlstring[,                           default_scheme[, allow_fragments]])
md: This is similar to urlparse(), but does not split the params from the URL.
type: function
pt: urlparse
mn: urlunsplit
ms: urlunsplit(parts)
md: Combine the elements of a tuple as returned by urlsplit() into a complete URL as a string.
type: function
pt: urlparse
mn: urljoin
ms: urljoin(base, url[, allow_fragments])
md: Construct a full (``absolute'') URL by combining a ``base URL'' (base) with another URL (url).
type: function
pt: urlparse
mn: urldefrag
ms: urldefrag(url)
md: If url contains a fragment identifier, returns a modified version of url with no fragment identifier, and the fragment identifier as a separate string.
type: function
pt: urlparse
mn: scheme
ms: scheme
md: Construct a URL from a tuple as returned by urlparse().
type: member
pt: urlparse
mn: netloc
ms: netloc
md: Combine the elements of a tuple as returned by urlsplit() into a complete URL as a string.
type: member
pt: urlparse
mn: data
ms: data
md: Subclass of UserDict that supports direct iteration (e.
type: member
pt: UserDict
mn: data
ms: data
md: A real Python list object used to store the contents of the UserList class.
type: member
pt: UserList
mn: data
ms: data
md: This class is derived from the UserString above and redefines strings to be mutable.
type: member
pt: UserString
mn: encode
ms: encode(in_file, out_file[, name[, mode]])
md: Uuencode file in_file into file out_file.
type: function
pt: uu
mn: decode
ms: decode(in_file[, out_file[, mode[, quiet]]])
md: This call decodes uuencoded file in_file placing the result on   file out_file.
type: function
pt: uu
mn: getnode
ms: getnode()
md: Get the hardware address as a 48-bit positive integer.
type: function
pt: uuid
mn: uuid1
ms: uuid1([node[, clock_seq]])
md: Generate a UUID from a host ID, sequence number, and the current time.
type: function
pt: uuid
mn: uuid3
ms: uuid3(namespace, name)
md: Generate a UUID based on the MD5 hash of a namespace identifier (which is a UUID) and a name (which is a string).
type: function
pt: uuid
mn: uuid4
ms: uuid4()
md: Generate a random UUID.
type: function
pt: uuid
mn: uuid5
ms: uuid5(namespace, name)
md: Generate a UUID based on the SHA-1 hash of a namespace identifier (which is a UUID) and a name (which is a string).
type: function
pt: uuid
mn: bytes
ms: bytes
md: The UUID as a 16-byte string (containing the six integer fields in big-endian byte order).
type: member
pt: uuid
mn: bytes_le
ms: bytes_le
md: The UUID as a 16-byte string (with time_low, time_mid, and time_hi_version in little-endian byte order).
type: member
pt: uuid
mn: fields
ms: fields
md: A tuple of the six integer fields of the UUID, which are also available as six individual attributes and two derived attributes:
type: member
pt: uuid
mn: int
ms: int
md: The UUID as a 128-bit integer.
type: member
pt: uuid
mn: urn
ms: urn
md: The UUID as a URN as specified in RFC 4122.
type: member
pt: uuid
mn: variant
ms: variant
md: The UUID variant, which determines the internal layout of the UUID.
type: member
pt: uuid
mn: version
ms: version
md: The UUID version number (1 through 5, meaningful only when the variant is RFC_4122).
type: member
pt: uuid
mn: open
ms: open(file[, mode])
md: If file is a string, open the file by that name, other treat it as a seekable file-like object.
type: function
pt: wave
mn: openfp
ms: openfp(file, mode)
md: A synonym for open(), maintained for backwards compatibility.
type: function
pt: wave
mn: proxy
ms: proxy(object[, callback])
md: Return a proxy to object which uses a weak reference.
type: function
pt: weakref
mn: getweakrefcount
ms: getweakrefcount(object)
md: Return the number of weak references and proxies which refer to   object.
type: function
pt: weakref
mn: getweakrefs
ms: getweakrefs(object)
md: Return a list of all weak reference and proxy objects which refer to   object.
type: function
pt: weakref
mn: iterkeyrefs
ms: iterkeyrefs()
md: Return an iterator that yields the weak references to the keys.
type: method
pt: weakref
mn: keyrefs
ms: keyrefs()
md: Return a list of weak references to the keys.
type: method
pt: weakref
mn: itervaluerefs
ms: itervaluerefs()
md: Return an iterator that yields the weak references to the values.
type: method
pt: weakref
mn: valuerefs
ms: valuerefs()
md: Return a list of weak references to the values.
type: method
pt: weakref
mn: open
ms: open(url[, new=0[, autoraise=1]])
md: Display url using the default browser.
type: function
pt: webbrowser
mn: open_new
ms: open_new(url)
md: Open url in a new window of the default browser, if possible,   otherwise, open url in the only browser window.
type: function
pt: webbrowser
mn: open_new_tab
ms: open_new_tab(url)
md: Open url in a new page ("tab") of the default browser, if possible,   otherwise equivalent to open_new.
type: function
pt: webbrowser
mn: get
ms: get([name])
md: Return a controller object for the browser type name.
type: function
pt: webbrowser
mn: register
ms: register(name, constructor[, instance])
md: Register the browser type name.
type: function
pt: webbrowser
mn: whichdb
ms: whichdb(filename)
md: Returns one of the following values: None if the file can't be opened because it's unreadable or doesn't exist; the empty string ('') if the file's format can't be guessed; or a string containing the required module name, such as 'dbm' or 'gdbm'.
type: function
pt: whichdb
mn: Beep
ms: Beep(frequency, duration)
md: Beep the PC's speaker.
type: function
pt: winsound
mn: PlaySound
ms: PlaySound(sound, flags)
md: Call the underlying PlaySound() function from the   Platform API.
type: function
pt: winsound
mn: MessageBeep
ms: MessageBeep([type=MB_OK])
md: Call the underlying MessageBeep() function from the   Platform API.
type: function
pt: winsound
mn: run
ms: run(app)
md: Run the specified WSGI application, app.
type: method
pt: wsgiref.handlers
mn: _write
ms: _write(data)
md: Buffer the string data for transmission to the client.
type: method
pt: wsgiref.handlers
mn: _flush
ms: _flush()
md: Force buffered data to be transmitted to the client.
type: method
pt: wsgiref.handlers
mn: get_stdin
ms: get_stdin()
md: Return an input stream object suitable for use as the wsgi.
type: method
pt: wsgiref.handlers
mn: get_stderr
ms: get_stderr()
md: Return an output stream object suitable for use as the wsgi.
type: method
pt: wsgiref.handlers
mn: add_cgi_vars
ms: add_cgi_vars()
md: Insert CGI variables for the current request into the environ attribute.
type: method
pt: wsgiref.handlers
mn: get_scheme
ms: get_scheme()
md: Return the URL scheme being used for the current request.
type: method
pt: wsgiref.handlers
mn: setup_environ
ms: setup_environ()
md: Set the environ attribute to a fully-populated WSGI environment.
type: method
pt: wsgiref.handlers
mn: log_exception
ms: log_exception(exc_info)
md: Log the exc_info tuple in the server log.
type: method
pt: wsgiref.handlers
mn: error_output
ms: error_output(environ, start_response)
md: This method is a WSGI application to generate an error page for the user.
type: method
pt: wsgiref.handlers
mn: sendfile
ms: sendfile()
md: Override to implement platform-specific file transmission.
type: method
pt: wsgiref.handlers
mn: stdin
ms: stdin
md: This is an abstract base class for running WSGI applications.
type: member
pt: wsgiref.handlers
mn: environ
ms: environ
md: The value to be used for the wsgi.
type: member
pt: wsgiref.handlers
mn: wsgi_multiprocess
ms: wsgi_multiprocess
md: The value to be used for the wsgi.
type: member
pt: wsgiref.handlers
mn: wsgi_run_once
ms: wsgi_run_once
md: The value to be used for the wsgi.
type: member
pt: wsgiref.handlers
mn: os_environ
ms: os_environ
md: The default environment variables to be included in every request's WSGI environment.
type: member
pt: wsgiref.handlers
mn: server_software
ms: server_software
md: If the origin_server attribute is set, this attribute's value is used to set the default SERVER_SOFTWARE WSGI environment variable, and also to set a default Server: header in HTTP responses.
type: member
pt: wsgiref.handlers
mn: wsgi_file_wrapper
ms: wsgi_file_wrapper
md: Log the exc_info tuple in the server log.
type: member
pt: wsgiref.handlers
mn: traceback_limit
ms: traceback_limit
md: The maximum number of frames to include in tracebacks output by the default log_exception() method.
type: member
pt: wsgiref.handlers
mn: error_status
ms: error_status
md: The HTTP status used for error responses.
type: member
pt: wsgiref.handlers
mn: error_headers
ms: error_headers
md: The HTTP headers used for error responses.
type: member
pt: wsgiref.handlers
mn: error_body
ms: error_body
md: The error response body.
type: member
pt: wsgiref.handlers
mn: origin_server
ms: origin_server
md: This attribute should be set to a true value if the handler's _write() and _flush() are being used to communicate directly to the client, rather than via a CGI-like gateway protocol that wants the HTTP status in a special Status: header.
type: member
pt: wsgiref.handlers
mn: http_version
ms: http_version
md: If origin_server is true, this string attribute is used to set the HTTP version of the response set to the client.
type: member
pt: wsgiref.handlers
mn: get_all
ms: get_all(name)
md: Return a list of all the values for the named header.
type: method
pt: wsgiref.headers
mn: add_header
ms: add_header(name, value, **_params)
md: Add a (possibly multi-valued) header, with optional MIME parameters specified via keyword arguments.
type: method
pt: wsgiref.headers
mn: make_server
ms: make_server(host, port, app[, server_class=WSGIServer [,handler_class=WSGIRequestHandler]])
md: Create a new WSGI server listening on host and port, accepting connections for app.
type: function
pt: wsgiref.simpleserver
mn: demo_app
ms: demo_app(environ, start_response)
md: This function is a small but complete WSGI application that returns a text page containing the message ``Hello world!'' and a list of the key/value pairs provided in the environ parameter.
type: function
pt: wsgiref.simpleserver
mn: set_app
ms: set_app(application)
md: Sets the callable application as the WSGI application that will receive requests.
type: method
pt: wsgiref.simpleserver
mn: get_app
ms: get_app()
md: Returns the currently-set application callable.
type: method
pt: wsgiref.simpleserver
mn: get_environ
ms: get_environ()
md: Returns a dictionary containing the WSGI environment for a request.
type: method
pt: wsgiref.simpleserver
mn: get_stderr
ms: get_stderr()
md: Return the object that should be used as the wsgi.
type: method
pt: wsgiref.simpleserver
mn: handle
ms: handle()
md: Process the HTTP request.
type: method
pt: wsgiref.simpleserver
mn: base_environ
ms: base_environ
md: Return the object that should be used as the wsgi.
type: member
pt: wsgiref.simpleserver
mn: guess_scheme
ms: guess_scheme(environ)
md: Return a guess for whether wsgi.
type: function
pt: wsgiref.util
mn: request_uri
ms: request_uri(environ [, include_query=1])
md: Return the full request URI
type: function
pt: wsgiref.util
mn: application_uri
ms: application_uri(environ)
md: Similar to request_uri, except that the PATH_INFO and QUERY_STRING variables are ignored.
type: function
pt: wsgiref.util
mn: shift_path_info
ms: shift_path_info(environ)
md: Shift a single name from PATH_INFO to SCRIPT_NAME and return the name.
type: function
pt: wsgiref.util
mn: is_hop_by_hop
ms: is_hop_by_hop(header_name)
md: Return true if 'header_name' is an HTTP/1.
type: function
pt: wsgiref.util
mn: validator
ms: validator(application)
md: Wrap application and return a new WSGI application object.
type: function
pt: wsgiref.validate
mn: registerDOMImplementation
ms: registerDOMImplementation(name,factory)
md: Register the factory function with the name name.
type: method
pt: xml.dom
mn: getDOMImplementation
ms: getDOMImplementation([name[, features]])
md: Return a suitable DOM implementation.
type: method
pt: xml.dom
mn: parse
ms: parse(filename_or_file, parser)
md: Return a Document from the given input.
type: function
pt: xml.dom.minidom
mn: parseString
ms: parseString(string[, parser])
md: Return a Document that represents the string.
type: function
pt: xml.dom.minidom
mn: documentElement
ms: documentElement
md: The W3C recommendation for the DOM supported by xml.
type: member
pt: xml.dom.minidom
mn: parse
ms: parse(stream_or_string[,parser[, bufsize]])
md: .
type: function
pt: xml.dom.pulldom
mn: parseString
ms: parseString(string[, parser])
md: .
type: function
pt: xml.dom.pulldom
mn: ErrorString
ms: ErrorString(errno)
md: Returns an explanatory string for a given error number errno.
type: function
pt: xml.parsers.expat
mn: ParserCreate
ms: ParserCreate([encoding[,                               namespace_separator]])
md: Creates and returns a new xmlparser object.
type: function
pt: xml.parsers.expat
mn: StartElementHandler
ms: StartElementHandler
md: Home page of the Expat project.
type: member
pt: xml.parsers.expat
mn: escape
ms: escape(data[, entities])
md: Escape "&amp;", "&lt;", and "&gt;" in a string   of data.
type: function
pt: xml.sax.saxutils
mn: unescape
ms: unescape(data[, entities])
md: Unescape "&amp;amp;", "&amp;lt;", and "&amp;gt;"   in a string of data.
type: function
pt: xml.sax.saxutils
mn: quoteattr
ms: quoteattr(data[, entities])
md: Similar to escape(), but also prepares data to be   used as an attribute value.
type: function
pt: xml.sax.saxutils
mn: prepare_input_source
ms: prepare_input_source(source[, base])
md: This function takes an input source and an optional base URL and   returns a fully resolved InputSource object ready for   reading.
type: function
pt: xml.sax.saxutils
mn: make_parser
ms: make_parser([parser_list])
md: Create and return a SAX XMLReader object.
type: function
pt: xml.sax
mn: parse
ms: parse(filename_or_stream, handler[, error_handler])
md: Create a SAX parser and use it to parse a document.
type: function
pt: xml.sax
mn: parseString
ms: parseString(string, handler[, error_handler])
md: Similar to parse(), but parses from a buffer string   received as a parameter.
type: function
pt: xml.sax
mn: is_zipfile
ms: is_zipfile(filename)
md: Returns True if filename is a valid ZIP file based on its magic   number, otherwise returns False.
type: function
pt: zipfile
mn: adler32
ms: adler32(string[, value])
md: Computes a Adler-32 checksum of string.
type: function
pt: zlib
mn: compress
ms: compress(string[, level])
md: Compresses the data in string, returning a string contained   compressed data.
type: function
pt: zlib
mn: compressobj
ms: compressobj([level])
md: Returns a compression object, to be used for compressing data streams   that won't fit into memory at once.
type: function
pt: zlib
mn: crc32
ms: crc32(string[, value])
md: Computes a CRC (Cyclic Redundancy Check) checksum of string.
type: function
pt: zlib
mn: decompress
ms: decompress(string[, wbits[, bufsize]])
md: Decompresses the data in string, returning a string containing   the uncompressed data.
type: function
pt: zlib
mn: decompressobj
ms: decompressobj([wbits])
md: Returns a decompression object, to be used for decompressing data   streams that won't fit into memory at once.
type: function
pt: zlib
mn: compress
ms: compress(string)
md: Compress string, returning a string containing compressed data for at least part of the data in string.
type: method
pt: zlib
mn: flush
ms: flush([mode])
md: All pending input is processed, and a string containing the remaining compressed output is returned.
type: method
pt: zlib
mn: copy
ms: copy()
md: Returns a copy of the compression object.
type: method
pt: zlib
mn: unused_data
ms: unused_data
md: A string which contains any bytes past the end of the compressed data.
type: member
pt: zlib
mn: unconsumed_tail
ms: unconsumed_tail
md: A string that contains any data that was not consumed by the last decompress call because it exceeded the limit for the uncompressed data buffer.
type: member
pt: zlib