api

string string\nA collection of string operations (most are no longer used).\n\nWarning: most of the code you see here isn't normally used nowadays.\nBeginning with Python 1.6, many of these functions are implemented as\nmethods on the standard string object. They used to be implemented by\na built-in module called strop, but strop is now obsolete itself.\n\nPublic module variables:\n\nwhitespace -- a string containing all characters considered whitespace\nlowercase -- a string containing all characters considered lowercase letters\nuppercase -- a string containing all characters considered uppercase letters\nletters -- a string containing all characters considered letters\ndigits -- a string containing all characters considered decimal digits\nhexdigits -- a string containing all characters considered hexadecimal digits\noctdigits -- a string containing all characters considered octal digits\npunctuation -- a string containing all characters considered punctuation\nprintable -- a string containing all characters considered printable
Formatter string.Formatter()\n
Template string.Template()\nA string class for supporting $-substitutions.
__builtins__ string.__builtins__ [dict]
__doc__ string.__doc__ [str]
__file__ string.__file__ [str]
__name__ string.__name__ [str]
__package__ string.__package__ [NoneType]
ascii_letters string.ascii_letters [str]
ascii_lowercase string.ascii_lowercase [str]
ascii_uppercase string.ascii_uppercase [str]
atof string.atof(s) -> float\n\n    Return the floating point number represented by the string s.
atof_error string.atof_error()\nInappropriate argument value (of correct type).
atoi string.atoi(s [,base]) -> int\n\n    Return the integer represented by the string s in the given\n    base, which defaults to 10.  The string s must consist of one\n    or more digits, possibly preceded by a sign.  If base is 0, it\n    is chosen from the leading characters of s, 0 for octal, 0x or\n    0X for hexadecimal.  If base is 16, a preceding 0x or 0X is\n    accepted.
atoi_error string.atoi_error()\nInappropriate argument value (of correct type).
atol string.atol(s [,base]) -> long\n\n    Return the long integer represented by the string s in the\n    given base, which defaults to 10.  The string s must consist\n    of one or more digits, possibly preceded by a sign.  If base\n    is 0, it is chosen from the leading characters of s, 0 for\n    octal, 0x or 0X for hexadecimal.  If base is 16, a preceding\n    0x or 0X is accepted.  A trailing L or l is not accepted,\n    unless base is 0.
atol_error string.atol_error()\nInappropriate argument value (of correct type).
capitalize string.capitalize(s) -> string\n\n    Return a copy of the string s with only its first character\n    capitalized.
capwords string.capwords(s [,sep]) -> string\n\n    Split the argument into words using split, capitalize each\n    word using capitalize, and join the capitalized words using\n    join.  If the optional second argument sep is absent or None,\n    runs of whitespace characters are replaced by a single space\n    and leading and trailing whitespace are removed, otherwise\n    sep is used to split and join the words.
center string.center(s, width[, fillchar]) -> string\n\n    Return a center version of s, in a field of the specified\n    width. padded with spaces as needed.  The string is never\n    truncated.  If specified the fillchar is used instead of spaces.
count string.count(s, sub[, start[,end]]) -> int\n\n    Return the number of occurrences of substring sub in string\n    s[start:end].  Optional arguments start and end are\n    interpreted as in slice notation.
digits string.digits [str]
expandtabs string.expandtabs(s [,tabsize]) -> string\n\n    Return a copy of the string s with all tab characters replaced\n    by the appropriate number of spaces, depending on the current\n    column, and the tabsize (default 8).
find string.find(s, sub [,start [,end]]) -> in\n\n    Return the lowest index in s where substring sub is found,\n    such that sub is contained within s[start,end].  Optional\n    arguments start and end are interpreted as in slice notation.\n\n    Return -1 on failure.
hexdigits string.hexdigits [str]
index string.index(s, sub [,start [,end]]) -> int\n\n    Like find but raises ValueError when the substring is not found.
index_error string.index_error()\nInappropriate argument value (of correct type).
join string.join(list [,sep]) -> string\n\n    Return a string composed of the words in list, with\n    intervening occurrences of sep.  The default separator is a\n    single space.\n\n    (joinfields and join are synonymous)
joinfields string.joinfields()\njoin(list [,sep]) -> string\n\n    Return a string composed of the words in list, with\n    intervening occurrences of sep.  The default separator is a\n    single space.\n\n    (joinfields and join are synonymous)
letters string.letters [str]
ljust string.ljust(s, width[, fillchar]) -> string\n\n    Return a left-justified version of s, in a field of the\n    specified width, padded with spaces as needed.  The string is\n    never truncated.  If specified the fillchar is used instead of spaces.
lower string.lower(s) -> string\n\n    Return a copy of the string s converted to lowercase.
lowercase string.lowercase [str]
lstrip string.lstrip(s [,chars]) -> string\n\n    Return a copy of the string s with leading whitespace removed.\n    If chars is given and not None, remove characters in chars instead.
maketrans string.maketrans(frm, to) -> string\n\nReturn a translation table (a string of 256 bytes long)\nsuitable for use in string.translate.  The strings frm and to\nmust be of the same length.
octdigits string.octdigits [str]
printable string.printable [str]
punctuation string.punctuation [str]
replace string.replace()\nreplace (str, old, new[, maxreplace]) -> string\n\n    Return a copy of string str with all occurrences of substring\n    old replaced by new. If the optional argument maxreplace is\n    given, only the first maxreplace occurrences are replaced.
rfind string.rfind(s, sub [,start [,end]]) -> int\n\n    Return the highest index in s where substring sub is found,\n    such that sub is contained within s[start,end].  Optional\n    arguments start and end are interpreted as in slice notation.\n\n    Return -1 on failure.
rindex string.rindex(s, sub [,start [,end]]) -> int\n\n    Like rfind but raises ValueError when the substring is not found.
rjust string.rjust(s, width[, fillchar]) -> string\n\n    Return a right-justified version of s, in a field of the\n    specified width, padded with spaces as needed.  The string is\n    never truncated.  If specified the fillchar is used instead of spaces.
rsplit string.rsplit(s [,sep [,maxsplit]]) -> list of strings\n\n    Return a list of the words in the string s, using sep as the\n    delimiter string, starting at the end of the string and working\n    to the front.  If maxsplit is given, at most maxsplit splits are\n    done. If sep is not specified or is None, any whitespace string\n    is a separator.
rstrip string.rstrip(s [,chars]) -> string\n\n    Return a copy of the string s with trailing whitespace removed.\n    If chars is given and not None, remove characters in chars instead.
split string.split(s [,sep [,maxsplit]]) -> list of strings\n\n    Return a list of the words in the string s, using sep as the\n    delimiter string.  If maxsplit is given, splits at no more than\n    maxsplit places (resulting in at most maxsplit+1 words).  If sep\n    is not specified or is None, any whitespace string is a separator.\n\n    (split and splitfields are synonymous)
splitfields string.splitfields()\nsplit(s [,sep [,maxsplit]]) -> list of strings\n\n    Return a list of the words in the string s, using sep as the\n    delimiter string.  If maxsplit is given, splits at no more than\n    maxsplit places (resulting in at most maxsplit+1 words).  If sep\n    is not specified or is None, any whitespace string is a separator.\n\n    (split and splitfields are synonymous)
strip string.strip(s [,chars]) -> string\n\n    Return a copy of the string s with leading and trailing\n    whitespace removed.\n    If chars is given and not None, remove characters in chars instead.\n    If chars is unicode, S will be converted to unicode before stripping.
swapcase string.swapcase(s) -> string\n\n    Return a copy of the string s with upper case characters\n    converted to lowercase and vice versa.
translate string.translate(s,table [,deletions]) -> string\n\n    Return a copy of the string s, where all characters occurring\n    in the optional argument deletions are removed, and the\n    remaining characters have been mapped through the given\n    translation table, which must be a string of length 256.  The\n    deletions argument is not allowed for Unicode strings.
upper string.upper(s) -> string\n\n    Return a copy of the string s converted to uppercase.
uppercase string.uppercase [str]
whitespace string.whitespace [str]
zfill string.zfill(x, width) -> string\n\n    Pad a numeric string x with zeros on the left, to fill a field\n    of the specified width.  The string x is never truncated.
re re\nSupport for regular expressions (RE).\n\nThis module provides regular expression matching operations similar to\nthose found in Perl.  It supports both 8-bit and Unicode strings; both\nthe pattern and the strings being processed can contain null bytes and\ncharacters outside the US ASCII range.\n\nRegular expressions can contain both special and ordinary characters.\nMost ordinary characters, like "A", "a", or "0", are the simplest\nregular expressions; they simply match themselves.  You can\nconcatenate ordinary characters, so last matches the string 'last'.\n\nThe special characters are:\n    "."      Matches any character except a newline.\n    "^"      Matches the start of the string.\n    "$"      Matches the end of the string or just before the newline at\n             the end of the string.\n    "*"      Matches 0 or more (greedy) repetitions of the preceding RE.\n             Greedy means that it will match as many repetitions as possible.\n    "+"      Matches 1 or more (greedy) repetitions of the preceding RE.\n    "?"      Matches 0 or 1 (greedy) of the preceding RE.\n    *?,+?,?? Non-greedy versions of the previous three special characters.\n    {m,n}    Matches from m to n repetitions of the preceding RE.\n    {m,n}?   Non-greedy version of the above.\n    "\\"     Either escapes special characters or signals a special sequence.\n    []       Indicates a set of characters.\n             A "^" as the first character indicates a complementing set.\n    "|"      A|B, creates an RE that will match either A or B.\n    (...)    Matches the RE inside the parentheses.\n             The contents can be retrieved or matched later in the string.\n    (?iLmsux) Set the I, L, M, S, U, or X flag for the RE (see below).\n    (?:...)  Non-grouping version of regular parentheses.\n    (?P<name>...) The substring matched by the group is accessible by name.\n    (?P=name)     Matches the text matched earlier by the group named name.\n    (?#...)  A comment; ignored.\n    (?=...)  Matches if ... matches next, but doesn't consume the string.\n    (?!...)  Matches if ... doesn't match next.\n    (?<=...) Matches if preceded by ... (must be fixed length).\n    (?<!...) Matches if not preceded by ... (must be fixed length).\n    (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,\n                       the (optional) no pattern otherwise.\n\nThe special sequences consist of "\\" and a character from the list\nbelow.  If the ordinary character is not on the list, then the\nresulting RE will match the second character.\n    \number  Matches the contents of the group of the same number.\n    \A       Matches only at the start of the string.\n    \Z       Matches only at the end of the string.\n    \b       Matches the empty string, but only at the start or end of a word.\n    \B       Matches the empty string, but not at the start or end of a word.\n    \d       Matches any decimal digit; equivalent to the set [0-9].\n    \D       Matches any non-digit character; equivalent to the set [^0-9].\n    \s       Matches any whitespace character; equivalent to [ \t\\n\r\f\v].\n    \S       Matches any non-whitespace character; equiv. to [^ \t\\n\r\f\v].\n    \w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_].\n             With LOCALE, it will match the set [0-9_] plus characters defined\n             as letters for the current locale.\n    \W       Matches the complement of \w.\n    \\       Matches a literal backslash.\n\nThis module exports the following functions:\n    match    Match a regular expression pattern to the beginning of a string.\n    search   Search a string for the presence of a pattern.\n    sub      Substitute occurrences of a pattern found in a string.\n    subn     Same as sub, but also return the number of substitutions made.\n    split    Split a string by the occurrences of a pattern.\n    findall  Find all occurrences of a pattern in a string.\n    finditer Return an iterator yielding a match object for each match.\n    compile  Compile a pattern into a RegexObject.\n    purge    Clear the regular expression cache.\n    escape   Backslash all non-alphanumerics in a string.\n\nSome of the functions in this module takes flags as optional parameters:\n    I  IGNORECASE  Perform case-insensitive matching.\n    L  LOCALE      Make \w, \W, \b, \B, dependent on the current locale.\n    M  MULTILINE   "^" matches the beginning of lines (after a newline)\n                   as well as the string.\n                   "$" matches the end of lines (before a newline) as well\n                   as the end of the string.\n    S  DOTALL      "." matches any character at all, including the newline.\n    X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.\n    U  UNICODE     Make \w, \W, \b, \B, dependent on the Unicode locale.\n\nThis module also defines an exception 'error'.
DEBUG re.DEBUG [int]
DOTALL re.DOTALL [int]
I re.I [int]
IGNORECASE re.IGNORECASE [int]
L re.L [int]
LOCALE re.LOCALE [int]
M re.M [int]
MULTILINE re.MULTILINE [int]
S re.S [int]
Scanner re.Scanner\n
__doc__ Scanner.__doc__ [NoneType]
__init__ Scanner.__init__()\n
__module__ Scanner.__module__ [str]
scan Scanner.scan()\n
T re.T [int]
TEMPLATE re.TEMPLATE [int]
U re.U [int]
UNICODE re.UNICODE [int]
VERBOSE re.VERBOSE [int]
X re.X [int]
__all__ re.__all__ [list]
__builtins__ re.__builtins__ [dict]
__doc__ re.__doc__ [str]
__file__ re.__file__ [str]
__name__ re.__name__ [str]
__package__ re.__package__ [NoneType]
__version__ re.__version__ [str]
compile re.compile()\nCompile a regular expression pattern, returning a pattern object.
error re.error()\n
escape re.escape()\nEscape all non-alphanumeric characters in pattern.
findall re.findall()\nReturn a list of all non-overlapping matches in the string.\n\n    If one or more groups are present in the pattern, return a\n    list of groups; this will be a list of tuples if the pattern\n    has more than one group.\n\n    Empty matches are included in the result.
finditer re.finditer()\nReturn an iterator over all non-overlapping matches in the\n        string.  For each match, the iterator returns a match object.\n\n        Empty matches are included in the result.
match re.match()\nTry to apply the pattern at the start of the string, returning\n    a match object, or None if no match was found.
purge re.purge()\nClear the regular expression cache
search re.search()\nScan through string looking for a match to the pattern, returning\n    a match object, or None if no match was found.
split re.split()\nSplit the source string by the occurrences of the pattern,\n    returning a list containing the resulting substrings.
sub re.sub()\nReturn the string obtained by replacing the leftmost\n    non-overlapping occurrences of the pattern in string by the\n    replacement repl.  repl can be either a string or a callable;\n    if a string, backslash escapes in it are processed.  If it is\n    a callable, it's passed the match object and must return\n    a replacement string to be used.
subn re.subn()\nReturn a 2-tuple containing (new_string, number).\n    new_string is the string obtained by replacing the leftmost\n    non-overlapping occurrences of the pattern in the source\n    string by the replacement repl.  number is the number of\n    substitutions that were made. repl can be either a string or a\n    callable; if a string, backslash escapes in it are processed.\n    If it is a callable, it's passed the match object and must\n    return a replacement string to be used.
template re.template()\nCompile a template pattern, returning a pattern object
textwrap textwrap\nText wrapping and filling.
TextWrapper textwrap.TextWrapper\n\n    Object for wrapping/filling text.  The public interface consists of\n    the wrap() and fill() methods; the other methods are just there for\n    subclasses to override in order to tweak the default behaviour.\n    If you want to completely replace the main wrapping algorithm,\n    you'll probably have to override _wrap_chunks().\n\n    Several instance attributes control various aspects of wrapping:\n      width (default: 70)\n        the maximum width of wrapped lines (unless break_long_words\n        is false)\n      initial_indent (default: "")\n        string that will be prepended to the first line of wrapped\n        output.  Counts towards the line's width.\n      subsequent_indent (default: "")\n        string that will be prepended to all lines save the first\n        of wrapped output; also counts towards each line's width.\n      expand_tabs (default: true)\n        Expand tabs in input text to spaces before further processing.\n        Each tab will become 1 .. 8 spaces, depending on its position in\n        its line.  If false, each tab is treated as a single character.\n      replace_whitespace (default: true)\n        Replace all whitespace characters in the input text by spaces\n        after tab expansion.  Note that if expand_tabs is false and\n        replace_whitespace is true, every tab will be converted to a\n        single space!\n      fix_sentence_endings (default: false)\n        Ensure that sentence-ending punctuation is always followed\n        by two spaces.  Off by default because the algorithm is\n        (unavoidably) imperfect.\n      break_long_words (default: true)\n        Break words longer than 'width'.  If false, those words will not\n        be broken, and some lines might be longer than 'width'.\n      break_on_hyphens (default: true)\n        Allow breaking hyphenated words. If true, wrapping will occur\n        preferably on whitespaces and right after hyphens part of\n        compound words.\n      drop_whitespace (default: true)\n        Drop leading and trailing whitespace from lines.
__doc__ TextWrapper.__doc__ [str]
__init__ TextWrapper.__init__()\n
__module__ TextWrapper.__module__ [str]
fill TextWrapper.fill(text : string) -> string\n\n        Reformat the single paragraph in 'text' to fit in lines of no\n        more than 'self.width' columns, and return a new string\n        containing the entire wrapped paragraph.
sentence_end_re TextWrapper.sentence_end_re [_sre.SRE_Pattern]
unicode_whitespace_trans TextWrapper.unicode_whitespace_trans [dict]
uspace TextWrapper.uspace [int]
whitespace_trans TextWrapper.whitespace_trans [str]
wordsep_re TextWrapper.wordsep_re [_sre.SRE_Pattern]
wordsep_simple_re TextWrapper.wordsep_simple_re [_sre.SRE_Pattern]
wrap TextWrapper.wrap(text : string) -> [string]\n\n        Reformat the single paragraph in 'text' so it fits in lines of\n        no more than 'self.width' columns, and return a list of wrapped\n        lines.  Tabs in 'text' are expanded with string.expandtabs(),\n        and all other whitespace characters (including newline) are\n        converted to space.
x TextWrapper.x [int]
__all__ textwrap.__all__ [list]
__builtins__ textwrap.__builtins__ [dict]
__doc__ textwrap.__doc__ [str]
__file__ textwrap.__file__ [str]
__name__ textwrap.__name__ [str]
__package__ textwrap.__package__ [NoneType]
__revision__ textwrap.__revision__ [str]
dedent textwrap.dedent()\nRemove any common leading whitespace from every line in `text`.\n\n    This can be used to make triple-quoted strings line up with the left\n    edge of the display, while still presenting them in the source code\n    in indented form.\n\n    Note that tabs and spaces are both treated as whitespace, but they\n    are not equal: the lines "  hello" and "	hello" are\n    considered to have no common leading whitespace.  (This behaviour is\n    new in Python 2.5; older versions of this module incorrectly\n    expanded tabs before searching for common leading whitespace.)
fill textwrap.fill()\nFill a single paragraph of text, returning a new string.\n\n    Reformat the single paragraph in 'text' to fit in lines of no more\n    than 'width' columns, and return a new string containing the entire\n    wrapped paragraph.  As with wrap(), tabs are expanded and other\n    whitespace characters converted to space.  See TextWrapper class for\n    available keyword args to customize wrapping behaviour.
wrap textwrap.wrap()\nWrap a single paragraph of text, returning a list of wrapped lines.\n\n    Reformat the single paragraph in 'text' so it fits in lines of no\n    more than 'width' columns, and return a list of wrapped lines.  By\n    default, tabs in 'text' are expanded with string.expandtabs(), and\n    all other whitespace characters (including newline) are converted to\n    space.  See TextWrapper class for available keyword args to customize\n    wrapping behaviour.
datetime datetime\nFast implementation of the datetime type.
MAXYEAR datetime.MAXYEAR [int]
MINYEAR datetime.MINYEAR [int]
__doc__ datetime.__doc__ [str]
__file__ datetime.__file__ [str]
__name__ datetime.__name__ [str]
__package__ datetime.__package__ [NoneType]
date datetime.date(year, month, day) --> date object
datetime datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])\n\nThe year, month and day arguments are required. tzinfo may be None, or an\ninstance of a tzinfo subclass. The remaining arguments may be ints or longs.
datetime_CAPI datetime.datetime_CAPI [PyCapsule]
time datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) --> a time object\n\nAll arguments are optional. tzinfo may be None, or an instance of\na tzinfo subclass. The remaining arguments may be ints or longs.
timedelta datetime.timedelta()\nDifference between two datetime values.
tzinfo datetime.tzinfo()\nAbstract base class for time zone info objects.
calendar calendar\nCalendar printing functions\n\nNote when comparing these calendars to the ones printed by cal(1): By\ndefault, these calendars have Monday as the first day of the week, and\nSunday as the last (the European convention). Use setfirstweekday() to\nset the first day of the week (0=Monday, 6=Sunday).
Calendar calendar.Calendar()\n\n    Base calendar class. This class doesn't do any formatting. It simply\n    provides data to subclasses.
EPOCH calendar.EPOCH [int]
FRIDAY calendar.FRIDAY [int]
February calendar.February [int]
HTMLCalendar calendar.HTMLCalendar()\n\n    This calendar returns complete HTML pages.
IllegalMonthError calendar.IllegalMonthError()\n
IllegalWeekdayError calendar.IllegalWeekdayError()\n
January calendar.January [int]
LocaleHTMLCalendar calendar.LocaleHTMLCalendar()\n\n    This class can be passed a locale name in the constructor and will return\n    month and weekday names in the specified locale. If this locale includes\n    an encoding all strings containing month and weekday names will be returned\n    as unicode.
LocaleTextCalendar calendar.LocaleTextCalendar()\n\n    This class can be passed a locale name in the constructor and will return\n    month and weekday names in the specified locale. If this locale includes\n    an encoding all strings containing month and weekday names will be returned\n    as unicode.
MONDAY calendar.MONDAY [int]
SATURDAY calendar.SATURDAY [int]
SUNDAY calendar.SUNDAY [int]
THURSDAY calendar.THURSDAY [int]
TUESDAY calendar.TUESDAY [int]
TextCalendar calendar.TextCalendar()\n\n    Subclass of Calendar that outputs a calendar as a simple plain text\n    similar to the UNIX program cal.
TimeEncoding calendar.TimeEncoding\n
__doc__ TimeEncoding.__doc__ [NoneType]
__enter__ TimeEncoding.__enter__()\n
__exit__ TimeEncoding.__exit__()\n
__init__ TimeEncoding.__init__()\n
__module__ TimeEncoding.__module__ [str]
WEDNESDAY calendar.WEDNESDAY [int]
__all__ calendar.__all__ [list]
__builtins__ calendar.__builtins__ [dict]
__doc__ calendar.__doc__ [str]
__file__ calendar.__file__ [str]
__name__ calendar.__name__ [str]
__package__ calendar.__package__ [NoneType]
c calendar.c [calendar.TextCalendar]
calendar calendar.calendar()\n\n        Returns a year's calendar as a multi-line string.
day_abbr calendar.day_abbr [instance]
day_name calendar.day_name [instance]
error calendar.error()\nInappropriate argument value (of correct type).
firstweekday calendar.firstweekday()\n
format calendar.format()\nPrints multi-column formatting for year calendars
formatstring calendar.formatstring()\nReturns a string formatted from n strings, centered within n columns.
isleap calendar.isleap()\nReturn True for leap years, False for non-leap years.
leapdays calendar.leapdays()\nReturn number of leap years in range [y1, y2).\n       Assume y1 <= y2.
main calendar.main()\n
mdays calendar.mdays [list]
month calendar.month()\n\n        Return a month's calendar string (multi-line).
month_abbr calendar.month_abbr [instance]
month_name calendar.month_name [instance]
monthcalendar calendar.monthcalendar()\n\n        Return a matrix representing a month's calendar.\n        Each row represents a week; days outside this month are zero.
monthrange calendar.monthrange()\nReturn weekday (0-6 ~ Mon-Sun) and number of days (28-31) for\n       year, month.
prcal calendar.prcal()\nPrint a year's calendar.
prmonth calendar.prmonth()\n\n        Print a month's calendar.
prweek calendar.prweek()\n\n        Print a single week (no newline).
setfirstweekday calendar.setfirstweekday()\n
timegm calendar.timegm()\nUnrelated but handy function to calculate Unix timestamp from GMT.
week calendar.week()\n\n        Returns a single week in a string (no newline).
weekday calendar.weekday()\nReturn weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),\n       day (1-31).
weekheader calendar.weekheader()\n\n        Return a header for a week.
types types\nDefine names for all type symbols known in the standard interpreter.\n\nTypes that are part of optional modules (e.g. array) are not listed.
BooleanType types.BooleanType()\nbool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.
BufferType types.BufferType()\nbuffer(object [, offset[, size]])\n\nCreate a new buffer object which references the given object.\nThe buffer will reference a slice of the target object from the\nstart of the object (or at the specified offset). The slice will\nextend to the end of the target object (or with the specified size).
BuiltinFunctionType types.BuiltinFunctionType()\n
BuiltinMethodType types.BuiltinMethodType()\n
ClassType types.ClassType()\nclassobj(name, bases, dict)\n\nCreate a class object.  The name must be a string; the second argument\na tuple of classes, and the third a dictionary.
CodeType types.CodeType()\ncode(argcount, nlocals, stacksize, flags, codestring, constants, names,\n      varnames, filename, name, firstlineno, lnotab[, freevars[, cellvars]])\n\nCreate a code object.  Not for the faint of heart.
ComplexType types.ComplexType()\ncomplex(real[, imag]) -> complex number\n\nCreate a complex number from a real part and an optional imaginary part.\nThis is equivalent to (real + imag*1j) where imag defaults to 0.
DictProxyType types.DictProxyType()\n
DictType types.DictType()\ndict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)
DictionaryType types.DictionaryType()\ndict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)
EllipsisType types.EllipsisType()\n
FileType types.FileType()\nfile(name[, mode[, buffering]]) -> file object\n\nOpen a file.  The mode can be 'r', 'w' or 'a' for reading (default),\nwriting or appending.  The file will be created if it doesn't exist\nwhen opened for writing or appending; it will be truncated when\nopened for writing.  Add a 'b' to the mode for binary files.\nAdd a '+' to the mode to allow simultaneous reading and writing.\nIf the buffering argument is given, 0 means unbuffered, 1 means line\nbuffered, and larger numbers specify the buffer size.  The preferred way\nto open a file is with the builtin open() function.\nAdd a 'U' to mode to open the file for input with universal newline\nsupport.  Any line ending in the input file will be seen as a '\\n'\nin Python.  Also, a file so opened gains the attribute 'newlines';\nthe value for this attribute is one of None (no newline read yet),\n'\r', '\\n', '\r\\n' or a tuple containing all the newline types seen.\n\n'U' cannot be combined with 'w' or '+' mode.
FloatType types.FloatType()\nfloat(x) -> floating point number\n\nConvert a string or number to a floating point number, if possible.
FrameType types.FrameType()\n
FunctionType types.FunctionType()\nfunction(code, globals[, name[, argdefs[, closure]]])\n\nCreate a function object from a code object and a dictionary.\nThe optional name string overrides the name from the code object.\nThe optional argdefs tuple specifies the default argument values.\nThe optional closure tuple supplies the bindings for free variables.
GeneratorType types.GeneratorType()\n
GetSetDescriptorType types.GetSetDescriptorType()\n
InstanceType types.InstanceType()\ninstance(class[, dict])\n\nCreate an instance without calling its __init__() method.\nThe class must be a classic class.\nIf present, dict must be a dictionary or None.
IntType types.IntType()\nint(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible.  A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!)  When converting a string, use\nthe optional base.  It is an error to supply a base when converting a\nnon-string.  If base is zero, the proper base is guessed based on the\nstring content.  If the argument is outside the integer range a\nlong object will be returned instead.
LambdaType types.LambdaType()\nfunction(code, globals[, name[, argdefs[, closure]]])\n\nCreate a function object from a code object and a dictionary.\nThe optional name string overrides the name from the code object.\nThe optional argdefs tuple specifies the default argument values.\nThe optional closure tuple supplies the bindings for free variables.
ListType types.ListType()\nlist() -> new empty list\nlist(iterable) -> new list initialized from iterable's items
LongType types.LongType()\nlong(x[, base]) -> integer\n\nConvert a string or number to a long integer, if possible.  A floating\npoint argument will be truncated towards zero (this does not include a\nstring representation of a floating point number!)  When converting a\nstring, use the optional base.  It is an error to supply a base when\nconverting a non-string.
MemberDescriptorType types.MemberDescriptorType()\n
MethodType types.MethodType()\ninstancemethod(function, instance, class)\n\nCreate an instance method object.
ModuleType types.ModuleType()\nmodule(name[, doc])\n\nCreate a module object.\nThe name must be a string; the optional doc argument can have any type.
NoneType types.NoneType()\n
NotImplementedType types.NotImplementedType()\n
ObjectType types.ObjectType()\nThe most base type
SliceType types.SliceType()\nslice([start,] stop[, step])\n\nCreate a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
StringType types.StringType()\nstr(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object.
StringTypes types.StringTypes [tuple]
TracebackType types.TracebackType()\n
TupleType types.TupleType()\ntuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable's items\n\nIf the argument is a tuple, the return value is the same object.
TypeType types.TypeType()\ntype(object) -> the object's type\ntype(name, bases, dict) -> a new type
UnboundMethodType types.UnboundMethodType()\ninstancemethod(function, instance, class)\n\nCreate an instance method object.
UnicodeType types.UnicodeType()\nunicode(string [, encoding[, errors]]) -> object\n\nCreate a new Unicode object from the given encoded string.\nencoding defaults to the current default string encoding.\nerrors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.
XRangeType types.XRangeType()\nxrange([start,] stop[, step]) -> xrange object\n\nLike range(), but instead of returning a list, returns an object that\ngenerates the numbers in the range on demand.  For looping, this is \nslightly faster than range() and more memory efficient.
__builtins__ types.__builtins__ [dict]
__doc__ types.__doc__ [str]
__file__ types.__file__ [str]
__name__ types.__name__ [str]
__package__ types.__package__ [NoneType]
math math\nThis module is always available.  It provides access to the\nmathematical functions defined by the C standard.
__doc__ math.__doc__ [str]
__name__ math.__name__ [str]
__package__ math.__package__ [NoneType]
acos math.acos(x)\n\nReturn the arc cosine (measured in radians) of x.
acosh math.acosh(x)\n\nReturn the hyperbolic arc cosine (measured in radians) of x.
asin math.asin(x)\n\nReturn the arc sine (measured in radians) of x.
asinh math.asinh(x)\n\nReturn the hyperbolic arc sine (measured in radians) of x.
atan math.atan(x)\n\nReturn the arc tangent (measured in radians) of x.
atan2 math.atan2(y, x)\n\nReturn the arc tangent (measured in radians) of y/x.\nUnlike atan(y/x), the signs of both x and y are considered.
atanh math.atanh(x)\n\nReturn the hyperbolic arc tangent (measured in radians) of x.
ceil math.ceil(x)\n\nReturn the ceiling of x as a float.\nThis is the smallest integral value >= x.
copysign math.copysign(x, y)\n\nReturn x with the sign of y.
cos math.cos(x)\n\nReturn the cosine of x (measured in radians).
cosh math.cosh(x)\n\nReturn the hyperbolic cosine of x.
degrees math.degrees(x)\n\nConvert angle x from radians to degrees.
e math.e [float]
erf math.erf(x)\n\nError function at x.
erfc math.erfc(x)\n\nComplementary error function at x.
exp math.exp(x)\n\nReturn e raised to the power of x.
expm1 math.expm1(x)\n\nReturn exp(x)-1.\nThis function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
fabs math.fabs(x)\n\nReturn the absolute value of the float x.
factorial math.factorial(x) -> Integral\n\nFind x!. Raise a ValueError if x is negative or non-integral.
floor math.floor(x)\n\nReturn the floor of x as a float.\nThis is the largest integral value <= x.
fmod math.fmod(x, y)\n\nReturn fmod(x, y), according to platform C.  x % y may differ.
frexp math.frexp(x)\n\nReturn the mantissa and exponent of x, as pair (m, e).\nm is a float and e is an int, such that x = m * 2.**e.\nIf x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
fsum math.fsum(iterable)\n\nReturn an accurate floating point sum of values in the iterable.\nAssumes IEEE-754 floating point arithmetic.
gamma math.gamma(x)\n\nGamma function at x.
hypot math.hypot(x, y)\n\nReturn the Euclidean distance, sqrt(x*x + y*y).
isinf math.isinf(x) -> bool\n\nCheck if float x is infinite (positive or negative).
isnan math.isnan(x) -> bool\n\nCheck if float x is not a number (NaN).
ldexp math.ldexp(x, i)\n\nReturn x * (2**i).
lgamma math.lgamma(x)\n\nNatural logarithm of absolute value of Gamma function at x.
log math.log(x[, base])\n\nReturn the logarithm of x to the given base.\nIf the base not specified, returns the natural logarithm (base e) of x.
log10 math.log10(x)\n\nReturn the base 10 logarithm of x.
log1p math.log1p(x)\n\nReturn the natural logarithm of 1+x (base e).\nThe result is computed in a way which is accurate for x near zero.
modf math.modf(x)\n\nReturn the fractional and integer parts of x.  Both results carry the sign\nof x and are floats.
pi math.pi [float]
pow math.pow(x, y)\n\nReturn x**y (x to the power of y).
radians math.radians(x)\n\nConvert angle x from degrees to radians.
sin math.sin(x)\n\nReturn the sine of x (measured in radians).
sinh math.sinh(x)\n\nReturn the hyperbolic sine of x.
sqrt math.sqrt(x)\n\nReturn the square root of x.
tan math.tan(x)\n\nReturn the tangent of x (measured in radians).
tanh math.tanh(x)\n\nReturn the hyperbolic tangent of x.
trunc math.trunc(x:Real) -> Integral\n\nTruncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
decimal decimal\n\nThis is a Py2.3 implementation of decimal floating point arithmetic based on\nthe General Decimal Arithmetic Specification:\n\n    www2.hursley.ibm.com/decimal/decarith.html\n\nand IEEE standard 854-1987:\n\n    www.cs.berkeley.edu/~ejr/projects/754/private/drafts/854-1987/dir.html\n\nDecimal floating point has finite precision with arbitrarily large bounds.\n\nThe purpose of this module is to support arithmetic using familiar\n"schoolhouse" rules and to avoid some of the tricky representation\nissues associated with binary floating point.  The package is especially\nuseful for financial applications or for contexts where users have\nexpectations that are at odds with binary floating point (for instance,\nin binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead\nof the expected Decimal('0.00') returned by decimal floating point).\n\nHere are some examples of using the decimal module:\n\n>>> from decimal import *\n>>> setcontext(ExtendedContext)\n>>> Decimal(0)\nDecimal('0')\n>>> Decimal('1')\nDecimal('1')\n>>> Decimal('-.0123')\nDecimal('-0.0123')\n>>> Decimal(123456)\nDecimal('123456')\n>>> Decimal('123.45e12345678901234567890')\nDecimal('1.2345E+12345678901234567892')\n>>> Decimal('1.33') + Decimal('1.27')\nDecimal('2.60')\n>>> Decimal('12.34') + Decimal('3.87') - Decimal('18.41')\nDecimal('-2.20')\n>>> dig = Decimal(1)\n>>> print dig / Decimal(3)\n0.333333333\n>>> getcontext().prec = 18\n>>> print dig / Decimal(3)\n0.333333333333333333\n>>> print dig.sqrt()\n1\n>>> print Decimal(3).sqrt()\n1.73205080756887729\n>>> print Decimal(3) ** 123\n4.85192780976896427E+58\n>>> inf = Decimal(1) / Decimal(0)\n>>> print inf\nInfinity\n>>> neginf = Decimal(-1) / Decimal(0)\n>>> print neginf\n-Infinity\n>>> print neginf + inf\nNaN\n>>> print neginf * inf\n-Infinity\n>>> print dig / 0\nInfinity\n>>> getcontext().traps[DivisionByZero] = 1\n>>> print dig / 0\nTraceback (most recent call last):\n  ...\n  ...\n  ...\nDivisionByZero: x / 0\n>>> c = Context()\n>>> c.traps[InvalidOperation] = 0\n>>> print c.flags[InvalidOperation]\n0\n>>> c.divide(Decimal(0), Decimal(0))\nDecimal('NaN')\n>>> c.traps[InvalidOperation] = 1\n>>> print c.flags[InvalidOperation]\n1\n>>> c.flags[InvalidOperation] = 0\n>>> print c.flags[InvalidOperation]\n0\n>>> print c.divide(Decimal(0), Decimal(0))\nTraceback (most recent call last):\n  ...\n  ...\n  ...\nInvalidOperation: 0 / 0\n>>> print c.flags[InvalidOperation]\n1\n>>> c.flags[InvalidOperation] = 0\n>>> c.traps[InvalidOperation] = 0\n>>> print c.divide(Decimal(0), Decimal(0))\nNaN\n>>> print c.flags[InvalidOperation]\n1\n>>>
BasicContext decimal.BasicContext [decimal.Context]
Clamped decimal.Clamped()\nExponent of a 0 changed to fit bounds.\n\n    This occurs and signals clamped if the exponent of a result has been\n    altered in order to fit the constraints of a specific concrete\n    representation.  This may occur when the exponent of a zero result would\n    be outside the bounds of a representation, or when a large normal\n    number would have an encoded exponent that cannot be represented.  In\n    this latter case, the exponent is reduced to fit and the corresponding\n    number of zero digits are appended to the coefficient ("fold-down").
Context decimal.Context()\nContains the context for a Decimal instance.\n\n    Contains:\n    prec - precision (for use in rounding, division, square roots..)\n    rounding - rounding type (how you round)\n    traps - If traps[exception] = 1, then the exception is\n                    raised when it is caused.  Otherwise, a value is\n                    substituted in.\n    flags  - When an exception is caused, flags[exception] is set.\n             (Whether or not the trap_enabler is set)\n             Should be reset by user of Decimal instance.\n    Emin -   Minimum exponent\n    Emax -   Maximum exponent\n    capitals -      If 1, 1*10^1 is printed as 1E+1.\n                    If 0, printed as 1e1\n    _clamp - If 1, change exponents if too high (Default 0)
ConversionSyntax decimal.ConversionSyntax()\nTrying to convert badly formed string.\n\n    This occurs and signals invalid-operation if an string is being\n    converted to a number and it does not conform to the numeric string\n    syntax.  The result is [0,qNaN].
Decimal decimal.Decimal()\nFloating point class for decimal arithmetic.
DecimalException decimal.DecimalException()\nBase exception class.\n\n    Used exceptions derive from this.\n    If an exception derives from another exception besides this (such as\n    Underflow (Inexact, Rounded, Subnormal) that indicates that it is only\n    called if the others are present.  This isn't actually used for\n    anything, though.\n\n    handle  -- Called when context._raise_error is called and the\n               trap_enabler is not set.  First argument is self, second is the\n               context.  More arguments can be given, those being after\n               the explanation in _raise_error (For example,\n               context._raise_error(NewError, '(-x)!', self._sign) would\n               call NewError().handle(context, self._sign).)\n\n    To define a new exception, it should be sufficient to have it derive\n    from DecimalException.
DecimalTuple decimal.DecimalTuple(sign, digits, exponent)
DefaultContext decimal.DefaultContext [decimal.Context]
DivisionByZero decimal.DivisionByZero()\nDivision by 0.\n\n    This occurs and signals division-by-zero if division of a finite number\n    by zero was attempted (during a divide-integer or divide operation, or a\n    power operation with negative right-hand operand), and the dividend was\n    not zero.\n\n    The result of the operation is [sign,inf], where sign is the exclusive\n    or of the signs of the operands for divide, or is 1 for an odd power of\n    -0, for power.
DivisionImpossible decimal.DivisionImpossible()\nCannot perform the division adequately.\n\n    This occurs and signals invalid-operation if the integer result of a\n    divide-integer or remainder operation had too many digits (would be\n    longer than precision).  The result is [0,qNaN].
DivisionUndefined decimal.DivisionUndefined()\nUndefined result of division.\n\n    This occurs and signals invalid-operation if division by zero was\n    attempted (during a divide-integer, divide, or remainder operation), and\n    the dividend is also zero.  The result is [0,qNaN].
ExtendedContext decimal.ExtendedContext [decimal.Context]
Inexact decimal.Inexact()\nHad to round, losing information.\n\n    This occurs and signals inexact whenever the result of an operation is\n    not exact (that is, it needed to be rounded and any discarded digits\n    were non-zero), or if an overflow or underflow condition occurs.  The\n    result in all cases is unchanged.\n\n    The inexact signal may be tested (or trapped) to determine if a given\n    operation (or sequence of operations) was inexact.
InvalidContext decimal.InvalidContext()\nInvalid context.  Unknown rounding, for example.\n\n    This occurs and signals invalid-operation if an invalid context was\n    detected during an operation.  This can occur if contexts are not checked\n    on creation and either the precision exceeds the capability of the\n    underlying concrete representation or an unknown or unsupported rounding\n    was specified.  These aspects of the context need only be checked when\n    the values are required to be used.  The result is [0,qNaN].
InvalidOperation decimal.InvalidOperation()\nAn invalid operation was performed.\n\n    Various bad things cause this:\n\n    Something creates a signaling NaN\n    -INF + INF\n    0 * (+-)INF\n    (+-)INF / (+-)INF\n    x % 0\n    (+-)INF % x\n    x._rescale( non-integer )\n    sqrt(-x) , x > 0\n    0 ** 0\n    x ** (non-integer)\n    x ** (+-)INF\n    An operand is invalid\n\n    The result of the operation after these is a quiet positive NaN,\n    except when the cause is a signaling NaN, in which case the result is\n    also a quiet NaN, but with the original sign, and an optional\n    diagnostic information.
Overflow decimal.Overflow()\nNumerical overflow.\n\n    This occurs and signals overflow if the adjusted exponent of a result\n    (from a conversion or from an operation that is not an attempt to divide\n    by zero), after rounding, would be greater than the largest value that\n    can be handled by the implementation (the value Emax).\n\n    The result depends on the rounding mode:\n\n    For round-half-up and round-half-even (and for round-half-down and\n    round-up, if implemented), the result of the operation is [sign,inf],\n    where sign is the sign of the intermediate result.  For round-down, the\n    result is the largest finite number that can be represented in the\n    current precision, with the sign of the intermediate result.  For\n    round-ceiling, the result is the same as for round-down if the sign of\n    the intermediate result is 1, or is [0,inf] otherwise.  For round-floor,\n    the result is the same as for round-down if the sign of the intermediate\n    result is 0, or is [1,inf] otherwise.  In all cases, Inexact and Rounded\n    will also be raised.
ROUND_05UP decimal.ROUND_05UP [str]
ROUND_CEILING decimal.ROUND_CEILING [str]
ROUND_DOWN decimal.ROUND_DOWN [str]
ROUND_FLOOR decimal.ROUND_FLOOR [str]
ROUND_HALF_DOWN decimal.ROUND_HALF_DOWN [str]
ROUND_HALF_EVEN decimal.ROUND_HALF_EVEN [str]
ROUND_HALF_UP decimal.ROUND_HALF_UP [str]
ROUND_UP decimal.ROUND_UP [str]
Rounded decimal.Rounded()\nNumber got rounded (not  necessarily changed during rounding).\n\n    This occurs and signals rounded whenever the result of an operation is\n    rounded (that is, some zero or non-zero digits were discarded from the\n    coefficient), or if an overflow or underflow condition occurs.  The\n    result in all cases is unchanged.\n\n    The rounded signal may be tested (or trapped) to determine if a given\n    operation (or sequence of operations) caused a loss of precision.
Subnormal decimal.Subnormal()\nExponent < Emin before rounding.\n\n    This occurs and signals subnormal whenever the result of a conversion or\n    operation is subnormal (that is, its adjusted exponent is less than\n    Emin, before any rounding).  The result in all cases is unchanged.\n\n    The subnormal signal may be tested (or trapped) to determine if a given\n    or operation (or sequence of operations) yielded a subnormal result.
Underflow decimal.Underflow()\nNumerical underflow with result rounded to 0.\n\n    This occurs and signals underflow if a result is inexact and the\n    adjusted exponent of the result would be smaller (more negative) than\n    the smallest value that can be handled by the implementation (the value\n    Emin).  That is, the result is both inexact and subnormal.\n\n    The result after an underflow will be a subnormal number rounded, if\n    necessary, so that its exponent is not less than Etiny.  This may result\n    in 0 with the sign of the intermediate result and an exponent of Etiny.\n\n    In all cases, Inexact, Rounded, and Subnormal will also be raised.
__all__ decimal.__all__ [list]
__builtins__ decimal.__builtins__ [dict]
__doc__ decimal.__doc__ [str]
__file__ decimal.__file__ [str]
__name__ decimal.__name__ [str]
__package__ decimal.__package__ [NoneType]
__version__ decimal.__version__ [str]
getcontext decimal.getcontext()\nReturns this thread's context.\n\n        If this thread does not yet have a context, returns\n        a new context and sets this thread's context.\n        New contexts are copies of DefaultContext.
localcontext decimal.localcontext() as ctx:\n                 ctx.prec += 2\n                 # Rest of sin calculation algorithm\n                 # uses a precision 2 greater than normal\n             return +s  # Convert result to normal precision\n\n         def sin(x):\n             with localcontext(ExtendedContext):\n                 # Rest of sin calculation algorithm\n                 # uses the Extended Context from the\n                 # General Decimal Arithmetic Specification\n             return +s  # Convert result to normal context\n\n    >>> setcontext(DefaultContext)\n    >>> print getcontext().prec\n    28\n    >>> with localcontext():\n    ...     ctx = getcontext()\n    ...     ctx.prec += 2\n    ...     print ctx.prec\n    ...\n    30\n    >>> with localcontext(ExtendedContext):\n    ...     print getcontext().prec\n    ...\n    9\n    >>> print getcontext().prec\n    28
setcontext decimal.setcontext()\nSet this thread's context to context.
random random\nRandom variable generators.\n\n    integers\n    --------\n           uniform within range\n\n    sequences\n    ---------\n           pick random element\n           pick random sample\n           generate random permutation\n\n    distributions on the real line:\n    ------------------------------\n           uniform\n           triangular\n           normal (Gaussian)\n           lognormal\n           negative exponential\n           gamma\n           beta\n           pareto\n           Weibull\n\n    distributions on the circle (angles 0 to 2pi)\n    ---------------------------------------------\n           circular uniform\n           von Mises\n\nGeneral notes on the underlying Mersenne Twister core generator:\n\n* The period is 2**19937-1.\n* It is one of the most extensively tested generators in existence.\n* Without a direct way to compute N steps forward, the semantics of\n  jumpahead(n) are weakened to simply jump to another distant state and rely\n  on the large period to avoid overlapping sequences.\n* The random() method is implemented in C, executes in a single Python step,\n  and is, therefore, threadsafe.
BPF random.BPF [int]
LOG4 random.LOG4 [float]
NV_MAGICCONST random.NV_MAGICCONST [float]
RECIP_BPF random.RECIP_BPF [float]
Random random.Random()\nRandom number generator base class used by bound module functions.\n\n    Used to instantiate instances of Random to get generators that don't\n    share state.  Especially useful for multi-threaded programs, creating\n    a different instance of Random for each thread, and using the jumpahead()\n    method to ensure that the generated sequences seen by each thread don't\n    overlap.\n\n    Class Random can also be subclassed if you want to use a different basic\n    generator of your own devising: in that case, override the following\n    methods: random(), seed(), getstate(), setstate() and jumpahead().\n    Optionally, implement a getrandbits() method so that randrange() can cover\n    arbitrarily large ranges.
SG_MAGICCONST random.SG_MAGICCONST [float]
SystemRandom random.SystemRandom()\nAlternate random number generator using sources provided\n    by the operating system (such as /dev/urandom on Unix or\n    CryptGenRandom on Windows).\n\n     Not available on all systems (see os.urandom() for details).
TWOPI random.TWOPI [float]
WichmannHill random.WichmannHill()\n
__all__ random.__all__ [list]
__builtins__ random.__builtins__ [dict]
__doc__ random.__doc__ [str]
__file__ random.__file__ [str]
__name__ random.__name__ [str]
__package__ random.__package__ [NoneType]
betavariate random.betavariate()\nBeta distribution.\n\n        Conditions on the parameters are alpha > 0 and beta > 0.\n        Returned values range between 0 and 1.
choice random.choice()\nChoose a random element from a non-empty sequence.
division random.division [instance]
expovariate random.expovariate()\nExponential distribution.\n\n        lambd is 1.0 divided by the desired mean.  It should be\n        nonzero.  (The parameter would be called "lambda", but that is\n        a reserved word in Python.)  Returned values range from 0 to\n        positive infinity if lambd is positive, and from negative\n        infinity to 0 if lambd is negative.
gammavariate random.gammavariate()\nGamma distribution.  Not the gamma function!\n\n        Conditions on the parameters are alpha > 0 and beta > 0.\n\n        The probability distribution function is:\n\n                    x ** (alpha - 1) * math.exp(-x / beta)\n          pdf(x) =  --------------------------------------\n                      math.gamma(alpha) * beta ** alpha
gauss random.gauss()\nGaussian distribution.\n\n        mu is the mean, and sigma is the standard deviation.  This is\n        slightly faster than the normalvariate() function.\n\n        Not thread-safe without a lock around calls.
getrandbits random.getrandbits(k) -> x.  Generates a long int with k random bits.
getstate random.getstate()\nReturn internal state; can be passed to setstate() later.
jumpahead random.jumpahead()\nChange the internal state to one that is likely far away\n        from the current state.  This method will not be in Py3.x,\n        so it is better to simply reseed.
lognormvariate random.lognormvariate()\nLog normal distribution.\n\n        If you take the natural logarithm of this distribution, you'll get a\n        normal distribution with mean mu and standard deviation sigma.\n        mu can have any value, and sigma must be greater than zero.
normalvariate random.normalvariate()\nNormal distribution.\n\n        mu is the mean, and sigma is the standard deviation.
paretovariate random.paretovariate()\nPareto distribution.  alpha is the shape parameter.
randint random.randint()\nReturn random integer in range [a, b], including both end points.
random random.random() -> x in the interval [0, 1).
randrange random.randrange()\nChoose a random item from range(start, stop[, step]).\n\n        This fixes the problem with randint() which includes the\n        endpoint; in Python this is usually not what you want.\n        Do not supply the 'int', 'default', and 'maxwidth' arguments.
sample random.sample(xrange(10000000), 60)
seed random.seed()\nInitialize internal state from hashable object.\n\n        None or no argument seeds from current time or from an operating\n        system specific randomness source if available.\n\n        If a is not None or an int or long, hash(a) is used instead.
setstate random.setstate()\nRestore internal state from object returned by getstate().
shuffle random.shuffle()\nx, random=random.random -> shuffle list x in place; return None.\n\n        Optional arg random is a 0-argument function returning a random\n        float in [0.0, 1.0); by default, the standard random.random.
triangular random.triangular()\nTriangular distribution.\n\n        Continuous distribution bounded by given lower and upper limits,\n        and having a given mode value in-between.\n\n        http://en.wikipedia.org/wiki/Triangular_distribution
uniform random.uniform()\nGet a random number in the range [a, b) or [a, b] depending on rounding.
vonmisesvariate random.vonmisesvariate()\nCircular data distribution.\n\n        mu is the mean angle, expressed in radians between 0 and 2*pi, and\n        kappa is the concentration parameter, which must be greater than or\n        equal to zero.  If kappa is equal to zero, this distribution reduces\n        to a uniform random angle over the range 0 to 2*pi.
weibullvariate random.weibullvariate()\nWeibull distribution.\n\n        alpha is the scale parameter and beta is the shape parameter.
tempfile tempfile\nTemporary files.\n\nThis module provides generic, low- and high-level interfaces for\ncreating temporary files and directories.  The interfaces listed\nas "safe" just below can be used without fear of race conditions.\nThose listed as "unsafe" cannot, and are provided for backward\ncompatibility only.\n\nThis module also provides some data items to the user:\n\n  TMP_MAX  - maximum number of names that will be tried before\n             giving up.\n  template - the default prefix for all temporary names.\n             You may change this to control the default prefix.\n  tempdir  - If this is set to a string before the first use of\n             any routine from this module, it will be considered as\n             another candidate location to store temporary files.
NamedTemporaryFile tempfile.NamedTemporaryFile()\nCreate and return a temporary file.\n    Arguments:\n    'prefix', 'suffix', 'dir' -- as for mkstemp.\n    'mode' -- the mode argument to os.fdopen (default "w+b").\n    'bufsize' -- the buffer size argument to os.fdopen (default -1).\n    'delete' -- whether the file is deleted on close (default True).\n    The file is created as mkstemp() would do it.\n\n    Returns an object with a file-like interface; the name of the file\n    is accessible as file.name.  The file will be automatically deleted\n    when it is closed unless the 'delete' argument is set to False.
SpooledTemporaryFile tempfile.SpooledTemporaryFile\nTemporary file wrapper, specialized to switch from\n    StringIO to a real file when it exceeds a certain size or\n    when a fileno is needed.
__doc__ SpooledTemporaryFile.__doc__ [str]
__enter__ SpooledTemporaryFile.__enter__()\n
__exit__ SpooledTemporaryFile.__exit__()\n
__init__ SpooledTemporaryFile.__init__()\n
__iter__ SpooledTemporaryFile.__iter__()\n
__module__ SpooledTemporaryFile.__module__ [str]
close SpooledTemporaryFile.close()\n
closed SpooledTemporaryFile.closed [property]
encoding SpooledTemporaryFile.encoding [property]
fileno SpooledTemporaryFile.fileno()\n
flush SpooledTemporaryFile.flush()\n
isatty SpooledTemporaryFile.isatty()\n
mode SpooledTemporaryFile.mode [property]
name SpooledTemporaryFile.name [property]
newlines SpooledTemporaryFile.newlines [property]
next SpooledTemporaryFile.next()\n
read SpooledTemporaryFile.read()\n
readline SpooledTemporaryFile.readline()\n
readlines SpooledTemporaryFile.readlines()\n
rollover SpooledTemporaryFile.rollover()\n
seek SpooledTemporaryFile.seek()\n
softspace SpooledTemporaryFile.softspace [property]
tell SpooledTemporaryFile.tell()\n
truncate SpooledTemporaryFile.truncate()\n
write SpooledTemporaryFile.write()\n
writelines SpooledTemporaryFile.writelines()\n
xreadlines SpooledTemporaryFile.xreadlines()\n
TMP_MAX tempfile.TMP_MAX [int]
TemporaryFile tempfile.TemporaryFile()\nCreate and return a temporary file.\n        Arguments:\n        'prefix', 'suffix', 'dir' -- as for mkstemp.\n        'mode' -- the mode argument to os.fdopen (default "w+b").\n        'bufsize' -- the buffer size argument to os.fdopen (default -1).\n        The file is created as mkstemp() would do it.\n\n        Returns an object with a file-like interface.  The file has no\n        name, and will cease to exist when it is closed.
__all__ tempfile.__all__ [list]
__builtins__ tempfile.__builtins__ [dict]
__doc__ tempfile.__doc__ [str]
__file__ tempfile.__file__ [str]
__name__ tempfile.__name__ [str]
__package__ tempfile.__package__ [NoneType]
gettempdir tempfile.gettempdir()\nAccessor for tempfile.tempdir.
gettempprefix tempfile.gettempprefix()\nAccessor for tempdir.template.
mkdtemp tempfile.mkdtemp()\nUser-callable function to create and return a unique temporary\n    directory.  The return value is the pathname of the directory.\n\n    Arguments are as for mkstemp, except that the 'text' argument is\n    not accepted.\n\n    The directory is readable, writable, and searchable only by the\n    creating user.\n\n    Caller is responsible for deleting the directory when done with it.
mkstemp tempfile.mkstemp()\nUser-callable function to create and return a unique temporary\n    file.  The return value is a pair (fd, name) where fd is the\n    file descriptor returned by os.open, and name is the filename.\n\n    If 'suffix' is specified, the file name will end with that suffix,\n    otherwise there will be no suffix.\n\n    If 'prefix' is specified, the file name will begin with that prefix,\n    otherwise a default prefix is used.\n\n    If 'dir' is specified, the file will be created in that directory,\n    otherwise a default directory is used.\n\n    If 'text' is specified and true, the file is opened in text\n    mode.  Else (the default) the file is opened in binary mode.  On\n    some operating systems, this makes no difference.\n\n    The file is readable and writable only by the creating user ID.\n    If the operating system uses permission bits to indicate whether a\n    file is executable, the file is executable by no one. The file\n    descriptor is not inherited by children of this process.\n\n    Caller is responsible for deleting the file when done with it.
mktemp tempfile.mktemp()\nUser-callable function to return a unique temporary file name.  The\n    file is not created.\n\n    Arguments are as for mkstemp, except that the 'text' argument is\n    not accepted.\n\n    This function is unsafe and should not be used.  The file name\n    refers to a file that did not exist at some point, but by the time\n    you get around to creating it, someone else may have beaten you to\n    the punch.
tempdir tempfile.tempdir [NoneType]
template tempfile.template [str]
os os\nOS routines for Mac, NT, or Posix depending on what system we're on.\n\nThis exports:\n  - all functions from posix, nt, os2, or ce, e.g. unlink, stat, etc.\n  - os.path is one of the modules posixpath, or ntpath\n  - os.name is 'posix', 'nt', 'os2', 'ce' or 'riscos'\n  - os.curdir is a string representing the current directory ('.' or ':')\n  - os.pardir is a string representing the parent directory ('..' or '::')\n  - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\')\n  - os.extsep is the extension separator ('.' or '/')\n  - os.altsep is the alternate pathname separator (None or '/')\n  - os.pathsep is the component separator used in $PATH etc\n  - os.linesep is the line separator in text files ('\r' or '\\n' or '\r\\n')\n  - os.defpath is the default search path for executables\n  - os.devnull is the file path of the null device ('/dev/null', etc.)\n\nPrograms that import and use 'os' stand a better chance of being\nportable between different platforms.  Of course, they must then\nonly use functions that are defined by all platforms (e.g., unlink\nand opendir), and leave all pathname manipulation to os.path\n(e.g., split and join).
EX_CANTCREAT os.EX_CANTCREAT [int]
EX_CONFIG os.EX_CONFIG [int]
EX_DATAERR os.EX_DATAERR [int]
EX_IOERR os.EX_IOERR [int]
EX_NOHOST os.EX_NOHOST [int]
EX_NOINPUT os.EX_NOINPUT [int]
EX_NOPERM os.EX_NOPERM [int]
EX_NOUSER os.EX_NOUSER [int]
EX_OK os.EX_OK [int]
EX_OSERR os.EX_OSERR [int]
EX_OSFILE os.EX_OSFILE [int]
EX_PROTOCOL os.EX_PROTOCOL [int]
EX_SOFTWARE os.EX_SOFTWARE [int]
EX_TEMPFAIL os.EX_TEMPFAIL [int]
EX_UNAVAILABLE os.EX_UNAVAILABLE [int]
EX_USAGE os.EX_USAGE [int]
F_OK os.F_OK [int]
NGROUPS_MAX os.NGROUPS_MAX [int]
O_APPEND os.O_APPEND [int]
O_ASYNC os.O_ASYNC [int]
O_CREAT os.O_CREAT [int]
O_DIRECT os.O_DIRECT [int]
O_DIRECTORY os.O_DIRECTORY [int]
O_DSYNC os.O_DSYNC [int]
O_EXCL os.O_EXCL [int]
O_LARGEFILE os.O_LARGEFILE [int]
O_NDELAY os.O_NDELAY [int]
O_NOATIME os.O_NOATIME [int]
O_NOCTTY os.O_NOCTTY [int]
O_NOFOLLOW os.O_NOFOLLOW [int]
O_NONBLOCK os.O_NONBLOCK [int]
O_RDONLY os.O_RDONLY [int]
O_RDWR os.O_RDWR [int]
O_RSYNC os.O_RSYNC [int]
O_SYNC os.O_SYNC [int]
O_TRUNC os.O_TRUNC [int]
O_WRONLY os.O_WRONLY [int]
P_NOWAIT os.P_NOWAIT [int]
P_NOWAITO os.P_NOWAITO [int]
P_WAIT os.P_WAIT [int]
R_OK os.R_OK [int]
SEEK_CUR os.SEEK_CUR [int]
SEEK_END os.SEEK_END [int]
SEEK_SET os.SEEK_SET [int]
ST_APPEND os.ST_APPEND [int]
ST_MANDLOCK os.ST_MANDLOCK [int]
ST_NOATIME os.ST_NOATIME [int]
ST_NODEV os.ST_NODEV [int]
ST_NODIRATIME os.ST_NODIRATIME [int]
ST_NOEXEC os.ST_NOEXEC [int]
ST_NOSUID os.ST_NOSUID [int]
ST_RDONLY os.ST_RDONLY [int]
ST_RELATIME os.ST_RELATIME [int]
ST_SYNCHRONOUS os.ST_SYNCHRONOUS [int]
ST_WRITE os.ST_WRITE [int]
TMP_MAX os.TMP_MAX [int]
WCONTINUED os.WCONTINUED [int]
WCOREDUMP os.WCOREDUMP(status) -> bool\n\nReturn True if the process returning 'status' was dumped to a core file.
WEXITSTATUS os.WEXITSTATUS(status) -> integer\n\nReturn the process return code from 'status'.
WIFCONTINUED os.WIFCONTINUED(status) -> bool\n\nReturn True if the process returning 'status' was continued from a\njob control stop.
WIFEXITED os.WIFEXITED(status) -> bool\n\nReturn true if the process returning 'status' exited using the exit()\nsystem call.
WIFSIGNALED os.WIFSIGNALED(status) -> bool\n\nReturn True if the process returning 'status' was terminated by a signal.
WIFSTOPPED os.WIFSTOPPED(status) -> bool\n\nReturn True if the process returning 'status' was stopped.
WNOHANG os.WNOHANG [int]
WSTOPSIG os.WSTOPSIG(status) -> integer\n\nReturn the signal that stopped the process that provided\nthe 'status' value.
WTERMSIG os.WTERMSIG(status) -> integer\n\nReturn the signal that terminated the process that provided the 'status'\nvalue.
WUNTRACED os.WUNTRACED [int]
W_OK os.W_OK [int]
X_OK os.X_OK [int]
__all__ os.__all__ [list]
__builtins__ os.__builtins__ [dict]
__doc__ os.__doc__ [str]
__file__ os.__file__ [str]
__name__ os.__name__ [str]
__package__ os.__package__ [NoneType]
abort os.abort() -> does not return!\n\nAbort the interpreter immediately.  This 'dumps core' or otherwise fails\nin the hardest way possible on the hosting operating system.
access os.access(path, mode) -> True if granted, False otherwise\n\nUse the real uid/gid to test for access to a path.  Note that most\noperations will use the effective uid/gid, therefore this routine can\nbe used in a suid/sgid environment to test if the invoking user has the\nspecified access to the path.  The mode argument can be F_OK to test\nexistence, or the inclusive-OR of R_OK, W_OK, and X_OK.
altsep os.altsep [NoneType]
chdir os.chdir(path)\n\nChange the current working directory to the specified path.
chmod os.chmod(path, mode)\n\nChange the access permissions of a file.
chown os.chown(path, uid, gid)\n\nChange the owner and group id of path to the numeric uid and gid.
chroot os.chroot(path)\n\nChange root directory to path.
close os.close(fd)\n\nClose a file descriptor (for low level IO).
closerange os.closerange(fd_low, fd_high)\n\nCloses all file descriptors in [fd_low, fd_high), ignoring errors.
confstr os.confstr(name) -> string\n\nReturn a string-valued system configuration variable.
confstr_names os.confstr_names [dict]
ctermid os.ctermid() -> string\n\nReturn the name of the controlling terminal for this process.
curdir os.curdir [str]
defpath os.defpath [str]
devnull os.devnull [str]
dup os.dup(fd) -> fd2\n\nReturn a duplicate of a file descriptor.
dup2 os.dup2(old_fd, new_fd)\n\nDuplicate file descriptor.
environ os.environ [instance]
error os.error()\nOS system call failed.
execl os.execl(file, *args)\n\n    Execute the executable file with argument list args, replacing the\n    current process.
execle os.execle(file, *args, env)\n\n    Execute the executable file with argument list args and\n    environment env, replacing the current process.
execlp os.execlp(file, *args)\n\n    Execute the executable file (which is searched for along $PATH)\n    with argument list args, replacing the current process.
execlpe os.execlpe(file, *args, env)\n\n    Execute the executable file (which is searched for along $PATH)\n    with argument list args and environment env, replacing the current\n    process.
execv os.execv(path, args)\n\nExecute an executable path with arguments, replacing current process.\n\n    path: path of executable file\n    args: tuple or list of strings
execve os.execve(path, args, env)\n\nExecute a path with arguments and environment, replacing current process.\n\n    path: path of executable file\n    args: tuple or list of arguments\n    env: dictionary of strings mapping to strings
execvp os.execvp(file, args)\n\n    Execute the executable file (which is searched for along $PATH)\n    with argument list args, replacing the current process.\n    args may be a list or tuple of strings.
execvpe os.execvpe(file, args, env)\n\n    Execute the executable file (which is searched for along $PATH)\n    with argument list args and environment env , replacing the\n    current process.\n    args may be a list or tuple of strings.
extsep os.extsep [str]
fchdir os.fchdir(fildes)\n\nChange to the directory of the given file descriptor.  fildes must be\nopened on a directory, not a file.
fchmod os.fchmod(fd, mode)\n\nChange the access permissions of the file given by file\ndescriptor fd.
fchown os.fchown(fd, uid, gid)\n\nChange the owner and group id of the file given by file descriptor\nfd to the numeric uid and gid.
fdatasync os.fdatasync(fildes)\n\nforce write of file with filedescriptor to disk.\n does not force update of metadata.
fdopen os.fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\nReturn an open file object connected to a file descriptor.
fork os.fork() -> pid\n\nFork a child process.\nReturn 0 to child process and PID of child to parent process.
forkpty os.forkpty() -> (pid, master_fd)\n\nFork a new process with a new pseudo-terminal as controlling tty.\n\nLike fork(), return 0 as pid to child process, and PID of child to parent.\nTo both, return fd of newly opened pseudo-terminal.
fpathconf os.fpathconf(fd, name) -> integer\n\nReturn the configuration limit name for the file descriptor fd.\nIf there is no limit, return -1.
fstat os.fstat(fd) -> stat result\n\nLike stat(), but for an open file descriptor.
fstatvfs os.fstatvfs(fd) -> statvfs result\n\nPerform an fstatvfs system call on the given fd.
fsync os.fsync(fildes)\n\nforce write of file with filedescriptor to disk.
ftruncate os.ftruncate(fd, length)\n\nTruncate a file to a specified length.
getcwd os.getcwd() -> path\n\nReturn a string representing the current working directory.
getcwdu os.getcwdu() -> path\n\nReturn a unicode string representing the current working directory.
getegid os.getegid() -> egid\n\nReturn the current process's effective group id.
getenv os.getenv()\nGet an environment variable, return None if it doesn't exist.\n    The optional second argument can specify an alternate default.
geteuid os.geteuid() -> euid\n\nReturn the current process's effective user id.
getgid os.getgid() -> gid\n\nReturn the current process's group id.
getgroups os.getgroups() -> list of group IDs\n\nReturn list of supplemental group IDs for the process.
getloadavg os.getloadavg() -> (float, float, float)\n\nReturn the number of processes in the system run queue averaged over\nthe last 1, 5, and 15 minutes or raises OSError if the load average\nwas unobtainable
getlogin os.getlogin() -> string\n\nReturn the actual login name.
getpgid os.getpgid(pid) -> pgid\n\nCall the system call getpgid().
getpgrp os.getpgrp() -> pgrp\n\nReturn the current process group id.
getpid os.getpid() -> pid\n\nReturn the current process id
getppid os.getppid() -> ppid\n\nReturn the parent's process id.
getresgid os.getresgid() -> (rgid, egid, sgid)\n\nGet tuple of the current process's real, effective, and saved group ids.
getresuid os.getresuid() -> (ruid, euid, suid)\n\nGet tuple of the current process's real, effective, and saved user ids.
getsid os.getsid(pid) -> sid\n\nCall the system call getsid().
getuid os.getuid() -> uid\n\nReturn the current process's user id.
initgroups os.initgroups(username, gid) -> None\n\nCall the system initgroups() to initialize the group access list with all of\nthe groups of which the specified username is a member, plus the specified\ngroup id.
isatty os.isatty(fd) -> bool\n\nReturn True if the file descriptor 'fd' is an open file descriptor\nconnected to the slave end of a terminal.
kill os.kill(pid, sig)\n\nKill a process with a signal.
killpg os.killpg(pgid, sig)\n\nKill a process group with a signal.
lchown os.lchown(path, uid, gid)\n\nChange the owner and group id of path to the numeric uid and gid.\nThis function will not follow symbolic links.
linesep os.linesep [str]
link os.link(src, dst)\n\nCreate a hard link to a file.
listdir os.listdir(path) -> list_of_strings\n\nReturn a list containing the names of the entries in the directory.\n\n    path: path of directory to list\n\nThe list is in arbitrary order.  It does not include the special\nentries '.' and '..' even if they are present in the directory.
lseek os.lseek(fd, pos, how) -> newpos\n\nSet the current position of a file descriptor.
lstat os.lstat(path) -> stat result\n\nLike stat(path), but do not follow symbolic links.
major os.major(device) -> major number\nExtracts a device major number from a raw device number.
makedev os.makedev(major, minor) -> device number\nComposes a raw device number from the major and minor device numbers.
makedirs os.makedirs(path [, mode=0777])\n\n    Super-mkdir; create a leaf directory and all intermediate ones.\n    Works like mkdir, except that any intermediate path segment (not\n    just the rightmost) will be created if it does not exist.  This is\n    recursive.
minor os.minor(device) -> minor number\nExtracts a device minor number from a raw device number.
mkdir os.mkdir(path [, mode=0777])\n\nCreate a directory.
mkfifo os.mkfifo(filename [, mode=0666])\n\nCreate a FIFO (a POSIX named pipe).
mknod os.mknod(filename [, mode=0600, device])\n\nCreate a filesystem node (file, device special file or named pipe)\nnamed filename. mode specifies both the permissions to use and the\ntype of node to be created, being combined (bitwise OR) with one of\nS_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\ndevice defines the newly created device special file (probably using\nos.makedev()), otherwise it is ignored.
name os.name [str]
nice os.nice(inc) -> new_priority\n\nDecrease the priority of process by inc and return the new priority.
open os.open(filename, flag [, mode=0777]) -> fd\n\nOpen a file (for low level IO).
openpty os.openpty() -> (master_fd, slave_fd)\n\nOpen a pseudo-terminal, returning open fd's for both master and slave end.
pardir os.pardir [str]
path os.path\nCommon operations on Posix pathnames.\n\nInstead of importing this module directly, import os and refer to\nthis module as os.path.  The "os.path" name is an alias for this\nmodule on Posix systems; on other systems (e.g. Mac, Windows),\nos.path provides the same operations in a manner specific to that\nplatform, and is an alias to another module (e.g. macpath, ntpath).\n\nSome of this can actually be useful on non-Posix systems too, e.g.\nfor manipulation of the pathname component of URLs.
__all__ os.path.__all__ [list]
__builtins__ os.path.__builtins__ [dict]
__doc__ os.path.__doc__ [str]
__file__ os.path.__file__ [str]
__name__ os.path.__name__ [str]
__package__ os.path.__package__ [NoneType]
abspath os.path.abspath()\nReturn an absolute path.
altsep os.path.altsep [NoneType]
basename os.path.basename()\nReturns the final component of a pathname
commonprefix os.path.commonprefix()\nGiven a list of pathnames, returns the longest common leading component
curdir os.path.curdir [str]
defpath os.path.defpath [str]
devnull os.path.devnull [str]
dirname os.path.dirname()\nReturns the directory component of a pathname
exists os.path.exists()\nTest whether a path exists.  Returns False for broken symbolic links
expanduser os.path.expanduser()\nExpand ~ and ~user constructions.  If user or $HOME is unknown,\n    do nothing.
expandvars os.path.expandvars()\nExpand shell variables of form $var and ${var}.  Unknown variables\n    are left unchanged.
extsep os.path.extsep [str]
getatime os.path.getatime()\nReturn the last access time of a file, reported by os.stat().
getctime os.path.getctime()\nReturn the metadata change time of a file, reported by os.stat().
getmtime os.path.getmtime()\nReturn the last modification time of a file, reported by os.stat().
getsize os.path.getsize()\nReturn the size of a file, reported by os.stat().
isabs os.path.isabs()\nTest whether a path is absolute
isdir os.path.isdir()\nReturn true if the pathname refers to an existing directory.
isfile os.path.isfile()\nTest whether a path is a regular file
islink os.path.islink()\nTest whether a path is a symbolic link
ismount os.path.ismount()\nTest whether a path is a mount point
join os.path.join()\nJoin two or more pathname components, inserting '/' as needed.\n    If any component is an absolute path, all previous path components\n    will be discarded.
lexists os.path.lexists()\nTest whether a path exists.  Returns True for broken symbolic links
normcase os.path.normcase()\nNormalize case of pathname.  Has no effect under Posix
normpath os.path.normpath()\nNormalize path, eliminating double slashes, etc.
pardir os.path.pardir [str]
pathsep os.path.pathsep [str]
realpath os.path.realpath()\nReturn the canonical path of the specified filename, eliminating any\nsymbolic links encountered in the path.
relpath os.path.relpath()\nReturn a relative version of a path
samefile os.path.samefile()\nTest whether two pathnames reference the same actual file
sameopenfile os.path.sameopenfile()\nTest whether two open file objects reference the same file
samestat os.path.samestat()\nTest whether two stat buffers reference the same file
sep os.path.sep [str]
split os.path.split()\nSplit a pathname.  Returns tuple "(head, tail)" where "tail" is\n    everything after the final slash.  Either part may be empty.
splitdrive os.path.splitdrive()\nSplit a pathname into drive and path. On Posix, drive is always\n    empty.
splitext os.path.splitext()\nSplit the extension from a pathname.\n\n    Extension is everything from the last dot to the end, ignoring\n    leading dots.  Returns "(root, ext)"; ext may be empty.
supports_unicode_filenames os.path.supports_unicode_filenames [bool]
walk os.path.walk()\nDirectory tree walk with callback function.\n\n    For each directory in the directory tree rooted at top (including top\n    itself, but excluding '.' and '..'), call func(arg, dirname, fnames).\n    dirname is the name of the directory, and fnames a list of the names of\n    the files and subdirectories in dirname (excluding '.' and '..').  func\n    may modify the fnames list in-place (e.g. via del or slice assignment),\n    and walk will only recurse into the subdirectories whose names remain in\n    fnames; this can be used to implement a filter, or to impose a specific\n    order of visiting.  No semantics are defined for, or required of, arg,\n    beyond that arg is always passed to func.  It can be used, e.g., to pass\n    a filename pattern, or a mutable object designed to accumulate\n    statistics.  Passing None for arg is common.
pathconf os.pathconf(path, name) -> integer\n\nReturn the configuration limit name for the file or directory path.\nIf there is no limit, return -1.
pathconf_names os.pathconf_names [dict]
pathsep os.pathsep [str]
pipe os.pipe() -> (read_end, write_end)\n\nCreate a pipe.
popen os.popen(command [, mode='r' [, bufsize]]) -> pipe\n\nOpen a pipe to/from a command returning a file object.
popen2 os.popen2()\nExecute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'\n            may be a sequence, in which case arguments will be passed directly to\n            the program without shell intervention (as with os.spawnv()).  If 'cmd'\n            is a string it will be passed to the shell (as with os.system()). If\n            'bufsize' is specified, it sets the buffer size for the I/O pipes.  The\n            file objects (child_stdin, child_stdout) are returned.
popen3 os.popen3()\nExecute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'\n            may be a sequence, in which case arguments will be passed directly to\n            the program without shell intervention (as with os.spawnv()).  If 'cmd'\n            is a string it will be passed to the shell (as with os.system()). If\n            'bufsize' is specified, it sets the buffer size for the I/O pipes.  The\n            file objects (child_stdin, child_stdout, child_stderr) are returned.
popen4 os.popen4()\nExecute the shell command 'cmd' in a sub-process.  On UNIX, 'cmd'\n            may be a sequence, in which case arguments will be passed directly to\n            the program without shell intervention (as with os.spawnv()).  If 'cmd'\n            is a string it will be passed to the shell (as with os.system()). If\n            'bufsize' is specified, it sets the buffer size for the I/O pipes.  The\n            file objects (child_stdin, child_stdout_stderr) are returned.
putenv os.putenv(key, value)\n\nChange or add an environment variable.
read os.read(fd, buffersize) -> string\n\nRead a file descriptor.
readlink os.readlink(path) -> path\n\nReturn a string representing the path to which the symbolic link points.
remove os.remove(path)\n\nRemove a file (same as unlink(path)).
removedirs os.removedirs(path)\n\n    Super-rmdir; remove a leaf directory and all empty intermediate\n    ones.  Works like rmdir except that, if the leaf directory is\n    successfully removed, directories corresponding to rightmost path\n    segments will be pruned away until either the whole path is\n    consumed or an error occurs.  Errors during this latter phase are\n    ignored -- they generally mean that a directory was not empty.
rename os.rename(old, new)\n\nRename a file or directory.
renames os.renames(old, new)\n\n    Super-rename; create directories as necessary and delete any left\n    empty.  Works like rename, except creation of any intermediate\n    directories needed to make the new pathname good is attempted\n    first.  After the rename, directories corresponding to rightmost\n    path segments of the old name will be pruned way until either the\n    whole path is consumed or a nonempty directory is found.\n\n    Note: this function can fail with the new directory structure made\n    if you lack permissions needed to unlink the leaf directory or\n    file.
rmdir os.rmdir(path)\n\nRemove a directory.
sep os.sep [str]
setegid os.setegid(gid)\n\nSet the current process's effective group id.
seteuid os.seteuid(uid)\n\nSet the current process's effective user id.
setgid os.setgid(gid)\n\nSet the current process's group id.
setgroups os.setgroups(list)\n\nSet the groups of the current process to list.
setpgid os.setpgid(pid, pgrp)\n\nCall the system call setpgid().
setpgrp os.setpgrp()\n\nMake this process the process group leader.
setregid os.setregid(rgid, egid)\n\nSet the current process's real and effective group ids.
setresgid os.setresgid(rgid, egid, sgid)\n\nSet the current process's real, effective, and saved group ids.
setresuid os.setresuid(ruid, euid, suid)\n\nSet the current process's real, effective, and saved user ids.
setreuid os.setreuid(ruid, euid)\n\nSet the current process's real and effective user ids.
setsid os.setsid()\n\nCall the system call setsid().
setuid os.setuid(uid)\n\nSet the current process's user id.
spawnl os.spawnl(mode, file, *args) -> integer\n\nExecute file with arguments from args in a subprocess.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnle os.spawnle(mode, file, *args, env) -> integer\n\nExecute file with arguments from args in a subprocess with the\nsupplied environment.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnlp os.spawnlp(mode, file, *args) -> integer\n\nExecute file (which is looked for along $PATH) with arguments from\nargs in a subprocess with the supplied environment.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnlpe os.spawnlpe(mode, file, *args, env) -> integer\n\nExecute file (which is looked for along $PATH) with arguments from\nargs in a subprocess with the supplied environment.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnv os.spawnv(mode, file, args) -> integer\n\nExecute file with arguments from args in a subprocess.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnve os.spawnve(mode, file, args, env) -> integer\n\nExecute file with arguments from args in a subprocess with the\nspecified environment.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnvp os.spawnvp(mode, file, args) -> integer\n\nExecute file (which is looked for along $PATH) with arguments from\nargs in a subprocess.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
spawnvpe os.spawnvpe(mode, file, args, env) -> integer\n\nExecute file (which is looked for along $PATH) with arguments from\nargs in a subprocess with the supplied environment.\nIf mode == P_NOWAIT return the pid of the process.\nIf mode == P_WAIT return the process's exit code if it exits normally;\notherwise return -SIG, where SIG is the signal that killed it.
stat os.stat(path) -> stat result\n\nPerform a stat system call on the given path.
stat_float_times os.stat_float_times([newval]) -> oldval\n\nDetermine whether os.[lf]stat represents time stamps as float objects.\nIf newval is True, future calls to stat() return floats, if it is False,\nfuture calls return ints. \nIf newval is omitted, return the current setting.
stat_result os.stat_result()\nstat_result: Result from stat or lstat.\n\nThis object may be accessed either as a tuple of\n  (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\nor via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\nPosix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\nor st_flags, they are available as attributes only.\n\nSee os.stat for more information.
statvfs os.statvfs(path) -> statvfs result\n\nPerform a statvfs system call on the given path.
statvfs_result os.statvfs_result()\nstatvfs_result: Result from statvfs or fstatvfs.\n\nThis object may be accessed either as a tuple of\n  (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\nor via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\nSee os.statvfs for more information.
strerror os.strerror(code) -> string\n\nTranslate an error code to a message string.
symlink os.symlink(src, dst)\n\nCreate a symbolic link pointing to src named dst.
sysconf os.sysconf(name) -> integer\n\nReturn an integer-valued system configuration variable.
sysconf_names os.sysconf_names [dict]
system os.system(command) -> exit_status\n\nExecute the command (a string) in a subshell.
tcgetpgrp os.tcgetpgrp(fd) -> pgid\n\nReturn the process group associated with the terminal given by a fd.
tcsetpgrp os.tcsetpgrp(fd, pgid)\n\nSet the process group associated with the terminal given by a fd.
tempnam os.tempnam([dir[, prefix]]) -> string\n\nReturn a unique name for a temporary file.\nThe directory and a prefix may be specified as strings; they may be omitted\nor None if not needed.
times os.times() -> (utime, stime, cutime, cstime, elapsed_time)\n\nReturn a tuple of floating point numbers indicating process times.
tmpfile os.tmpfile() -> file object\n\nCreate a temporary file with no directory entries.
tmpnam os.tmpnam() -> string\n\nReturn a unique name for a temporary file.
ttyname os.ttyname(fd) -> string\n\nReturn the name of the terminal device connected to 'fd'.
umask os.umask(new_mask) -> old_mask\n\nSet the current numeric umask and return the previous umask.
uname os.uname() -> (sysname, nodename, release, version, machine)\n\nReturn a tuple identifying the current operating system.
unlink os.unlink(path)\n\nRemove a file (same as remove(path)).
unsetenv os.unsetenv(key)\n\nDelete an environment variable.
urandom os.urandom(n) -> str\n\n        Return a string of n random bytes suitable for cryptographic use.
utime os.utime(path, (atime, mtime))\nutime(path, None)\n\nSet the access and modified time of the file to the given values.  If the\nsecond form is used, set the access and modified times to the current time.
wait os.wait() -> (pid, status)\n\nWait for completion of a child process.
wait3 os.wait3(options) -> (pid, status, rusage)\n\nWait for completion of a child process.
wait4 os.wait4(pid, options) -> (pid, status, rusage)\n\nWait for completion of a given child process.
waitpid os.waitpid(pid, options) -> (pid, status)\n\nWait for completion of a given child process.
walk os.walk('python/Lib/email'):\n        print root, "consumes",\n        print sum([getsize(join(root, name)) for name in files]),\n        print "bytes in", len(files), "non-directory files"\n        if 'CVS' in dirs:\n            dirs.remove('CVS')  # don't visit CVS directories
write os.write(fd, string) -> byteswritten\n\nWrite a string to a file descriptor.
io io\nThe io module provides the Python interfaces to stream handling. The\nbuiltin open function is defined in this module.\n\nAt the top of the I/O hierarchy is the abstract base class IOBase. It\ndefines the basic interface to a stream. Note, however, that there is no\nseparation between reading and writing to streams; implementations are\nallowed to throw an IOError if they do not support a given operation.\n\nExtending IOBase is RawIOBase which deals simply with the reading and\nwriting of raw bytes to a stream. FileIO subclasses RawIOBase to provide\nan interface to OS files.\n\nBufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\nsubclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\nstreams that are readable, writable, and both respectively.\nBufferedRandom provides a buffered interface to random access\nstreams. BytesIO is a simple stream of in-memory bytes.\n\nAnother IOBase subclass, TextIOBase, deals with the encoding and decoding\nof streams into text. TextIOWrapper, which extends it, is a buffered text\ninterface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\nis a in-memory stream for text.\n\nArgument names are not part of the specification, and only the arguments\nof open() are intended to be used as keyword arguments.\n\ndata:\n\nDEFAULT_BUFFER_SIZE\n\n   An int containing the default buffer size used by the module's buffered\n   I/O classes. open() uses the file's blksize (as obtained by os.stat) if\n   possible.
BlockingIOError io.BlockingIOError()\nException raised when I/O would block on a non-blocking I/O stream
BufferedIOBase io.BufferedIOBase()\n
BufferedRWPair io.BufferedRWPair()\nA buffered reader and writer object together.\n\nA buffered reader object and buffered writer object put together to\nform a sequential IO object that can read and write. This is typically\nused with a socket or two-way pipe.\n\nreader and writer are RawIOBase objects that are readable and\nwriteable respectively. If the buffer_size is omitted it defaults to\nDEFAULT_BUFFER_SIZE.
BufferedRandom io.BufferedRandom()\nA buffered interface to random access streams.\n\nThe constructor creates a reader and writer for a seekable stream,\nraw, given in the first argument. If the buffer_size is omitted it\ndefaults to DEFAULT_BUFFER_SIZE. max_buffer_size isn't used anymore.
BufferedReader io.BufferedReader()\nCreate a new buffered reader using the given readable raw IO object.
BufferedWriter io.BufferedWriter()\nA buffer for a writeable sequential RawIO object.\n\nThe constructor creates a BufferedWriter for the given writeable raw\nstream. If the buffer_size is not given, it defaults to\nDEFAULT_BUFFER_SIZE. max_buffer_size isn't used anymore.
BytesIO io.BytesIO([buffer]) -> object\n\nCreate a buffered I/O implementation using an in-memory bytes\nbuffer, ready for reading and writing.
DEFAULT_BUFFER_SIZE io.DEFAULT_BUFFER_SIZE [int]
FileIO io.FileIO()\nfile(name: str[, mode: str]) -> file IO object\n\nOpen a file.  The mode can be 'r', 'w' or 'a' for reading (default),\nwriting or appending.  The file will be created if it doesn't exist\nwhen opened for writing or appending; it will be truncated when\nopened for writing.  Add a '+' to the mode to allow simultaneous\nreading and writing.
IOBase io.IOBase()\n
IncrementalNewlineDecoder io.IncrementalNewlineDecoder()\nCodec used when reading a file in universal newlines mode.  It wraps\nanother incremental decoder, translating \r\\n and \r into \\n.  It also\nrecords the types of newlines encountered.  When used with\ntranslate=False, it ensures that the newline sequence is returned in\none piece. When used with decoder=None, it expects unicode strings as\ndecode input and translates newlines without first invoking an external\ndecoder.
OpenWrapper io.OpenWrapper()\nOpen file and return a stream.  Raise IOError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn't in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to 'r' which means open for reading in text\nmode.  Other common values are 'w' for writing (truncating the file if\nit already exists), and 'a' for appending (which on some Unix systems,\nmeans that all writes append to the end of the file regardless of the\ncurrent seek position). In text mode, if encoding is not specified the\nencoding used is platform dependent. (For reading and writing raw\nbytes use binary mode and leave encoding unspecified.) The available\nmodes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n'r'       open for reading (default)\n'w'       open for writing, truncating the file first\n'a'       open for writing, appending to the end of the file if it exists\n'b'       binary mode\n't'       text mode (default)\n'+'       open a disk file for updating (reading and writing)\n'U'       universal newline mode (for backwards compatibility; unneeded\n          for new code)\n========= ===============================================================\n\nThe default mode is 'rt' (open for reading text). For binary random\naccess, the mode 'w+b' opens and truncates the file to 0 bytes, while\n'r+b' opens the file without truncation.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn't. Files opened in\nbinary mode (appending 'b' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n't' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer.  When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n  is chosen using a heuristic trying to determine the underlying device's\n  "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n  On many systems, the buffer will typically be 4096 or 8192 bytes long.\n\n* "Interactive" text files (files for which isatty() returns True)\n  use line buffering.  Other text files use the policy described above\n  for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed.  See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n'strict' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass 'ignore' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register for a list of the permitted\nencoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, '', '\\n', '\r', and '\r\\n'.  It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n  enabled. Lines in the input can end in '\\n', '\r', or '\r\\n', and\n  these are translated into '\\n' before being returned to the\n  caller. If it is '', universal newline mode is enabled, but line\n  endings are returned to the caller untranslated. If it has any of\n  the other legal values, input lines are only terminated by the given\n  string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n  translated to the system default line separator, os.linesep. If\n  newline is '', no translation takes place. If newline is any of the\n  other legal values, any '\\n' characters written are translated to\n  the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.
RawIOBase io.RawIOBase()\n
SEEK_CUR io.SEEK_CUR [int]
SEEK_END io.SEEK_END [int]
SEEK_SET io.SEEK_SET [int]
StringIO io.StringIO()\nText I/O implementation using an in-memory buffer.\n\nThe initial_value argument sets the value of object.  The newline\nargument is like the one of TextIOWrapper's constructor.
TextIOBase io.TextIOBase()\n
TextIOWrapper io.TextIOWrapper()\nCharacter and line based layer over a BufferedIOBase object, buffer.\n\nencoding gives the name of the encoding that the stream will be\ndecoded or encoded with. It defaults to locale.getpreferredencoding.\n\nerrors determines the strictness of encoding and decoding (see the\ncodecs.register) and defaults to "strict".\n\nnewline can be None, '', '\\n', '\r', or '\r\\n'.  It controls the\nhandling of line endings. If it is None, universal newlines is\nenabled.  With this enabled, on input, the lines endings '\\n', '\r',\nor '\r\\n' are translated to '\\n' before being returned to the\ncaller. Conversely, on output, '\\n' is translated to the system\ndefault line seperator, os.linesep. If newline is any other of its\nlegal values, that newline becomes the newline when the file is read\nand it is returned untranslated. On output, '\\n' is converted to the\nnewline.\n\nIf line_buffering is True, a call to flush is implied when a call to\nwrite contains a newline character.
UnsupportedOperation io.UnsupportedOperation()\n
__all__ io.__all__ [list]
__author__ io.__author__ [str]
__builtins__ io.__builtins__ [dict]
__doc__ io.__doc__ [str]
__file__ io.__file__ [str]
__name__ io.__name__ [str]
__package__ io.__package__ [NoneType]
open io.open() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.
time time\nThis module provides various functions to manipulate time values.\n\nThere are two standard representations of time.  One is the number\nof seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\nor a floating point number (to represent fractions of seconds).\nThe Epoch is system-defined; on Unix, it is generally January 1st, 1970.\nThe actual value can be retrieved by calling gmtime(0).\n\nThe other representation is a tuple of 9 integers giving local time.\nThe tuple items are:\n  year (four digits, e.g. 1998)\n  month (1-12)\n  day (1-31)\n  hours (0-23)\n  minutes (0-59)\n  seconds (0-59)\n  weekday (0-6, Monday is 0)\n  Julian day (day in the year, 1-366)\n  DST (Daylight Savings Time) flag (-1, 0 or 1)\nIf the DST flag is 0, the time is given in the regular time zone;\nif it is 1, the time is given in the DST time zone;\nif it is -1, mktime() should guess based on the date and time.\n\nVariables:\n\ntimezone -- difference in seconds between UTC and local standard time\naltzone -- difference in  seconds between UTC and local DST time\ndaylight -- whether local time should reflect DST\ntzname -- tuple of (standard time zone name, DST time zone name)\n\nFunctions:\n\ntime() -- return current time in seconds since the Epoch as a float\nclock() -- return CPU time since process start as a float\nsleep() -- delay for a number of seconds given as a float\ngmtime() -- convert seconds since Epoch to UTC tuple\nlocaltime() -- convert seconds since Epoch to local time tuple\nasctime() -- convert time tuple to string\nctime() -- convert time in seconds to string\nmktime() -- convert local time tuple to seconds since Epoch\nstrftime() -- convert time tuple to string according to format specification\nstrptime() -- parse string to time tuple according to format specification\ntzset() -- change the local timezone
__doc__ time.__doc__ [str]
__name__ time.__name__ [str]
__package__ time.__package__ [NoneType]
accept2dyear time.accept2dyear [int]
altzone time.altzone [int]
asctime time.asctime([tuple]) -> string\n\nConvert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\nWhen the time tuple is not present, current time as returned by localtime()\nis used.
clock time.clock() -> floating point number\n\nReturn the CPU time or real time since the start of the process or since\nthe first call to clock().  This has as much precision as the system\nrecords.
ctime time.ctime(seconds) -> string\n\nConvert a time in seconds since the Epoch to a string in local time.\nThis is equivalent to asctime(localtime(seconds)). When the time tuple is\nnot present, current time as returned by localtime() is used.
daylight time.daylight [int]
gmtime time.gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n                       tm_sec, tm_wday, tm_yday, tm_isdst)\n\nConvert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\nGMT).  When 'seconds' is not passed in, convert the current time instead.
localtime time.localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,\n                          tm_sec,tm_wday,tm_yday,tm_isdst)\n\nConvert seconds since the Epoch to a time tuple expressing local time.\nWhen 'seconds' is not passed in, convert the current time instead.
mktime time.mktime(tuple) -> floating point number\n\nConvert a time tuple in local time to seconds since the Epoch.
sleep time.sleep(seconds)\n\nDelay execution for a given number of seconds.  The argument may be\na floating point number for subsecond precision.
strftime time.strftime(format[, tuple]) -> string\n\nConvert a time tuple to a string according to a format specification.\nSee the library reference manual for formatting codes. When the time tuple\nis not present, current time as returned by localtime() is used.
strptime time.strptime(string, format) -> struct_time\n\nParse a string to a time tuple according to a format specification.\nSee the library reference manual for formatting codes (same as strftime()).
struct_time time.struct_time()\nThe time value as returned by gmtime(), localtime(), and strptime(), and\n accepted by asctime(), mktime() and strftime().  May be considered as a\n sequence of 9 integers.\n\n Note that several fields' values are not the same as those defined by\n the C language standard for struct tm.  For example, the value of the\n field tm_year is the actual year, not year - 1900.  See individual\n fields' descriptions for details.
time time.time() -> floating point number\n\nReturn the current time in seconds since the Epoch.\nFractions of a second may be present if the system clock provides them.
timezone time.timezone [int]
tzname time.tzname [tuple]
tzset time.tzset()\n\nInitialize, or reinitialize, the local timezone to the value stored in\nos.environ['TZ']. The TZ environment variable should be specified in\nstandard Unix timezone format as documented in the tzset man page\n(eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\nfall back to UTC. If the TZ environment variable is not set, the local\ntimezone is set to the systems best guess of wallclock time.\nChanging the TZ environment variable without calling tzset *may* change\nthe local timezone used by methods such as localtime, but this behaviour\nshould not be relied on.
argparse argparse\nCommand-line parsing library\n\nThis module is an optparse-inspired command-line parsing library that:\n\n    - handles both optional and positional arguments\n    - produces highly informative usage messages\n    - supports parsers that dispatch to sub-parsers\n\nThe following is a simple usage example that sums integers from the\ncommand-line and writes the result to a file::\n\n    parser = argparse.ArgumentParser(\n        description='sum the integers at the command line')\n    parser.add_argument(\n        'integers', metavar='int', nargs='+', type=int,\n        help='an integer to be summed')\n    parser.add_argument(\n        '--log', default=sys.stdout, type=argparse.FileType('w'),\n        help='the file where the sum should be written')\n    args = parser.parse_args()\n    args.log.write('%s' % sum(args.integers))\n    args.log.close()\n\nThe module contains the following public classes:\n\n    - ArgumentParser -- The main entry point for command-line parsing. As the\n        example above shows, the add_argument() method is used to populate\n        the parser with actions for optional and positional arguments. Then\n        the parse_args() method is invoked to convert the args at the\n        command-line into an object with attributes.\n\n    - ArgumentError -- The exception raised by ArgumentParser objects when\n        there are errors with the parser's actions. Errors raised while\n        parsing the command-line are caught by ArgumentParser and emitted\n        as command-line messages.\n\n    - FileType -- A factory for defining types of files to be created. As the\n        example above shows, instances of FileType are typically passed as\n        the type= argument of add_argument() calls.\n\n    - Action -- The base class for parser actions. Typically actions are\n        selected by passing strings like 'store_true' or 'append_const' to\n        the action= argument of add_argument(). However, for greater\n        customization of ArgumentParser actions, subclasses of Action may\n        be defined and passed as the action= argument.\n\n    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,\n        ArgumentDefaultsHelpFormatter -- Formatter classes which\n        may be passed as the formatter_class= argument to the\n        ArgumentParser constructor. HelpFormatter is the default,\n        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser\n        not to change the formatting for help text, and\n        ArgumentDefaultsHelpFormatter adds information about argument defaults\n        to the help.\n\nAll other classes in this module are considered implementation details.\n(Also note that HelpFormatter and RawDescriptionHelpFormatter are only\nconsidered public as object names -- the API of the formatter objects is\nstill considered an implementation detail.)
Action argparse.Action()\nInformation about how to convert command line strings to Python objects.\n\n    Action objects are used by an ArgumentParser to represent the information\n    needed to parse a single argument from one or more strings from the\n    command line. The keyword arguments to the Action constructor are also\n    all attributes of Action instances.\n\n    Keyword Arguments:\n\n        - option_strings -- A list of command-line option strings which\n            should be associated with this action.\n\n        - dest -- The name of the attribute to hold the created object(s)\n\n        - nargs -- The number of command-line arguments that should be\n            consumed. By default, one argument will be consumed and a single\n            value will be produced.  Other values include:\n                - N (an integer) consumes N arguments (and produces a list)\n                - '?' consumes zero or one arguments\n                - '*' consumes zero or more arguments (and produces a list)\n                - '+' consumes one or more arguments (and produces a list)\n            Note that the difference between the default and nargs=1 is that\n            with the default, a single value will be produced, while with\n            nargs=1, a list containing a single value will be produced.\n\n        - const -- The value to be produced if the option is specified and the\n            option uses an action that takes no values.\n\n        - default -- The value to be produced if the option is not specified.\n\n        - type -- The type which the command-line arguments should be converted\n            to, should be one of 'string', 'int', 'float', 'complex' or a\n            callable object that accepts a single string argument. If None,\n            'string' is assumed.\n\n        - choices -- A container of values that should be allowed. If not None,\n            after a command-line argument has been converted to the appropriate\n            type, an exception will be raised if it is not a member of this\n            collection.\n\n        - required -- True if the action must always be specified at the\n            command line. This is only meaningful for optional command-line\n            arguments.\n\n        - help -- The help string describing the argument.\n\n        - metavar -- The name to be used for the option's argument with the\n            help string. If None, the 'dest' value will be used as the name.
ArgumentDefaultsHelpFormatter argparse.ArgumentDefaultsHelpFormatter()\nHelp message formatter which adds default values to argument help.\n\n    Only the name of this class is considered a public API. All the methods\n    provided by the class are considered an implementation detail.
ArgumentError argparse.ArgumentError()\nAn error from creating or using an argument (optional or positional).\n\n    The string value of this exception is the message, augmented with\n    information about the argument that caused it.
ArgumentParser argparse.ArgumentParser()\nObject for parsing command line strings into Python objects.\n\n    Keyword Arguments:\n        - prog -- The name of the program (default: sys.argv[0])\n        - usage -- A usage message (default: auto-generated from arguments)\n        - description -- A description of what the program does\n        - epilog -- Text following the argument descriptions\n        - parents -- Parsers whose arguments should be copied into this one\n        - formatter_class -- HelpFormatter class for printing help messages\n        - prefix_chars -- Characters that prefix optional arguments\n        - fromfile_prefix_chars -- Characters that prefix files containing\n            additional arguments\n        - argument_default -- The default value for all arguments\n        - conflict_handler -- String indicating how to handle conflicts\n        - add_help -- Add a -h/-help option
ArgumentTypeError argparse.ArgumentTypeError()\nAn error from trying to convert a command line string to a type.
FileType argparse.FileType()\nFactory for creating file object types\n\n    Instances of FileType are typically passed as type= arguments to the\n    ArgumentParser add_argument() method.\n\n    Keyword Arguments:\n        - mode -- A string indicating how the file is to be opened. Accepts the\n            same values as the builtin open() function.\n        - bufsize -- The file's desired buffer size. Accepts the same values as\n            the builtin open() function.
HelpFormatter argparse.HelpFormatter()\nFormatter for generating usage messages and argument help strings.\n\n    Only the name of this class is considered a public API. All the methods\n    provided by the class are considered an implementation detail.
Namespace argparse.Namespace()\nSimple object for storing attributes.\n\n    Implements equality by attribute names and values, and provides a simple\n    string representation.
ONE_OR_MORE argparse.ONE_OR_MORE [str]
OPTIONAL argparse.OPTIONAL [str]
PARSER argparse.PARSER [str]
REMAINDER argparse.REMAINDER [str]
RawDescriptionHelpFormatter argparse.RawDescriptionHelpFormatter()\nHelp message formatter which retains any formatting in descriptions.\n\n    Only the name of this class is considered a public API. All the methods\n    provided by the class are considered an implementation detail.
RawTextHelpFormatter argparse.RawTextHelpFormatter()\nHelp message formatter which retains formatting of all help text.\n\n    Only the name of this class is considered a public API. All the methods\n    provided by the class are considered an implementation detail.
SUPPRESS argparse.SUPPRESS [str]
ZERO_OR_MORE argparse.ZERO_OR_MORE [str]
__all__ argparse.__all__ [list]
__builtins__ argparse.__builtins__ [dict]
__doc__ argparse.__doc__ [str]
__file__ argparse.__file__ [str]
__name__ argparse.__name__ [str]
__package__ argparse.__package__ [NoneType]
__version__ argparse.__version__ [str]
socket socket\nThis module provides socket operations and some related functions.\nOn Unix, it supports IP (Internet Protocol) and Unix domain sockets.\nOn other systems, it only supports IP. Functions specific for a\nsocket are available as methods of the socket object.\n\nFunctions:\n\nsocket() -- create a new socket object\nsocketpair() -- create a pair of new socket objects [*]\nfromfd() -- create a socket object from an open file descriptor [*]\ngethostname() -- return the current hostname\ngethostbyname() -- map a hostname to its IP number\ngethostbyaddr() -- map an IP number or hostname to DNS info\ngetservbyname() -- map a service name and a protocol name to a port number\ngetprotobyname() -- map a protocol name (e.g. 'tcp') to a number\nntohs(), ntohl() -- convert 16, 32 bit int from network to host byte order\nhtons(), htonl() -- convert 16, 32 bit int from host to network byte order\ninet_aton() -- convert IP addr string (123.45.67.89) to 32-bit packed format\ninet_ntoa() -- convert 32-bit packed format IP to string (123.45.67.89)\nssl() -- secure socket layer support (only available if configured)\nsocket.getdefaulttimeout() -- get the default timeout value\nsocket.setdefaulttimeout() -- set the default timeout value\ncreate_connection() -- connects to an address, with an optional timeout and\n                       optional source address.\n\n [*] not available on all platforms!\n\nSpecial objects:\n\nSocketType -- type object for socket objects\nerror -- exception raised for I/O errors\nhas_ipv6 -- boolean value indicating if IPv6 is supported\n\nInteger constants:\n\nAF_INET, AF_UNIX -- socket domains (first argument to socket() call)\nSOCK_STREAM, SOCK_DGRAM, SOCK_RAW -- socket types (second argument)\n\nMany other constants may be defined; these may be used in calls to\nthe setsockopt() and getsockopt() methods.
AF_APPLETALK socket.AF_APPLETALK [int]
AF_ASH socket.AF_ASH [int]
AF_ATMPVC socket.AF_ATMPVC [int]
AF_ATMSVC socket.AF_ATMSVC [int]
AF_AX25 socket.AF_AX25 [int]
AF_BLUETOOTH socket.AF_BLUETOOTH [int]
AF_BRIDGE socket.AF_BRIDGE [int]
AF_DECnet socket.AF_DECnet [int]
AF_ECONET socket.AF_ECONET [int]
AF_INET socket.AF_INET [int]
AF_INET6 socket.AF_INET6 [int]
AF_IPX socket.AF_IPX [int]
AF_IRDA socket.AF_IRDA [int]
AF_KEY socket.AF_KEY [int]
AF_LLC socket.AF_LLC [int]
AF_NETBEUI socket.AF_NETBEUI [int]
AF_NETLINK socket.AF_NETLINK [int]
AF_NETROM socket.AF_NETROM [int]
AF_PACKET socket.AF_PACKET [int]
AF_PPPOX socket.AF_PPPOX [int]
AF_ROSE socket.AF_ROSE [int]
AF_ROUTE socket.AF_ROUTE [int]
AF_SECURITY socket.AF_SECURITY [int]
AF_SNA socket.AF_SNA [int]
AF_TIPC socket.AF_TIPC [int]
AF_UNIX socket.AF_UNIX [int]
AF_UNSPEC socket.AF_UNSPEC [int]
AF_WANPIPE socket.AF_WANPIPE [int]
AF_X25 socket.AF_X25 [int]
AI_ADDRCONFIG socket.AI_ADDRCONFIG [int]
AI_ALL socket.AI_ALL [int]
AI_CANONNAME socket.AI_CANONNAME [int]
AI_NUMERICHOST socket.AI_NUMERICHOST [int]
AI_NUMERICSERV socket.AI_NUMERICSERV [int]
AI_PASSIVE socket.AI_PASSIVE [int]
AI_V4MAPPED socket.AI_V4MAPPED [int]
BDADDR_ANY socket.BDADDR_ANY [str]
BDADDR_LOCAL socket.BDADDR_LOCAL [str]
BTPROTO_HCI socket.BTPROTO_HCI [int]
BTPROTO_L2CAP socket.BTPROTO_L2CAP [int]
BTPROTO_RFCOMM socket.BTPROTO_RFCOMM [int]
BTPROTO_SCO socket.BTPROTO_SCO [int]
CAPI socket.CAPI [PyCapsule]
EAI_ADDRFAMILY socket.EAI_ADDRFAMILY [int]
EAI_AGAIN socket.EAI_AGAIN [int]
EAI_BADFLAGS socket.EAI_BADFLAGS [int]
EAI_FAIL socket.EAI_FAIL [int]
EAI_FAMILY socket.EAI_FAMILY [int]
EAI_MEMORY socket.EAI_MEMORY [int]
EAI_NODATA socket.EAI_NODATA [int]
EAI_NONAME socket.EAI_NONAME [int]
EAI_OVERFLOW socket.EAI_OVERFLOW [int]
EAI_SERVICE socket.EAI_SERVICE [int]
EAI_SOCKTYPE socket.EAI_SOCKTYPE [int]
EAI_SYSTEM socket.EAI_SYSTEM [int]
EBADF socket.EBADF [int]
EINTR socket.EINTR [int]
HCI_DATA_DIR socket.HCI_DATA_DIR [int]
HCI_FILTER socket.HCI_FILTER [int]
HCI_TIME_STAMP socket.HCI_TIME_STAMP [int]
INADDR_ALLHOSTS_GROUP socket.INADDR_ALLHOSTS_GROUP [int]
INADDR_ANY socket.INADDR_ANY [int]
INADDR_BROADCAST socket.INADDR_BROADCAST [int]
INADDR_LOOPBACK socket.INADDR_LOOPBACK [int]
INADDR_MAX_LOCAL_GROUP socket.INADDR_MAX_LOCAL_GROUP [int]
INADDR_NONE socket.INADDR_NONE [int]
INADDR_UNSPEC_GROUP socket.INADDR_UNSPEC_GROUP [int]
IPPORT_RESERVED socket.IPPORT_RESERVED [int]
IPPORT_USERRESERVED socket.IPPORT_USERRESERVED [int]
IPPROTO_AH socket.IPPROTO_AH [int]
IPPROTO_DSTOPTS socket.IPPROTO_DSTOPTS [int]
IPPROTO_EGP socket.IPPROTO_EGP [int]
IPPROTO_ESP socket.IPPROTO_ESP [int]
IPPROTO_FRAGMENT socket.IPPROTO_FRAGMENT [int]
IPPROTO_GRE socket.IPPROTO_GRE [int]
IPPROTO_HOPOPTS socket.IPPROTO_HOPOPTS [int]
IPPROTO_ICMP socket.IPPROTO_ICMP [int]
IPPROTO_ICMPV6 socket.IPPROTO_ICMPV6 [int]
IPPROTO_IDP socket.IPPROTO_IDP [int]
IPPROTO_IGMP socket.IPPROTO_IGMP [int]
IPPROTO_IP socket.IPPROTO_IP [int]
IPPROTO_IPIP socket.IPPROTO_IPIP [int]
IPPROTO_IPV6 socket.IPPROTO_IPV6 [int]
IPPROTO_NONE socket.IPPROTO_NONE [int]
IPPROTO_PIM socket.IPPROTO_PIM [int]
IPPROTO_PUP socket.IPPROTO_PUP [int]
IPPROTO_RAW socket.IPPROTO_RAW [int]
IPPROTO_ROUTING socket.IPPROTO_ROUTING [int]
IPPROTO_RSVP socket.IPPROTO_RSVP [int]
IPPROTO_TCP socket.IPPROTO_TCP [int]
IPPROTO_TP socket.IPPROTO_TP [int]
IPPROTO_UDP socket.IPPROTO_UDP [int]
IPV6_CHECKSUM socket.IPV6_CHECKSUM [int]
IPV6_DSTOPTS socket.IPV6_DSTOPTS [int]
IPV6_HOPLIMIT socket.IPV6_HOPLIMIT [int]
IPV6_HOPOPTS socket.IPV6_HOPOPTS [int]
IPV6_JOIN_GROUP socket.IPV6_JOIN_GROUP [int]
IPV6_LEAVE_GROUP socket.IPV6_LEAVE_GROUP [int]
IPV6_MULTICAST_HOPS socket.IPV6_MULTICAST_HOPS [int]
IPV6_MULTICAST_IF socket.IPV6_MULTICAST_IF [int]
IPV6_MULTICAST_LOOP socket.IPV6_MULTICAST_LOOP [int]
IPV6_NEXTHOP socket.IPV6_NEXTHOP [int]
IPV6_PKTINFO socket.IPV6_PKTINFO [int]
IPV6_RECVDSTOPTS socket.IPV6_RECVDSTOPTS [int]
IPV6_RECVHOPLIMIT socket.IPV6_RECVHOPLIMIT [int]
IPV6_RECVHOPOPTS socket.IPV6_RECVHOPOPTS [int]
IPV6_RECVPKTINFO socket.IPV6_RECVPKTINFO [int]
IPV6_RECVRTHDR socket.IPV6_RECVRTHDR [int]
IPV6_RECVTCLASS socket.IPV6_RECVTCLASS [int]
IPV6_RTHDR socket.IPV6_RTHDR [int]
IPV6_RTHDRDSTOPTS socket.IPV6_RTHDRDSTOPTS [int]
IPV6_RTHDR_TYPE_0 socket.IPV6_RTHDR_TYPE_0 [int]
IPV6_TCLASS socket.IPV6_TCLASS [int]
IPV6_UNICAST_HOPS socket.IPV6_UNICAST_HOPS [int]
IPV6_V6ONLY socket.IPV6_V6ONLY [int]
IP_ADD_MEMBERSHIP socket.IP_ADD_MEMBERSHIP [int]
IP_DEFAULT_MULTICAST_LOOP socket.IP_DEFAULT_MULTICAST_LOOP [int]
IP_DEFAULT_MULTICAST_TTL socket.IP_DEFAULT_MULTICAST_TTL [int]
IP_DROP_MEMBERSHIP socket.IP_DROP_MEMBERSHIP [int]
IP_HDRINCL socket.IP_HDRINCL [int]
IP_MAX_MEMBERSHIPS socket.IP_MAX_MEMBERSHIPS [int]
IP_MULTICAST_IF socket.IP_MULTICAST_IF [int]
IP_MULTICAST_LOOP socket.IP_MULTICAST_LOOP [int]
IP_MULTICAST_TTL socket.IP_MULTICAST_TTL [int]
IP_OPTIONS socket.IP_OPTIONS [int]
IP_RECVOPTS socket.IP_RECVOPTS [int]
IP_RECVRETOPTS socket.IP_RECVRETOPTS [int]
IP_RETOPTS socket.IP_RETOPTS [int]
IP_TOS socket.IP_TOS [int]
IP_TTL socket.IP_TTL [int]
MSG_CTRUNC socket.MSG_CTRUNC [int]
MSG_DONTROUTE socket.MSG_DONTROUTE [int]
MSG_DONTWAIT socket.MSG_DONTWAIT [int]
MSG_EOR socket.MSG_EOR [int]
MSG_OOB socket.MSG_OOB [int]
MSG_PEEK socket.MSG_PEEK [int]
MSG_TRUNC socket.MSG_TRUNC [int]
MSG_WAITALL socket.MSG_WAITALL [int]
MethodType socket.MethodType()\ninstancemethod(function, instance, class)\n\nCreate an instance method object.
NETLINK_DNRTMSG socket.NETLINK_DNRTMSG [int]
NETLINK_FIREWALL socket.NETLINK_FIREWALL [int]
NETLINK_IP6_FW socket.NETLINK_IP6_FW [int]
NETLINK_NFLOG socket.NETLINK_NFLOG [int]
NETLINK_ROUTE socket.NETLINK_ROUTE [int]
NETLINK_USERSOCK socket.NETLINK_USERSOCK [int]
NETLINK_XFRM socket.NETLINK_XFRM [int]
NI_DGRAM socket.NI_DGRAM [int]
NI_MAXHOST socket.NI_MAXHOST [int]
NI_MAXSERV socket.NI_MAXSERV [int]
NI_NAMEREQD socket.NI_NAMEREQD [int]
NI_NOFQDN socket.NI_NOFQDN [int]
NI_NUMERICHOST socket.NI_NUMERICHOST [int]
NI_NUMERICSERV socket.NI_NUMERICSERV [int]
PACKET_BROADCAST socket.PACKET_BROADCAST [int]
PACKET_FASTROUTE socket.PACKET_FASTROUTE [int]
PACKET_HOST socket.PACKET_HOST [int]
PACKET_LOOPBACK socket.PACKET_LOOPBACK [int]
PACKET_MULTICAST socket.PACKET_MULTICAST [int]
PACKET_OTHERHOST socket.PACKET_OTHERHOST [int]
PACKET_OUTGOING socket.PACKET_OUTGOING [int]
PF_PACKET socket.PF_PACKET [int]
RAND_add socket.RAND_add(string, entropy)\n\nMix string into the OpenSSL PRNG state.  entropy (a float) is a lower\nbound on the entropy contained in string.  See RFC 1750.
RAND_egd socket.RAND_egd(path) -> bytes\n\nQueries the entropy gather daemon (EGD) on the socket named by 'path'.\nReturns number of bytes read.  Raises SSLError if connection to EGD\nfails or if it does provide enough data to seed PRNG.
RAND_status socket.RAND_status() -> 0 or 1\n\nReturns 1 if the OpenSSL PRNG has been seeded with enough data and 0 if not.\nIt is necessary to seed the PRNG with RAND_add() on some platforms before\nusing the ssl() function.
SHUT_RD socket.SHUT_RD [int]
SHUT_RDWR socket.SHUT_RDWR [int]
SHUT_WR socket.SHUT_WR [int]
SOCK_DGRAM socket.SOCK_DGRAM [int]
SOCK_RAW socket.SOCK_RAW [int]
SOCK_RDM socket.SOCK_RDM [int]
SOCK_SEQPACKET socket.SOCK_SEQPACKET [int]
SOCK_STREAM socket.SOCK_STREAM [int]
SOL_HCI socket.SOL_HCI [int]
SOL_IP socket.SOL_IP [int]
SOL_SOCKET socket.SOL_SOCKET [int]
SOL_TCP socket.SOL_TCP [int]
SOL_TIPC socket.SOL_TIPC [int]
SOL_UDP socket.SOL_UDP [int]
SOMAXCONN socket.SOMAXCONN [int]
SO_ACCEPTCONN socket.SO_ACCEPTCONN [int]
SO_BROADCAST socket.SO_BROADCAST [int]
SO_DEBUG socket.SO_DEBUG [int]
SO_DONTROUTE socket.SO_DONTROUTE [int]
SO_ERROR socket.SO_ERROR [int]
SO_KEEPALIVE socket.SO_KEEPALIVE [int]
SO_LINGER socket.SO_LINGER [int]
SO_OOBINLINE socket.SO_OOBINLINE [int]
SO_RCVBUF socket.SO_RCVBUF [int]
SO_RCVLOWAT socket.SO_RCVLOWAT [int]
SO_RCVTIMEO socket.SO_RCVTIMEO [int]
SO_REUSEADDR socket.SO_REUSEADDR [int]
SO_SNDBUF socket.SO_SNDBUF [int]
SO_SNDLOWAT socket.SO_SNDLOWAT [int]
SO_SNDTIMEO socket.SO_SNDTIMEO [int]
SO_TYPE socket.SO_TYPE [int]
SSL_ERROR_EOF socket.SSL_ERROR_EOF [int]
SSL_ERROR_INVALID_ERROR_CODE socket.SSL_ERROR_INVALID_ERROR_CODE [int]
SSL_ERROR_SSL socket.SSL_ERROR_SSL [int]
SSL_ERROR_SYSCALL socket.SSL_ERROR_SYSCALL [int]
SSL_ERROR_WANT_CONNECT socket.SSL_ERROR_WANT_CONNECT [int]
SSL_ERROR_WANT_READ socket.SSL_ERROR_WANT_READ [int]
SSL_ERROR_WANT_WRITE socket.SSL_ERROR_WANT_WRITE [int]
SSL_ERROR_WANT_X509_LOOKUP socket.SSL_ERROR_WANT_X509_LOOKUP [int]
SSL_ERROR_ZERO_RETURN socket.SSL_ERROR_ZERO_RETURN [int]
SocketType socket.SocketType()\nsocket([family[, type[, proto]]]) -> socket object\n\nOpen a socket of the given type.  The family argument specifies the\naddress family; it defaults to AF_INET.  The type argument specifies\nwhether this is a stream (SOCK_STREAM, this is the default)\nor datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\nspecifying the default protocol.  Keyword arguments are accepted.\n\nA socket object represents one endpoint of a network connection.\n\nMethods of socket objects (keyword arguments not allowed):\n\naccept() -- accept a connection, returning new socket and client address\nbind(addr) -- bind the socket to a local address\nclose() -- close the socket\nconnect(addr) -- connect the socket to a remote address\nconnect_ex(addr) -- connect, return an error code instead of an exception\ndup() -- return a new socket object identical to the current one [*]\nfileno() -- return underlying file descriptor\ngetpeername() -- return remote address [*]\ngetsockname() -- return local address\ngetsockopt(level, optname[, buflen]) -- get socket options\ngettimeout() -- return timeout or None\nlisten(n) -- start listening for incoming connections\nmakefile([mode, [bufsize]]) -- return a file object for the socket [*]\nrecv(buflen[, flags]) -- receive data\nrecv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\nrecvfrom(buflen[, flags]) -- receive data and sender's address\nrecvfrom_into(buffer[, nbytes, [, flags])\n  -- receive data and sender's address (into a buffer)\nsendall(data[, flags]) -- send all data\nsend(data[, flags]) -- send data, may not send all of it\nsendto(data[, flags], addr) -- send data to a given address\nsetblocking(0 | 1) -- set or clear the blocking I/O flag\nsetsockopt(level, optname, value) -- set socket options\nsettimeout(None | float) -- set or clear the timeout\nshutdown(how) -- shut down traffic in one or both directions\n\n [*] not available on all platforms!
StringIO socket.StringIO([s]) -- Return a StringIO-like stream for reading or writing
TCP_CORK socket.TCP_CORK [int]
TCP_DEFER_ACCEPT socket.TCP_DEFER_ACCEPT [int]
TCP_INFO socket.TCP_INFO [int]
TCP_KEEPCNT socket.TCP_KEEPCNT [int]
TCP_KEEPIDLE socket.TCP_KEEPIDLE [int]
TCP_KEEPINTVL socket.TCP_KEEPINTVL [int]
TCP_LINGER2 socket.TCP_LINGER2 [int]
TCP_MAXSEG socket.TCP_MAXSEG [int]
TCP_NODELAY socket.TCP_NODELAY [int]
TCP_QUICKACK socket.TCP_QUICKACK [int]
TCP_SYNCNT socket.TCP_SYNCNT [int]
TCP_WINDOW_CLAMP socket.TCP_WINDOW_CLAMP [int]
TIPC_ADDR_ID socket.TIPC_ADDR_ID [int]
TIPC_ADDR_NAME socket.TIPC_ADDR_NAME [int]
TIPC_ADDR_NAMESEQ socket.TIPC_ADDR_NAMESEQ [int]
TIPC_CFG_SRV socket.TIPC_CFG_SRV [int]
TIPC_CLUSTER_SCOPE socket.TIPC_CLUSTER_SCOPE [int]
TIPC_CONN_TIMEOUT socket.TIPC_CONN_TIMEOUT [int]
TIPC_CRITICAL_IMPORTANCE socket.TIPC_CRITICAL_IMPORTANCE [int]
TIPC_DEST_DROPPABLE socket.TIPC_DEST_DROPPABLE [int]
TIPC_HIGH_IMPORTANCE socket.TIPC_HIGH_IMPORTANCE [int]
TIPC_IMPORTANCE socket.TIPC_IMPORTANCE [int]
TIPC_LOW_IMPORTANCE socket.TIPC_LOW_IMPORTANCE [int]
TIPC_MEDIUM_IMPORTANCE socket.TIPC_MEDIUM_IMPORTANCE [int]
TIPC_NODE_SCOPE socket.TIPC_NODE_SCOPE [int]
TIPC_PUBLISHED socket.TIPC_PUBLISHED [int]
TIPC_SRC_DROPPABLE socket.TIPC_SRC_DROPPABLE [int]
TIPC_SUBSCR_TIMEOUT socket.TIPC_SUBSCR_TIMEOUT [int]
TIPC_SUB_CANCEL socket.TIPC_SUB_CANCEL [int]
TIPC_SUB_PORTS socket.TIPC_SUB_PORTS [int]
TIPC_SUB_SERVICE socket.TIPC_SUB_SERVICE [int]
TIPC_TOP_SRV socket.TIPC_TOP_SRV [int]
TIPC_WAIT_FOREVER socket.TIPC_WAIT_FOREVER [int]
TIPC_WITHDRAWN socket.TIPC_WITHDRAWN [int]
TIPC_ZONE_SCOPE socket.TIPC_ZONE_SCOPE [int]
__all__ socket.__all__ [list]
__builtins__ socket.__builtins__ [dict]
__doc__ socket.__doc__ [str]
__file__ socket.__file__ [str]
__name__ socket.__name__ [str]
__package__ socket.__package__ [NoneType]
create_connection socket.create_connection()\nConnect to *address* and return the socket object.\n\n    Convenience function.  Connect to *address* (a 2-tuple ``(host,\n    port)``) and return the socket object.  Passing the optional\n    *timeout* parameter will set the timeout on the socket instance\n    before attempting to connect.  If no *timeout* is supplied, the\n    global default timeout setting returned by :func:`getdefaulttimeout`\n    is used.  If *source_address* is set it must be a tuple of (host, port)\n    for the socket to bind as a source address before making the connection.\n    An host of '' or port 0 tells the OS to use the default.
error socket.error()\n
fromfd socket.fromfd(fd, family, type[, proto]) -> socket object\n\nCreate a socket object from a duplicate of the given\nfile descriptor.\nThe remaining arguments are the same as for socket().
gaierror socket.gaierror()\n
getaddrinfo socket.getaddrinfo(host, port [, family, socktype, proto, flags])\n    -> list of (family, socktype, proto, canonname, sockaddr)\n\nResolve host and port into addrinfo struct.
getdefaulttimeout socket.getdefaulttimeout() -> timeout\n\nReturns the default timeout in seconds (float) for new socket objects.\nA value of None indicates that new socket objects have no timeout.\nWhen the socket module is first imported, the default is None.
getfqdn socket.getfqdn()\nGet fully qualified domain name from name.\n\n    An empty argument is interpreted as meaning the local host.\n\n    First the hostname returned by gethostbyaddr() is checked, then\n    possibly existing aliases. In case no FQDN is available, hostname\n    from gethostname() is returned.
gethostbyaddr socket.gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\nReturn the true host name, a list of aliases, and a list of IP addresses,\nfor a host.  The host argument is a string giving a host name or IP number.
gethostbyname socket.gethostbyname(host) -> address\n\nReturn the IP address (a string of the form '255.255.255.255') for a host.
gethostbyname_ex socket.gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\nReturn the true host name, a list of aliases, and a list of IP addresses,\nfor a host.  The host argument is a string giving a host name or IP number.
gethostname socket.gethostname() -> string\n\nReturn the current host name.
getnameinfo socket.getnameinfo(sockaddr, flags) --> (host, port)\n\nGet host and port for a sockaddr.
getprotobyname socket.getprotobyname(name) -> integer\n\nReturn the protocol number for the named protocol.  (Rarely used.)
getservbyname socket.getservbyname(servicename[, protocolname]) -> integer\n\nReturn a port number from a service name and protocol name.\nThe optional protocol name, if given, should be 'tcp' or 'udp',\notherwise any protocol will match.
getservbyport socket.getservbyport(port[, protocolname]) -> string\n\nReturn the service name from a port number and protocol name.\nThe optional protocol name, if given, should be 'tcp' or 'udp',\notherwise any protocol will match.
has_ipv6 socket.has_ipv6 [bool]
herror socket.herror()\n
htonl socket.htonl(integer) -> integer\n\nConvert a 32-bit integer from host to network byte order.
htons socket.htons(integer) -> integer\n\nConvert a 16-bit integer from host to network byte order.
inet_aton socket.inet_aton(string) -> packed 32-bit IP representation\n\nConvert an IP address in string format (123.45.67.89) to the 32-bit packed\nbinary format used in low-level network functions.
inet_ntoa socket.inet_ntoa(packed_ip) -> ip_address_string\n\nConvert an IP address from 32-bit packed binary format to string format
inet_ntop socket.inet_ntop(af, packed_ip) -> string formatted IP address\n\nConvert a packed IP address of the given family to string format.
inet_pton socket.inet_pton(af, ip) -> packed IP address string\n\nConvert an IP address from string format to a packed string suitable\nfor use with low-level network functions.
m socket.m()\nshutdown(flag)\n\nShut down the reading side of the socket (flag == SHUT_RD), the writing side\nof the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).
meth socket.meth()\n
ntohl socket.ntohl(integer) -> integer\n\nConvert a 32-bit integer from network to host byte order.
ntohs socket.ntohs(integer) -> integer\n\nConvert a 16-bit integer from network to host byte order.
p socket.p()\nshutdown(flag)\n\nShut down the reading side of the socket (flag == SHUT_RD), the writing side\nof the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).
partial socket.partial(func, *args, **keywords) - new function with partial application\n    of the given arguments and keywords.
setdefaulttimeout socket.setdefaulttimeout(timeout)\n\nSet the default timeout in seconds (float) for new socket objects.\nA value of None indicates that new socket objects have no timeout.\nWhen the socket module is first imported, the default is None.
socket socket.socket([family[, type[, proto]]]) -> socket object\n\nOpen a socket of the given type.  The family argument specifies the\naddress family; it defaults to AF_INET.  The type argument specifies\nwhether this is a stream (SOCK_STREAM, this is the default)\nor datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\nspecifying the default protocol.  Keyword arguments are accepted.\n\nA socket object represents one endpoint of a network connection.\n\nMethods of socket objects (keyword arguments not allowed):\n\naccept() -- accept a connection, returning new socket and client address\nbind(addr) -- bind the socket to a local address\nclose() -- close the socket\nconnect(addr) -- connect the socket to a remote address\nconnect_ex(addr) -- connect, return an error code instead of an exception\ndup() -- return a new socket object identical to the current one [*]\nfileno() -- return underlying file descriptor\ngetpeername() -- return remote address [*]\ngetsockname() -- return local address\ngetsockopt(level, optname[, buflen]) -- get socket options\ngettimeout() -- return timeout or None\nlisten(n) -- start listening for incoming connections\nmakefile([mode, [bufsize]]) -- return a file object for the socket [*]\nrecv(buflen[, flags]) -- receive data\nrecv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\nrecvfrom(buflen[, flags]) -- receive data and sender's address\nrecvfrom_into(buffer[, nbytes, [, flags])\n  -- receive data and sender's address (into a buffer)\nsendall(data[, flags]) -- send all data\nsend(data[, flags]) -- send data, may not send all of it\nsendto(data[, flags], addr) -- send data to a given address\nsetblocking(0 | 1) -- set or clear the blocking I/O flag\nsetsockopt(level, optname, value) -- set socket options\nsettimeout(None | float) -- set or clear the timeout\nshutdown(how) -- shut down traffic in one or both directions\n\n [*] not available on all platforms!
socketpair socket.socketpair([family[, type[, proto]]]) -> (socket object, socket object)\n\nCreate a pair of socket objects from the sockets returned by the platform\nsocketpair() function.\nThe arguments are the same as for socket() except the default family is\nAF_UNIX if defined on the platform; otherwise, the default is AF_INET.
ssl socket.ssl()\n
sslerror socket.sslerror()\n
timeout socket.timeout()\n
sys sys\nThis module provides access to some objects used or maintained by the\ninterpreter and to functions that interact strongly with the interpreter.\n\nDynamic objects:\n\nargv -- command line arguments; argv[0] is the script pathname if known\npath -- module search path; path[0] is the script directory, else ''\nmodules -- dictionary of loaded modules\n\ndisplayhook -- called to show results in an interactive session\nexcepthook -- called to handle any uncaught exception other than SystemExit\n  To customize printing in an interactive session or to install a custom\n  top-level exception handler, assign other functions to replace these.\n\nexitfunc -- if sys.exitfunc exists, this routine is called when Python exits\n  Assigning to sys.exitfunc is deprecated; use the atexit module instead.\n\nstdin -- standard input file object; used by raw_input() and input()\nstdout -- standard output file object; used by the print statement\nstderr -- standard error object; used for error messages\n  By assigning other file objects (or objects that behave like files)\n  to these, it is possible to redirect all of the interpreter's I/O.\n\nlast_type -- type of last uncaught exception\nlast_value -- value of last uncaught exception\nlast_traceback -- traceback of last uncaught exception\n  These three are only available in an interactive session after a\n  traceback has been printed.\n\nexc_type -- type of exception currently being handled\nexc_value -- value of exception currently being handled\nexc_traceback -- traceback of exception currently being handled\n  The function exc_info() should be used instead of these three,\n  because it is thread-safe.\n\nStatic objects:\n\nfloat_info -- a dict with information about the float inplementation.\nlong_info -- a struct sequence with information about the long implementation.\nmaxint -- the largest supported integer (the smallest is -maxint-1)\nmaxsize -- the largest supported length of containers.\nmaxunicode -- the largest supported character\nbuiltin_module_names -- tuple of module names built into this interpreter\nversion -- the version of this interpreter as a string\nversion_info -- version information as a named tuple\nhexversion -- version information encoded as a single integer\ncopyright -- copyright notice pertaining to this interpreter\nplatform -- platform identifier\nexecutable -- pathname of this Python interpreter\nprefix -- prefix used to find the Python library\nexec_prefix -- prefix used to find the machine-specific Python library\nfloat_repr_style -- string indicating the style of repr() output for floats\n__stdin__ -- the original stdin; don't touch!\n__stdout__ -- the original stdout; don't touch!\n__stderr__ -- the original stderr; don't touch!\n__displayhook__ -- the original displayhook; don't touch!\n__excepthook__ -- the original excepthook; don't touch!\n\nFunctions:\n\ndisplayhook() -- print an object to the screen, and save it in __builtin__._\nexcepthook() -- print an exception and its traceback to sys.stderr\nexc_info() -- return thread-safe information about the current exception\nexc_clear() -- clear the exception state for the current thread\nexit() -- exit the interpreter by raising SystemExit\ngetdlopenflags() -- returns flags to be used for dlopen() calls\ngetprofile() -- get the global profiling function\ngetrefcount() -- return the reference count for an object (plus one :-)\ngetrecursionlimit() -- return the max recursion depth for the interpreter\ngetsizeof() -- return the size of an object in bytes\ngettrace() -- get the global debug tracing function\nsetcheckinterval() -- control how often the interpreter checks for events\nsetdlopenflags() -- set the flags to be used for dlopen() calls\nsetprofile() -- set the global profiling function\nsetrecursionlimit() -- set the max recursion depth for the interpreter\nsettrace() -- set the global debug tracing function
__displayhook__ sys.__displayhook__()\ndisplayhook(object) -> None\n\nPrint an object to sys.stdout and also save it in __builtin__._
__doc__ sys.__doc__ [str]
__excepthook__ sys.__excepthook__()\nexcepthook(exctype, value, traceback) -> None\n\nHandle an exception by displaying it with a traceback on sys.stderr.
__name__ sys.__name__ [str]
__package__ sys.__package__ [NoneType]
__stderr__ sys.__stderr__ [file]
__stdin__ sys.__stdin__ [file]
__stdout__ sys.__stdout__ [file]
api_version sys.api_version [int]
argv sys.argv [list]
builtin_module_names sys.builtin_module_names [tuple]
byteorder sys.byteorder [str]
call_tracing sys.call_tracing(func, args) -> object\n\nCall func(*args), while tracing is enabled.  The tracing state is\nsaved, and restored afterwards.  This is intended to be called from\na debugger from a checkpoint, to recursively debug some other code.
callstats sys.callstats() -> tuple of integers\n\nReturn a tuple of function call statistics, if CALL_PROFILE was defined\nwhen Python was built.  Otherwise, return None.\n\nWhen enabled, this function returns detailed, implementation-specific\ndetails about the number of function calls executed. The return value is\na 11-tuple where the entries in the tuple are counts of:\n0. all function calls\n1. calls to PyFunction_Type objects\n2. PyFunction calls that do not create an argument tuple\n3. PyFunction calls that do not create an argument tuple\n   and bypass PyEval_EvalCodeEx()\n4. PyMethod calls\n5. PyMethod calls on bound methods\n6. PyType calls\n7. PyCFunction calls\n8. generator calls\n9. All other calls\n10. Number of stack pops performed by call_function()
copyright sys.copyright [str]
displayhook sys.displayhook(object) -> None\n\nPrint an object to sys.stdout and also save it in __builtin__._
dont_write_bytecode sys.dont_write_bytecode [bool]
exc_clear sys.exc_clear() -> None\n\nClear global information on the current exception.  Subsequent calls to\nexc_info() will return (None,None,None) until another exception is raised\nin the current thread or the execution stack returns to a frame where\nanother exception is being handled.
exc_info sys.exc_info() -> (type, value, traceback)\n\nReturn information about the most recent exception caught by an except\nclause in the current stack frame or in an older stack frame.
exc_type sys.exc_type [NoneType]
excepthook sys.excepthook()\nCatch an uncaught exception and make a traceback.
exec_prefix sys.exec_prefix [str]
executable sys.executable [str]
exit sys.exit([status])\n\nExit the interpreter by raising SystemExit(status).\nIf the status is omitted or None, it defaults to zero (i.e., success).\nIf the status is numeric, it will be used as the system exit status.\nIf it is another kind of object, it will be printed and the system\nexit status will be one (i.e., failure).
flags sys.flags [sys.flags]
float_info sys.float_info [sys.float_info]
float_repr_style sys.float_repr_style [str]
getcheckinterval sys.getcheckinterval() -> current check interval; see setcheckinterval().
getdefaultencoding sys.getdefaultencoding() -> string\n\nReturn the current default string encoding used by the Unicode \nimplementation.
getdlopenflags sys.getdlopenflags() -> int\n\nReturn the current value of the flags that are used for dlopen calls.\nThe flag constants are defined in the ctypes and DLFCN modules.
getfilesystemencoding sys.getfilesystemencoding() -> string\n\nReturn the encoding used to convert Unicode filenames in\noperating system filenames.
getprofile sys.getprofile()\n\nReturn the profiling function set with sys.setprofile.\nSee the profiler chapter in the library manual.
getrecursionlimit sys.getrecursionlimit()\n\nReturn the current value of the recursion limit, the maximum depth\nof the Python interpreter stack.  This limit prevents infinite\nrecursion from causing an overflow of the C stack and crashing Python.
getrefcount sys.getrefcount(object) -> integer\n\nReturn the reference count of object.  The count returned is generally\none higher than you might expect, because it includes the (temporary)\nreference as an argument to getrefcount().
getsizeof sys.getsizeof(object, default) -> int\n\nReturn the size of object in bytes.
gettrace sys.gettrace()\n\nReturn the global debug tracing function set with sys.settrace.\nSee the debugger chapter in the library manual.
hexversion sys.hexversion [int]
long_info sys.long_info [sys.long_info]
maxint sys.maxint [int]
maxsize sys.maxsize [int]
maxunicode sys.maxunicode [int]
meta_path sys.meta_path [list]
modules sys.modules [dict]
path sys.path [list]
path_hooks sys.path_hooks [list]
path_importer_cache sys.path_importer_cache [dict]
platform sys.platform [str]
prefix sys.prefix [str]
py3kwarning sys.py3kwarning [bool]
pydebug sys.pydebug [bool]
setcheckinterval sys.setcheckinterval(n)\n\nTell the Python interpreter to check for asynchronous events every\nn instructions.  This also affects how often thread switches occur.
setdlopenflags sys.setdlopenflags(n) -> None\n\nSet the flags used by the interpreter for dlopen calls, such as when the\ninterpreter loads extension modules.  Among other things, this will enable\na lazy resolving of symbols when importing a module, if called as\nsys.setdlopenflags(0).  To share symbols across extension modules, call as\nsys.setdlopenflags(ctypes.RTLD_GLOBAL).  Symbolic names for the flag modules\ncan be either found in the ctypes module, or in the DLFCN module. If DLFCN\nis not available, it can be generated from /usr/include/dlfcn.h using the\nh2py script.
setprofile sys.setprofile(function)\n\nSet the profiling function.  It will be called on each function call\nand return.  See the profiler chapter in the library manual.
setrecursionlimit sys.setrecursionlimit(n)\n\nSet the maximum depth of the Python interpreter stack to n.  This\nlimit prevents infinite recursion from causing an overflow of the C\nstack and crashing Python.  The highest possible limit is platform-\ndependent.
settrace sys.settrace(function)\n\nSet the global debug tracing function.  It will be called on each\nfunction call.  See the debugger chapter in the library manual.
stderr sys.stderr [file]
stdin sys.stdin [file]
stdout sys.stdout [file]
subversion sys.subversion [tuple]
version sys.version [str]
version_info sys.version_info [sys.version_info]
warnoptions sys.warnoptions [list]
__add__ str.__add__(y) <==> x+y
__class__ str.__class__()\nstr(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object.
__contains__ str.__contains__(y) <==> y in x
__delattr__ str.__delattr__('name') <==> del x.name
__doc__ str.__doc__ [str]
__eq__ str.__eq__(y) <==> x==y
__format__ str.__format__(format_spec) -> string\n\nReturn a formatted version of S as described by format_spec.
__ge__ str.__ge__(y) <==> x>=y
__getattribute__ str.__getattribute__('name') <==> x.name
__getitem__ str.__getitem__(y) <==> x[y]
__getnewargs__ str.__getnewargs__()\n
__getslice__ str.__getslice__(i, j) <==> x[i:j]\n           \n           Use of negative indices is not supported.
__gt__ str.__gt__(y) <==> x>y
__hash__ str.__hash__() <==> hash(x)
__init__ str.__init__(...) initializes x; see help(type(x)) for signature
__le__ str.__le__(y) <==> x<=y
__len__ str.__len__() <==> len(x)
__lt__ str.__lt__(y) <==> x<y
__mod__ str.__mod__(y) <==> x%y
__mul__ str.__mul__(n) <==> x*n
__ne__ str.__ne__(y) <==> x!=y
__new__ str.__new__(S, ...) -> a new object with type S, a subtype of T
__reduce__ str.__reduce__()\nhelper for pickle
__reduce_ex__ str.__reduce_ex__()\nhelper for pickle
__repr__ str.__repr__() <==> repr(x)
__rmod__ str.__rmod__(y) <==> y%x
__rmul__ str.__rmul__(n) <==> n*x
__setattr__ str.__setattr__('name', value) <==> x.name = value
__sizeof__ str.__sizeof__() -> size of S in memory, in bytes
__str__ str.__str__() <==> str(x)
__subclasshook__ str.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
capitalize str.capitalize() -> string\n\nReturn a copy of the string S with only its first character\ncapitalized.
center str.center(width[, fillchar]) -> string\n\nReturn S centered in a string of length width. Padding is\ndone using the specified fill character (default is a space)
count str.count(sub[, start[, end]]) -> int\n\nReturn the number of non-overlapping occurrences of substring sub in\nstring S[start:end].  Optional arguments start and end are interpreted\nas in slice notation.
decode str.decode([encoding[,errors]]) -> object\n\nDecodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is 'strict' meaning that encoding errors raise\na UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\nas well as any other name registered with codecs.register_error that is\nable to handle UnicodeDecodeErrors.
encode str.encode([encoding[,errors]]) -> object\n\nEncodes S using the codec registered for encoding. encoding defaults\nto the default encoding. errors may be given to set a different error\nhandling scheme. Default is 'strict' meaning that encoding errors raise\na UnicodeEncodeError. Other possible values are 'ignore', 'replace' and\n'xmlcharrefreplace' as well as any other name registered with\ncodecs.register_error that is able to handle UnicodeEncodeErrors.
endswith str.endswith(suffix[, start[, end]]) -> bool\n\nReturn True if S ends with the specified suffix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nsuffix can also be a tuple of strings to try.
expandtabs str.expandtabs([tabsize]) -> string\n\nReturn a copy of S where all tab characters are expanded using spaces.\nIf tabsize is not given, a tab size of 8 characters is assumed.
find str.find(sub [,start [,end]]) -> int\n\nReturn the lowest index in S where substring sub is found,\nsuch that sub is contained within S[start:end].  Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.
format str.format(*args, **kwargs) -> string\n\nReturn a formatted version of S, using substitutions from args and kwargs.\nThe substitutions are identified by braces ('{' and '}').
index str.index(sub [,start [,end]]) -> int\n\nLike S.find() but raise ValueError when the substring is not found.
isalnum str.isalnum() -> bool\n\nReturn True if all characters in S are alphanumeric\nand there is at least one character in S, False otherwise.
isalpha str.isalpha() -> bool\n\nReturn True if all characters in S are alphabetic\nand there is at least one character in S, False otherwise.
isdigit str.isdigit() -> bool\n\nReturn True if all characters in S are digits\nand there is at least one character in S, False otherwise.
islower str.islower() -> bool\n\nReturn True if all cased characters in S are lowercase and there is\nat least one cased character in S, False otherwise.
isspace str.isspace() -> bool\n\nReturn True if all characters in S are whitespace\nand there is at least one character in S, False otherwise.
istitle str.istitle() -> bool\n\nReturn True if S is a titlecased string and there is at least one\ncharacter in S, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise.
isupper str.isupper() -> bool\n\nReturn True if all cased characters in S are uppercase and there is\nat least one cased character in S, False otherwise.
join str.join(iterable) -> string\n\nReturn a string which is the concatenation of the strings in the\niterable.  The separator between elements is S.
ljust str.ljust(width[, fillchar]) -> string\n\nReturn S left-justified in a string of length width. Padding is\ndone using the specified fill character (default is a space).
lower str.lower() -> string\n\nReturn a copy of the string S converted to lowercase.
lstrip str.lstrip([chars]) -> string or unicode\n\nReturn a copy of the string S with leading whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping
partition str.partition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, and return the part before it,\nthe separator itself, and the part after it.  If the separator is not\nfound, return S and two empty strings.
replace str.replace(old, new[, count]) -> string\n\nReturn a copy of string S with all occurrences of substring\nold replaced by new.  If the optional argument count is\ngiven, only the first count occurrences are replaced.
rfind str.rfind(sub [,start [,end]]) -> int\n\nReturn the highest index in S where substring sub is found,\nsuch that sub is contained within S[start:end].  Optional\narguments start and end are interpreted as in slice notation.\n\nReturn -1 on failure.
rindex str.rindex(sub [,start [,end]]) -> int\n\nLike S.rfind() but raise ValueError when the substring is not found.
rjust str.rjust(width[, fillchar]) -> string\n\nReturn S right-justified in a string of length width. Padding is\ndone using the specified fill character (default is a space)
rpartition str.rpartition(sep) -> (head, sep, tail)\n\nSearch for the separator sep in S, starting at the end of S, and return\nthe part before it, the separator itself, and the part after it.  If the\nseparator is not found, return two empty strings and S.
rsplit str.rsplit([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in the string S, using sep as the\ndelimiter string, starting at the end of the string and working\nto the front.  If maxsplit is given, at most maxsplit splits are\ndone. If sep is not specified or is None, any whitespace string\nis a separator.
rstrip str.rstrip([chars]) -> string or unicode\n\nReturn a copy of the string S with trailing whitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping
split str.split([sep [,maxsplit]]) -> list of strings\n\nReturn a list of the words in the string S, using sep as the\ndelimiter string.  If maxsplit is given, at most maxsplit\nsplits are done. If sep is not specified or is None, any\nwhitespace string is a separator and empty strings are removed\nfrom the result.
splitlines str.splitlines([keepends]) -> list of strings\n\nReturn a list of the lines in S, breaking at line boundaries.\nLine breaks are not included in the resulting list unless keepends\nis given and true.
startswith str.startswith(prefix[, start[, end]]) -> bool\n\nReturn True if S starts with the specified prefix, False otherwise.\nWith optional start, test S beginning at that position.\nWith optional end, stop comparing S at that position.\nprefix can also be a tuple of strings to try.
strip str.strip([chars]) -> string or unicode\n\nReturn a copy of the string S with leading and trailing\nwhitespace removed.\nIf chars is given and not None, remove characters in chars instead.\nIf chars is unicode, S will be converted to unicode before stripping
swapcase str.swapcase() -> string\n\nReturn a copy of the string S with uppercase characters\nconverted to lowercase and vice versa.
title str.title() -> string\n\nReturn a titlecased version of S, i.e. words start with uppercase\ncharacters, all remaining cased characters have lowercase.
translate str.translate(table [,deletechars]) -> string\n\nReturn a copy of the string S, where all characters occurring\nin the optional argument deletechars are removed, and the\nremaining characters have been mapped through the given\ntranslation table, which must be a string of length 256 or None.\nIf the table argument is None, no translation is applied and\nthe operation simply removes the characters in deletechars.
upper str.upper() -> string\n\nReturn a copy of the string S converted to uppercase.
zfill str.zfill(width) -> string\n\nPad a numeric string S with zeros on the left, to fill a field\nof the specified width.  The string S is never truncated.
__add__ tuple.__add__(y) <==> x+y
__class__ tuple.__class__()\ntuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable's items\n\nIf the argument is a tuple, the return value is the same object.
__contains__ tuple.__contains__(y) <==> y in x
__delattr__ tuple.__delattr__('name') <==> del x.name
__doc__ tuple.__doc__ [str]
__eq__ tuple.__eq__(y) <==> x==y
__format__ tuple.__format__()\ndefault object formatter
__ge__ tuple.__ge__(y) <==> x>=y
__getattribute__ tuple.__getattribute__('name') <==> x.name
__getitem__ tuple.__getitem__(y) <==> x[y]
__getnewargs__ tuple.__getnewargs__()\n
__getslice__ tuple.__getslice__(i, j) <==> x[i:j]\n           \n           Use of negative indices is not supported.
__gt__ tuple.__gt__(y) <==> x>y
__hash__ tuple.__hash__() <==> hash(x)
__init__ tuple.__init__(...) initializes x; see help(type(x)) for signature
__iter__ tuple.__iter__() <==> iter(x)
__le__ tuple.__le__(y) <==> x<=y
__len__ tuple.__len__() <==> len(x)
__lt__ tuple.__lt__(y) <==> x<y
__mul__ tuple.__mul__(n) <==> x*n
__ne__ tuple.__ne__(y) <==> x!=y
__new__ tuple.__new__(S, ...) -> a new object with type S, a subtype of T
__reduce__ tuple.__reduce__()\nhelper for pickle
__reduce_ex__ tuple.__reduce_ex__()\nhelper for pickle
__repr__ tuple.__repr__() <==> repr(x)
__rmul__ tuple.__rmul__(n) <==> n*x
__setattr__ tuple.__setattr__('name', value) <==> x.name = value
__sizeof__ tuple.__sizeof__() -- size of T in memory, in bytes
__str__ tuple.__str__() <==> str(x)
__subclasshook__ tuple.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
count tuple.count(value) -> integer -- return number of occurrences of value
index tuple.index(value, [start, [stop]]) -> integer -- return first index of value.\nRaises ValueError if the value is not present.
__add__ list.__add__(y) <==> x+y
__class__ list.__class__()\nlist() -> new empty list\nlist(iterable) -> new list initialized from iterable's items
__contains__ list.__contains__(y) <==> y in x
__delattr__ list.__delattr__('name') <==> del x.name
__delitem__ list.__delitem__(y) <==> del x[y]
__delslice__ list.__delslice__(i, j) <==> del x[i:j]\n           \n           Use of negative indices is not supported.
__doc__ list.__doc__ [str]
__eq__ list.__eq__(y) <==> x==y
__format__ list.__format__()\ndefault object formatter
__ge__ list.__ge__(y) <==> x>=y
__getattribute__ list.__getattribute__('name') <==> x.name
__getitem__ list.__getitem__(y) <==> x[y]
__getslice__ list.__getslice__(i, j) <==> x[i:j]\n           \n           Use of negative indices is not supported.
__gt__ list.__gt__(y) <==> x>y
__hash__ list.__hash__ [NoneType]
__iadd__ list.__iadd__(y) <==> x+=y
__imul__ list.__imul__(y) <==> x*=y
__init__ list.__init__(...) initializes x; see help(type(x)) for signature
__iter__ list.__iter__() <==> iter(x)
__le__ list.__le__(y) <==> x<=y
__len__ list.__len__() <==> len(x)
__lt__ list.__lt__(y) <==> x<y
__mul__ list.__mul__(n) <==> x*n
__ne__ list.__ne__(y) <==> x!=y
__new__ list.__new__(S, ...) -> a new object with type S, a subtype of T
__reduce__ list.__reduce__()\nhelper for pickle
__reduce_ex__ list.__reduce_ex__()\nhelper for pickle
__repr__ list.__repr__() <==> repr(x)
__reversed__ list.__reversed__() -- return a reverse iterator over the list
__rmul__ list.__rmul__(n) <==> n*x
__setattr__ list.__setattr__('name', value) <==> x.name = value
__setitem__ list.__setitem__(i, y) <==> x[i]=y
__setslice__ list.__setslice__(i, j, y) <==> x[i:j]=y\n           \n           Use  of negative indices is not supported.
__sizeof__ list.__sizeof__() -- size of L in memory, in bytes
__str__ list.__str__() <==> str(x)
__subclasshook__ list.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
append list.append(object) -- append object to end
count list.count(value) -> integer -- return number of occurrences of value
extend list.extend(iterable) -- extend list by appending elements from the iterable
index list.index(value, [start, [stop]]) -> integer -- return first index of value.\nRaises ValueError if the value is not present.
insert list.insert(index, object) -- insert object before index
pop list.pop([index]) -> item -- remove and return item at index (default last).\nRaises IndexError if list is empty or index is out of range.
remove list.remove(value) -- remove first occurrence of value.\nRaises ValueError if the value is not present.
reverse list.reverse() -- reverse *IN PLACE*
sort list.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;\ncmp(x, y) -> -1, 0, 1
__class__ dict.__class__()\ndict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)
__cmp__ dict.__cmp__(y) <==> cmp(x,y)
__contains__ dict.__contains__(k) -> True if D has a key k, else False
__delattr__ dict.__delattr__('name') <==> del x.name
__delitem__ dict.__delitem__(y) <==> del x[y]
__doc__ dict.__doc__ [str]
__eq__ dict.__eq__(y) <==> x==y
__format__ dict.__format__()\ndefault object formatter
__ge__ dict.__ge__(y) <==> x>=y
__getattribute__ dict.__getattribute__('name') <==> x.name
__getitem__ dict.__getitem__(y) <==> x[y]
__gt__ dict.__gt__(y) <==> x>y
__hash__ dict.__hash__ [NoneType]
__init__ dict.__init__(...) initializes x; see help(type(x)) for signature
__iter__ dict.__iter__() <==> iter(x)
__le__ dict.__le__(y) <==> x<=y
__len__ dict.__len__() <==> len(x)
__lt__ dict.__lt__(y) <==> x<y
__ne__ dict.__ne__(y) <==> x!=y
__new__ dict.__new__(S, ...) -> a new object with type S, a subtype of T
__reduce__ dict.__reduce__()\nhelper for pickle
__reduce_ex__ dict.__reduce_ex__()\nhelper for pickle
__repr__ dict.__repr__() <==> repr(x)
__setattr__ dict.__setattr__('name', value) <==> x.name = value
__setitem__ dict.__setitem__(i, y) <==> x[i]=y
__sizeof__ dict.__sizeof__() -> size of D in memory, in bytes
__str__ dict.__str__() <==> str(x)
__subclasshook__ dict.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
clear dict.clear() -> None.  Remove all items from D.
copy dict.copy() -> a shallow copy of D
fromkeys dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.\nv defaults to None.
get dict.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
has_key dict.has_key(k) -> True if D has a key k, else False
items dict.items() -> list of D's (key, value) pairs, as 2-tuples
iteritems dict.iteritems() -> an iterator over the (key, value) items of D
iterkeys dict.iterkeys() -> an iterator over the keys of D
itervalues dict.itervalues() -> an iterator over the values of D
keys dict.keys() -> list of D's keys
pop dict.pop(k[,d]) -> v, remove specified key and return the corresponding value.\nIf key is not found, d is returned if given, otherwise KeyError is raised
popitem dict.popitem() -> (k, v), remove and return some (key, value) pair as a\n2-tuple; but raise KeyError if D is empty.
setdefault dict.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
update dict.update(E, **F) -> None.  Update D from dict/iterable E and F.\nIf E has a .keys() method, does:     for k in E: D[k] = E[k]\nIf E lacks .keys() method, does:     for (k, v) in E: D[k] = v\nIn either case, this is followed by: for k in F: D[k] = F[k]
values dict.values() -> list of D's values
viewitems dict.viewitems() -> a set-like object providing a view on D's items
viewkeys dict.viewkeys() -> a set-like object providing a view on D's keys
viewvalues dict.viewvalues() -> an object providing a view on D's values
__abs__ int.__abs__() <==> abs(x)
__add__ int.__add__(y) <==> x+y
__and__ int.__and__(y) <==> x&y
__class__ int.__class__()\nint(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible.  A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!)  When converting a string, use\nthe optional base.  It is an error to supply a base when converting a\nnon-string.  If base is zero, the proper base is guessed based on the\nstring content.  If the argument is outside the integer range a\nlong object will be returned instead.
__cmp__ int.__cmp__(y) <==> cmp(x,y)
__coerce__ int.__coerce__(y) <==> coerce(x, y)
__delattr__ int.__delattr__('name') <==> del x.name
__div__ int.__div__(y) <==> x/y
__divmod__ int.__divmod__(y) <==> divmod(x, y)
__doc__ int.__doc__ [str]
__float__ int.__float__() <==> float(x)
__floordiv__ int.__floordiv__(y) <==> x//y
__format__ int.__format__()\n
__getattribute__ int.__getattribute__('name') <==> x.name
__getnewargs__ int.__getnewargs__()\n
__hash__ int.__hash__() <==> hash(x)
__hex__ int.__hex__() <==> hex(x)
__index__ int.__index__():z.__index__()]
__init__ int.__init__(...) initializes x; see help(type(x)) for signature
__int__ int.__int__() <==> int(x)
__invert__ int.__invert__() <==> ~x
__long__ int.__long__() <==> long(x)
__lshift__ int.__lshift__(y) <==> x<<y
__mod__ int.__mod__(y) <==> x%y
__mul__ int.__mul__(y) <==> x*y
__neg__ int.__neg__() <==> -x
__new__ int.__new__(S, ...) -> a new object with type S, a subtype of T
__nonzero__ int.__nonzero__() <==> x != 0
__oct__ int.__oct__() <==> oct(x)
__or__ int.__or__(y) <==> x|y
__pos__ int.__pos__() <==> +x
__pow__ int.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__ int.__radd__(y) <==> y+x
__rand__ int.__rand__(y) <==> y&x
__rdiv__ int.__rdiv__(y) <==> y/x
__rdivmod__ int.__rdivmod__(y) <==> divmod(y, x)
__reduce__ int.__reduce__()\nhelper for pickle
__reduce_ex__ int.__reduce_ex__()\nhelper for pickle
__repr__ int.__repr__() <==> repr(x)
__rfloordiv__ int.__rfloordiv__(y) <==> y//x
__rlshift__ int.__rlshift__(y) <==> y<<x
__rmod__ int.__rmod__(y) <==> y%x
__rmul__ int.__rmul__(y) <==> y*x
__ror__ int.__ror__(y) <==> y|x
__rpow__ int.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__ int.__rrshift__(y) <==> y>>x
__rshift__ int.__rshift__(y) <==> x>>y
__rsub__ int.__rsub__(y) <==> y-x
__rtruediv__ int.__rtruediv__(y) <==> y/x
__rxor__ int.__rxor__(y) <==> y^x
__setattr__ int.__setattr__('name', value) <==> x.name = value
__sizeof__ int.__sizeof__() -> int\nsize of object in memory, in bytes
__str__ int.__str__() <==> str(x)
__sub__ int.__sub__(y) <==> x-y
__subclasshook__ int.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
__truediv__ int.__truediv__(y) <==> x/y
__trunc__ int.__trunc__()\nTruncating an Integral returns itself.
__xor__ int.__xor__(y) <==> x^y
bit_length int.bit_length() -> int\n\nNumber of bits necessary to represent self in binary.\n>>> bin(37)\n'0b100101'\n>>> (37).bit_length()\n6
conjugate int.conjugate()\nReturns self, the complex conjugate of any int.
denominator int.denominator [int]
imag int.imag [int]
numerator int.numerator [int]
real int.real [int]
__abs__ float.__abs__() <==> abs(x)
__add__ float.__add__(y) <==> x+y
__class__ float.__class__()\nfloat(x) -> floating point number\n\nConvert a string or number to a floating point number, if possible.
__coerce__ float.__coerce__(y) <==> coerce(x, y)
__delattr__ float.__delattr__('name') <==> del x.name
__div__ float.__div__(y) <==> x/y
__divmod__ float.__divmod__(y) <==> divmod(x, y)
__doc__ float.__doc__ [str]
__eq__ float.__eq__(y) <==> x==y
__float__ float.__float__() <==> float(x)
__floordiv__ float.__floordiv__(y) <==> x//y
__format__ float.__format__(format_spec) -> string\n\nFormats the float according to format_spec.
__ge__ float.__ge__(y) <==> x>=y
__getattribute__ float.__getattribute__('name') <==> x.name
__getformat__ float.__getformat__(typestr) -> string\n\nYou probably don't want to use this function.  It exists mainly to be\nused in Python's test suite.\n\ntypestr must be 'double' or 'float'.  This function returns whichever of\n'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the\nformat of floating point numbers used by the C type named by typestr.
__getnewargs__ float.__getnewargs__()\n
__gt__ float.__gt__(y) <==> x>y
__hash__ float.__hash__() <==> hash(x)
__init__ float.__init__(...) initializes x; see help(type(x)) for signature
__int__ float.__int__() <==> int(x)
__le__ float.__le__(y) <==> x<=y
__long__ float.__long__() <==> long(x)
__lt__ float.__lt__(y) <==> x<y
__mod__ float.__mod__(y) <==> x%y
__mul__ float.__mul__(y) <==> x*y
__ne__ float.__ne__(y) <==> x!=y
__neg__ float.__neg__() <==> -x
__new__ float.__new__(S, ...) -> a new object with type S, a subtype of T
__nonzero__ float.__nonzero__() <==> x != 0
__pos__ float.__pos__() <==> +x
__pow__ float.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__ float.__radd__(y) <==> y+x
__rdiv__ float.__rdiv__(y) <==> y/x
__rdivmod__ float.__rdivmod__(y) <==> divmod(y, x)
__reduce__ float.__reduce__()\nhelper for pickle
__reduce_ex__ float.__reduce_ex__()\nhelper for pickle
__repr__ float.__repr__() <==> repr(x)
__rfloordiv__ float.__rfloordiv__(y) <==> y//x
__rmod__ float.__rmod__(y) <==> y%x
__rmul__ float.__rmul__(y) <==> y*x
__rpow__ float.__rpow__(x[, z]) <==> pow(x, y[, z])
__rsub__ float.__rsub__(y) <==> y-x
__rtruediv__ float.__rtruediv__(y) <==> y/x
__setattr__ float.__setattr__('name', value) <==> x.name = value
__setformat__ float.__setformat__(typestr, fmt) -> None\n\nYou probably don't want to use this function.  It exists mainly to be\nused in Python's test suite.\n\ntypestr must be 'double' or 'float'.  fmt must be one of 'unknown',\n'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be\none of the latter two if it appears to match the underlying C reality.\n\nOverrides the automatic determination of C-level floating point type.\nThis affects how floats are converted to and from binary strings.
__sizeof__ float.__sizeof__() -> int\nsize of object in memory, in bytes
__str__ float.__str__() <==> str(x)
__sub__ float.__sub__(y) <==> x-y
__subclasshook__ float.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
__truediv__ float.__truediv__(y) <==> x/y
__trunc__ float.__trunc__()\nReturns the Integral closest to x between 0 and x.
as_integer_ratio float.as_integer_ratio() -> (int, int)\n\nReturns a pair of integers, whose ratio is exactly equal to the original\nfloat and with a positive denominator.\nRaises OverflowError on infinities and a ValueError on NaNs.\n\n>>> (10.0).as_integer_ratio()\n(10, 1)\n>>> (0.0).as_integer_ratio()\n(0, 1)\n>>> (-.25).as_integer_ratio()\n(-1, 4)
conjugate float.conjugate()\nReturns self, the complex conjugate of any float.
fromhex float.fromhex(string) -> float\n\nCreate a floating-point number from a hexadecimal string.\n>>> float.fromhex('0x1.ffffp10')\n2047.984375\n>>> float.fromhex('-0x1p-1074')\n-4.9406564584124654e-324
hex float.hex() -> string\n\nReturn a hexadecimal representation of a floating-point number.\n>>> (-0.1).hex()\n'-0x1.999999999999ap-4'\n>>> 3.14159.hex()\n'0x1.921f9f01b866ep+1'
imag float.imag [float]
is_integer float.is_integer()\nReturns True if the float is an integer.
real float.real [float]
__class__ file.__class__()\nfile(name[, mode[, buffering]]) -> file object\n\nOpen a file.  The mode can be 'r', 'w' or 'a' for reading (default),\nwriting or appending.  The file will be created if it doesn't exist\nwhen opened for writing or appending; it will be truncated when\nopened for writing.  Add a 'b' to the mode for binary files.\nAdd a '+' to the mode to allow simultaneous reading and writing.\nIf the buffering argument is given, 0 means unbuffered, 1 means line\nbuffered, and larger numbers specify the buffer size.  The preferred way\nto open a file is with the builtin open() function.\nAdd a 'U' to mode to open the file for input with universal newline\nsupport.  Any line ending in the input file will be seen as a '\\n'\nin Python.  Also, a file so opened gains the attribute 'newlines';\nthe value for this attribute is one of None (no newline read yet),\n'\r', '\\n', '\r\\n' or a tuple containing all the newline types seen.\n\n'U' cannot be combined with 'w' or '+' mode.
__delattr__ file.__delattr__('name') <==> del x.name
__doc__ file.__doc__ [str]
__enter__ file.__enter__() -> self.
__exit__ file.__exit__(*excinfo) -> None.  Closes the file.
__format__ file.__format__()\ndefault object formatter
__getattribute__ file.__getattribute__('name') <==> x.name
__hash__ file.__hash__() <==> hash(x)
__init__ file.__init__(...) initializes x; see help(type(x)) for signature
__iter__ file.__iter__() <==> iter(x)
__new__ file.__new__(S, ...) -> a new object with type S, a subtype of T
__reduce__ file.__reduce__()\nhelper for pickle
__reduce_ex__ file.__reduce_ex__()\nhelper for pickle
__repr__ file.__repr__() <==> repr(x)
__setattr__ file.__setattr__('name', value) <==> x.name = value
__sizeof__ file.__sizeof__() -> int\nsize of object in memory, in bytes
__str__ file.__str__() <==> str(x)
__subclasshook__ file.__subclasshook__()\nAbstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).
close file.close() -> None or (perhaps) an integer.  Close the file.\n\nSets data attribute .closed to True.  A closed file cannot be used for\nfurther I/O operations.  close() may be called more than once without\nerror.  Some kinds of file objects (for example, opened by popen())\nmay return an exit status upon closing.
closed file.closed [bool]
encoding file.encoding [NoneType]
errors file.errors [NoneType]
fileno file.fileno() -> integer "file descriptor".\n\nThis is needed for lower-level file interfaces, such os.read().
flush file.flush() -> None.  Flush the internal I/O buffer.
isatty file.isatty() -> true or false.  True if the file is connected to a tty device.
mode file.mode [str]
name file.name [str]
newlines file.newlines [NoneType]
next file.next() -> the next value, or raise StopIteration
read file.read([size]) -> read at most size bytes, returned as a string.\n\nIf the size argument is negative or omitted, read until EOF is reached.\nNotice that when in non-blocking mode, less data than what was requested\nmay be returned, even if no size parameter was given.
readinto file.readinto() -> Undocumented.  Don't use this; it may go away.
readline file.readline([size]) -> next line from the file, as a string.\n\nRetain newline.  A non-negative size argument limits the maximum\nnumber of bytes to return (an incomplete line may be returned then).\nReturn an empty string at EOF.
readlines file.readlines([size]) -> list of strings, each a line from the file.\n\nCall readline() repeatedly and return a list of the lines so read.\nThe optional size argument, if given, is an approximate bound on the\ntotal number of bytes in the lines returned.
seek file.seek(offset[, whence]) -> None.  Move to new file position.\n\nArgument offset is a byte count.  Optional argument whence defaults to\n0 (offset from start of file, offset should be >= 0); other values are 1\n(move relative to current position, positive or negative), and 2 (move\nrelative to end of file, usually negative, although many platforms allow\nseeking beyond the end of a file).  If the file is opened in text mode,\nonly offsets returned by tell() are legal.  Use of other offsets causes\nundefined behavior.\nNote that not all file objects are seekable.
softspace file.softspace [int]
tell file.tell() -> current file position, an integer (may be a long integer).
truncate file.truncate([size]) -> None.  Truncate the file to at most size bytes.\n\nSize defaults to the current file position, as returned by tell().
write file.write(str) -> None.  Write string str to file.\n\nNote that due to buffering, flush() or close() may be needed before\nthe file on disk reflects the data written.
writelines file.writelines(sequence_of_strings) -> None.  Write the strings to the file.\n\nNote that newlines are not added.  The sequence can be any iterable object\nproducing strings. This is equivalent to calling write() for each string.
xreadlines file.xreadlines() -> returns self.\n\nFor backward compatibility. File objects now include the performance\noptimizations previously implemented in the xreadlines module.
ArithmeticError ArithmeticError()\nBase class for arithmetic errors.
AssertionError AssertionError()\nAssertion failed.
AttributeError AttributeError()\nAttribute not found.
BaseException BaseException()\nCommon base class for all exceptions
BufferError BufferError()\nBuffer error.
BytesWarning BytesWarning()\nBase class for warnings about bytes and buffer related problems, mostly\nrelated to conversion from str or comparing to str.
DeprecationWarning DeprecationWarning()\nBase class for warnings about deprecated features.
EOFError EOFError()\nRead beyond end of file.
Ellipsis Ellipsis [ellipsis]
EnvironmentError EnvironmentError()\nBase class for I/O related errors.
Exception Exception()\nCommon base class for all non-exit exceptions.
False False [bool]
FloatingPointError FloatingPointError()\nFloating point operation failed.
FutureWarning FutureWarning()\nBase class for warnings about constructs that will change semantically\nin the future.
GeneratorExit GeneratorExit()\nRequest that a generator exit.
IOError IOError()\nI/O operation failed.
ImportError ImportError()\nImport can't find module, or can't find name in module.
ImportWarning ImportWarning()\nBase class for warnings about probable mistakes in module imports
IndentationError IndentationError()\nImproper indentation.
IndexError IndexError()\nSequence index out of range.
KeyError KeyError()\nMapping key not found.
KeyboardInterrupt KeyboardInterrupt()\nProgram interrupted by user.
LookupError LookupError()\nBase class for lookup errors.
MemoryError MemoryError()\nOut of memory.
NameError NameError()\nName not found globally.
None None [NoneType]
NotImplemented NotImplemented [NotImplementedType]
NotImplementedError NotImplementedError()\nMethod or function hasn't been implemented yet.
OSError OSError()\nOS system call failed.
OverflowError OverflowError()\nResult too large to be represented.
PendingDeprecationWarning PendingDeprecationWarning()\nBase class for warnings about features which will be deprecated\nin the future.
ReferenceError ReferenceError()\nWeak ref proxy used after referent went away.
RuntimeError RuntimeError()\nUnspecified run-time error.
RuntimeWarning RuntimeWarning()\nBase class for warnings about dubious runtime behavior.
StandardError StandardError()\nBase class for all standard Python exceptions that do not represent\ninterpreter exiting.
StopIteration StopIteration()\nSignal the end from iterator.next().
SyntaxError SyntaxError()\nInvalid syntax.
SyntaxWarning SyntaxWarning()\nBase class for warnings about dubious syntax.
SystemError SystemError()\nInternal error in the Python interpreter.\n\nPlease report this to the Python maintainer, along with the traceback,\nthe Python version, and the hardware/OS platform and version.
SystemExit SystemExit()\nRequest to exit from the interpreter.
TabError TabError()\nImproper mixture of spaces and tabs.
True True [bool]
TypeError TypeError()\nInappropriate argument type.
UnboundLocalError UnboundLocalError()\nLocal name referenced but not bound to a value.
UnicodeDecodeError UnicodeDecodeError()\nUnicode decoding error.
UnicodeEncodeError UnicodeEncodeError()\nUnicode encoding error.
UnicodeError UnicodeError()\nUnicode related error.
UnicodeTranslateError UnicodeTranslateError()\nUnicode translation error.
UnicodeWarning UnicodeWarning()\nBase class for warnings about Unicode related problems, mostly\nrelated to conversion problems.
UserWarning UserWarning()\nBase class for warnings generated by user code.
ValueError ValueError()\nInappropriate argument value (of correct type).
Warning Warning()\nBase class for warning categories.
ZeroDivisionError ZeroDivisionError()\nSecond argument to a division or modulo operation was zero.
__debug__ __debug__ [bool]
__doc__ __doc__ [str]
__import__ __import__(name, globals={}, locals={}, fromlist=[], level=-1) -> module\n\nImport a module.  The globals are only used to determine the context;\nthey are not modified.  The locals are currently unused.  The fromlist\nshould be a list of names to emulate ``from name import ...'', or an\nempty list to emulate ``import name''.\nWhen importing a module from a package, note that __import__('A.B', ...)\nreturns package A when fromlist is empty, but its submodule B when\nfromlist is not empty.  Level is used to determine whether to perform \nabsolute or relative imports.  -1 is the original strategy of attempting\nboth absolute and relative imports, 0 is absolute, a positive number\nis the number of parent directories to search relative to the current module.
__name__ __name__ [str]
__package__ __package__ [NoneType]
abs abs(number) -> number\n\nReturn the absolute value of the argument.
all all(iterable) -> bool\n\nReturn True if bool(x) is True for all values x in the iterable.
any any(iterable) -> bool\n\nReturn True if bool(x) is True for any x in the iterable.
apply apply(object[, args[, kwargs]]) -> value\n\nCall a callable object with positional arguments taken from the tuple args,\nand keyword arguments taken from the optional dictionary kwargs.\nNote that classes are callable, as are instances with a __call__() method.\n\nDeprecated since release 2.3. Instead, use the extended call syntax:\n    function(*args, **keywords).
basestring basestring()\nType basestring cannot be instantiated; it is the base for str and unicode.
bin bin(number) -> string\n\nReturn the binary representation of an integer or long integer.
bool bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.
buffer buffer(object [, offset[, size]])\n\nCreate a new buffer object which references the given object.\nThe buffer will reference a slice of the target object from the\nstart of the object (or at the specified offset). The slice will\nextend to the end of the target object (or with the specified size).
bytearray bytearray(iterable_of_ints) -> bytearray.\nbytearray(string, encoding[, errors]) -> bytearray.\nbytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.\nbytearray(memory_view) -> bytearray.\n\nConstruct an mutable bytearray object from:\n  - an iterable yielding integers in range(256)\n  - a text string encoded using the specified encoding\n  - a bytes or a bytearray object\n  - any object implementing the buffer API.\n\nbytearray(int) -> bytearray.\n\nConstruct a zero-initialized bytearray of the given length.
bytes bytes()\nstr(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object.
callable callable(object) -> bool\n\nReturn whether the object is callable (i.e., some kind of function).\nNote that classes are callable, as are instances with a __call__() method.
chr chr(i) -> character\n\nReturn a string of one character with ordinal i; 0 <= i < 256.
classmethod classmethod(function) -> method\n\nConvert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n  class C:\n      def f(cls, arg1, arg2, ...): ...\n      f = classmethod(f)\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()).  The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin.
cmp cmp(x, y) -> integer\n\nReturn negative if x<y, zero if x==y, positive if x>y.
coerce coerce(x, y) -> (x1, y1)\n\nReturn a tuple consisting of the two numeric arguments converted to\na common type, using the same rules as used by arithmetic operations.\nIf coercion is not possible, raise TypeError.
compile compile(source, filename, mode[, flags[, dont_inherit]]) -> code object\n\nCompile the source string (a Python module, statement or expression)\ninto a code object that can be executed by the exec statement or eval().\nThe filename will be used for run-time error messages.\nThe mode must be 'exec' to compile a module, 'single' to compile a\nsingle (interactive) statement, or 'eval' to compile an expression.\nThe flags argument, if present, controls which future statements influence\nthe compilation of the code.\nThe dont_inherit argument, if non-zero, stops the compilation inheriting\nthe effects of any future statements in effect in the code calling\ncompile; if absent or zero these statements do influence the compilation,\nin addition to any features explicitly specified.
complex complex(real[, imag]) -> complex number\n\nCreate a complex number from a real part and an optional imaginary part.\nThis is equivalent to (real + imag*1j) where imag defaults to 0.
copyright copyright()\ninteractive prompt objects for printing the license text, a list of\n    contributors and the copyright notice.
credits credits()\ninteractive prompt objects for printing the license text, a list of\n    contributors and the copyright notice.
delattr delattr(object, name)\n\nDelete a named attribute on an object; delattr(x, 'y') is equivalent to\n``del x.y''.
dict dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)
dir dir([object]) -> list of strings\n\nIf called without an argument, return the names in the current scope.\nElse, return an alphabetized list of names comprising (some of) the attributes\nof the given object, and of attributes reachable from it.\nIf the object supplies a method named __dir__, it will be used; otherwise\nthe default dir() logic is used and returns:\n  for a module object: the module's attributes.\n  for a class object:  its attributes, and recursively the attributes\n    of its bases.\n  for any other object: its attributes, its class's attributes, and\n    recursively the attributes of its class's base classes.
divmod divmod(x, y) -> (quotient, remainder)\n\nReturn the tuple ((x-x%y)/y, x%y).  Invariant: div*y + mod == x.
enumerate enumerate(iterable[, start]) -> iterator for index, value of iterable\n\nReturn an enumerate object.  iterable must be another object that supports\niteration.  The enumerate object yields pairs containing a count (from\nstart, which defaults to zero) and a value yielded by the iterable argument.\nenumerate is useful for obtaining an indexed list:\n    (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
eval eval(source[, globals[, locals]]) -> value\n\nEvaluate the source in the context of globals and locals.\nThe source may be a string representing a Python expression\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.
execfile execfile(filename[, globals[, locals]])\n\nRead and execute a Python script from a file.\nThe globals and locals are dictionaries, defaulting to the current\nglobals and locals.  If only globals is given, locals defaults to it.
exit exit()\n
file file(name[, mode[, buffering]]) -> file object\n\nOpen a file.  The mode can be 'r', 'w' or 'a' for reading (default),\nwriting or appending.  The file will be created if it doesn't exist\nwhen opened for writing or appending; it will be truncated when\nopened for writing.  Add a 'b' to the mode for binary files.\nAdd a '+' to the mode to allow simultaneous reading and writing.\nIf the buffering argument is given, 0 means unbuffered, 1 means line\nbuffered, and larger numbers specify the buffer size.  The preferred way\nto open a file is with the builtin open() function.\nAdd a 'U' to mode to open the file for input with universal newline\nsupport.  Any line ending in the input file will be seen as a '\\n'\nin Python.  Also, a file so opened gains the attribute 'newlines';\nthe value for this attribute is one of None (no newline read yet),\n'\r', '\\n', '\r\\n' or a tuple containing all the newline types seen.\n\n'U' cannot be combined with 'w' or '+' mode.
filter filter(function or None, sequence) -> list, tuple, or string\n\nReturn those items of sequence for which function(item) is true.  If\nfunction is None, return the items that are true.  If sequence is a tuple\nor string, return the same type, else return a list.
float float(x) -> floating point number\n\nConvert a string or number to a floating point number, if possible.
format format(value[, format_spec]) -> string\n\nReturns value.__format__(format_spec)\nformat_spec defaults to ""
frozenset frozenset() -> empty frozenset object\nfrozenset(iterable) -> frozenset object\n\nBuild an immutable unordered collection of unique elements.
getattr getattr(object, name[, default]) -> value\n\nGet a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\nWhen a default argument is given, it is returned when the attribute doesn't\nexist; without it, an exception is raised in that case.
globals globals() -> dictionary\n\nReturn the dictionary containing the current scope's global variables.
hasattr hasattr(object, name) -> bool\n\nReturn whether the object has an attribute with the given name.\n(This is done by calling getattr(object, name) and catching exceptions.)
hash hash(object) -> integer\n\nReturn a hash value for the object.  Two objects with the same value have\nthe same hash value.  The reverse is not necessarily true, but likely.
help help()\nDefine the builtin 'help'.\n    This is a wrapper around pydoc.help (with a twist).
hex hex(number) -> string\n\nReturn the hexadecimal representation of an integer or long integer.
id id(object) -> integer\n\nReturn the identity of an object.  This is guaranteed to be unique among\nsimultaneously existing objects.  (Hint: it's the object's memory address.)
input input([prompt]) -> value\n\nEquivalent to eval(raw_input(prompt)).
int int(x[, base]) -> integer\n\nConvert a string or number to an integer, if possible.  A floating point\nargument will be truncated towards zero (this does not include a string\nrepresentation of a floating point number!)  When converting a string, use\nthe optional base.  It is an error to supply a base when converting a\nnon-string.  If base is zero, the proper base is guessed based on the\nstring content.  If the argument is outside the integer range a\nlong object will be returned instead.
intern intern(string) -> string\n\n``Intern'' the given string.  This enters the string in the (global)\ntable of interned strings whose purpose is to speed up dictionary lookups.\nReturn the string itself or the previously interned string object with the\nsame value.
isinstance isinstance(object, class-or-type-or-tuple) -> bool\n\nReturn whether an object is an instance of a class or of a subclass thereof.\nWith a type as second argument, return whether that is the object's type.\nThe form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for\nisinstance(x, A) or isinstance(x, B) or ... (etc.).
issubclass issubclass(C, B) -> bool\n\nReturn whether class C is a subclass (i.e., a derived class) of class B.\nWhen using a tuple as the second argument issubclass(X, (A, B, ...)),\nis a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).
iter iter(collection) -> iterator\niter(callable, sentinel) -> iterator\n\nGet an iterator from an object.  In the first form, the argument must\nsupply its own iterator, or be a sequence.\nIn the second form, the callable is called until it returns the sentinel.
len len(object) -> integer\n\nReturn the number of items of a sequence or mapping.
license license()\ninteractive prompt objects for printing the license text, a list of\n    contributors and the copyright notice.
list list() -> new empty list\nlist(iterable) -> new list initialized from iterable's items
locals locals() -> dictionary\n\nUpdate and return a dictionary containing the current scope's local variables.
long long(x[, base]) -> integer\n\nConvert a string or number to a long integer, if possible.  A floating\npoint argument will be truncated towards zero (this does not include a\nstring representation of a floating point number!)  When converting a\nstring, use the optional base.  It is an error to supply a base when\nconverting a non-string.
map map(function, sequence[, sequence, ...]) -> list\n\nReturn a list of the results of applying the function to the items of\nthe argument sequence(s).  If more than one sequence is given, the\nfunction is called with an argument list consisting of the corresponding\nitem of each sequence, substituting None for missing values when not all\nsequences have the same length.  If the function is None, return a list of\nthe items of the sequence (or a list of tuples if more than one sequence).
max max(iterable[, key=func]) -> value\nmax(a, b, c, ...[, key=func]) -> value\n\nWith a single iterable argument, return its largest item.\nWith two or more arguments, return the largest argument.
memoryview memoryview(object)\n\nCreate a new memoryview object which references the given object.
min min(iterable[, key=func]) -> value\nmin(a, b, c, ...[, key=func]) -> value\n\nWith a single iterable argument, return its smallest item.\nWith two or more arguments, return the smallest argument.
next next(iterator[, default])\n\nReturn the next item from the iterator. If default is given and the iterator\nis exhausted, it is returned instead of raising StopIteration.
object object()\nThe most base type
oct oct(number) -> string\n\nReturn the octal representation of an integer or long integer.
open open(name[, mode[, buffering]]) -> file object\n\nOpen a file using the file() type, returns a file object.  This is the\npreferred way to open a file.  See file.__doc__ for further information.
ord ord(c) -> integer\n\nReturn the integer ordinal of a one-character string.
pow pow(x, y[, z]) -> number\n\nWith two arguments, equivalent to x**y.  With three arguments,\nequivalent to (x**y) % z, but may be more efficient (e.g. for longs).
print print(value, ..., sep=' ', end='\\n', file=sys.stdout)\n\nPrints the values to a stream, or to sys.stdout by default.\nOptional keyword arguments:\nfile: a file-like object (stream); defaults to the current sys.stdout.\nsep:  string inserted between values, default a space.\nend:  string appended after the last value, default a newline.
property property(fget=None, fset=None, fdel=None, doc=None) -> property attribute\n\nfget is a function to be used for getting an attribute value, and likewise\nfset is a function for setting, and fdel a function for del'ing, an\nattribute.  Typical use is to define a managed attribute x:\nclass C(object):\n    def getx(self): return self._x\n    def setx(self, value): self._x = value\n    def delx(self): del self._x\n    x = property(getx, setx, delx, "I'm the 'x' property.")\n\nDecorators make defining new properties or modifying existing ones easy:\nclass C(object):\n    @property\n    def x(self): return self._x\n    @x.setter\n    def x(self, value): self._x = value\n    @x.deleter\n    def x(self): del self._x
quit quit()\n
range range([start,] stop[, step]) -> list of integers\n\nReturn a list containing an arithmetic progression of integers.\nrange(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.\nWhen step is given, it specifies the increment (or decrement).\nFor example, range(4) returns [0, 1, 2, 3].  The end point is omitted!\nThese are exactly the valid indices for a list of 4 elements.
raw_input raw_input([prompt]) -> string\n\nRead a string from standard input.  The trailing newline is stripped.\nIf the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.\nOn Unix, GNU readline is used if enabled.  The prompt string, if given,\nis printed without a trailing newline before reading.
reduce reduce(function, sequence[, initial]) -> value\n\nApply a function of two arguments cumulatively to the items of a sequence,\nfrom left to right, so as to reduce the sequence to a single value.\nFor example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n((((1+2)+3)+4)+5).  If initial is present, it is placed before the items\nof the sequence in the calculation, and serves as a default when the\nsequence is empty.
reload reload(module) -> module\n\nReload the module.  The module must have been successfully imported before.
repr repr(object) -> string\n\nReturn the canonical string representation of the object.\nFor most object types, eval(repr(object)) == object.
reversed reversed(sequence) -> reverse iterator over values of the sequence\n\nReturn a reverse iterator
round round(number[, ndigits]) -> floating point number\n\nRound a number to a given precision in decimal digits (default 0 digits).\nThis always returns a floating point number.  Precision may be negative.
set set() -> new empty set object\nset(iterable) -> new set object\n\nBuild an unordered collection of unique elements.
setattr setattr(object, name, value)\n\nSet a named attribute on an object; setattr(x, 'y', v) is equivalent to\n``x.y = v''.
slice slice([start,] stop[, step])\n\nCreate a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
sorted sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
staticmethod staticmethod(function) -> method\n\nConvert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n     class C:\n     def f(arg1, arg2, ...): ...\n     f = staticmethod(f)\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()).  The instance is ignored except for its class.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin.
str str(object) -> string\n\nReturn a nice string representation of the object.\nIf the argument is a string, the return value is the same object.
sum sum(sequence[, start]) -> value\n\nReturns the sum of a sequence of numbers (NOT strings) plus the value\nof parameter 'start' (which defaults to 0).  When the sequence is\nempty, returns start.
super super(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n    def meth(self, arg):\n        super(C, self).meth(arg)
tuple tuple() -> empty tuple\ntuple(iterable) -> tuple initialized from iterable's items\n\nIf the argument is a tuple, the return value is the same object.
type type(object) -> the object's type\ntype(name, bases, dict) -> a new type
unichr unichr(i) -> Unicode character\n\nReturn a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
unicode unicode(string [, encoding[, errors]]) -> object\n\nCreate a new Unicode object from the given encoded string.\nencoding defaults to the current default string encoding.\nerrors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.
vars vars([object]) -> dictionary\n\nWithout arguments, equivalent to locals().\nWith an argument, equivalent to object.__dict__.
xrange xrange([start,] stop[, step]) -> xrange object\n\nLike range(), but instead of returning a list, returns an object that\ngenerates the numbers in the range on demand.  For looping, this is \nslightly faster than range() and more memory efficient.
zip zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]\n\nReturn a list of tuples, where each tuple contains the i-th element\nfrom each of the argument sequences.  The returned list is truncated\nin length to the length of the shortest argument sequence.