 |  |  | Python Library Reference |  |  |  |
| | | Python Library Reference | | | |
The Python interpreter has a number of functions built into it thatare always available. They are listed here in alphabetical order.
For example, the statement "import spam" results in the following call:__import__('spam',globals(),locals(), []); the statement "from spam.ham import eggs" results in "__import__('spam.ham', globals(), locals(), ['eggs'])". Note that even thoughlocals() and['eggs'] are passed in as arguments, the__import__() function does not set the local variable namedeggs; this is done by subsequent code that is generated for the import statement. (In fact, the standard implementation does not use itslocals argument at all, and uses itsglobals only to determine the package context of theimport statement.)
When thename variable is of the formpackage.module, normally, the top-level package (the name up till the first dot) is returned,not the module named byname. However, when a non-emptyfromlist argument is given, the module named byname is returned. This is done for compatibility with the bytecode generated for the different kinds of import statement; when using "import spam.ham.eggs", the top-level packagespam must be placed in the importing namespace, but when using "from spam.ham import eggs", thespam.ham subpackage must be used to find theeggs variable. As a workaround for this behavior, usegetattr() to extract the desired components. For example, you could define the following helper:
import stringdef my_import(name): mod = __import__(name) components = string.split(name, '.') for comp in components[1:]: mod = getattr(mod, comp) return mod
function(args), since in that case there is always exactly one argument. The use ofapply() is equivalent tofunction(*args, **keywords). Use ofapply() is not necessary since the ``extended call syntax,'' as used in the last example, is completely equivalent.x is false, this returnsFalse; otherwise it returnsTrue.bool is also a class, which is a subclass ofint. Classbool cannot be subclassed further. Its only instances areFalse andTrue. New in version 2.2.1.chr(97) returns the string'a'. This is the inverse oford(). The argument must be in the range [0..255], inclusive;ValueError will be raised ifi is outside that range.A class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom:
class C: def f(cls, arg1, arg2, ...): ... f = classmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.
Class methods are different than C++ or Java static methods. If you want those, see
x <y, zero ifx ==y and strictly positive ifx >y.'<string>' is commonly used). Thekind argument specifies what kind of code must be compiled; it can be'exec' ifstring consists of a sequence of statements,'eval' if it consists of a single expression, or'single' if it consists of a single interactive statement (in the latter case, expression statements that evaluate to something else thanNone will printed).When compiling multi-line statements, two caveats apply: line endings must be represented by a single newline character ('\n'), and the input must be terminated by at least one newline character. If line endings are represented by'\r\n', use the stringreplace() method to change them into'\n'.
The optional argumentsflags anddont_inherit (which are new in Python 2.2) control which future statements (seePEP 236) affect the compilation ofstring. If neither is present (or both are zero) the code is compiled with those future statements that are in effect in the code that is calling compile. If theflags argument is given anddont_inherit is not (or is zero) then the future statements specified by theflags argument are used in addition to those that would be used anyway. Ifdont_inherit is a non-zero integer then theflags argument is it - the future statements in effect around the call to compile are ignored.
Future statemants are specified by bits which can be bitwise or-ed together to specify multiple statements. The bitfield required to specify a given feature can be found as thecompiler_flag attribute on the_Feature instance in the__future__ module.
delattr(x, 'foobar') is equivalent todelx.foobar.{1: 2, 2: 3}:dict({1: 2, 2: 3})dict({1: 2, 2: 3}.items())dict({1: 2, 2: 3}.iteritems())dict(zip((1, 2), (2, 3)))dict([[2, 3], [1, 2]])dict([(i-1, i) for i in (2, 3)])New in version 2.2.
>>> import struct>>> dir()['__builtins__', '__doc__', '__name__', 'struct']>>> dir(struct)['__doc__', '__name__', 'calcsize', 'error', 'pack', 'unpack']
Note:Becausedir() is supplied primarily as a convenience for use at an interactive prompt, it tries to supply an interesting set of names more than it tries to supply a rigorously or consistently defined set of names, and its detailed behavior may change across releases.
(a /b,a %b). For floating point numbers the result is(q,a %b), whereq is usuallymath.floor(a /b) but may be 1 less than that. In any caseq *b +a %b is very close toa, ifa %b is non-zero it has the same sign asb, and0 <= abs(a %b) < abs(b).Changed in version 2.3:Usingdivmod() with complex numbers is deprecated.
>>> x = 1>>> print eval('x+1')2This function can also be used to execute arbitrary code objects (such as those created bycompile()). In this case pass a code object instead of a string. The code object must have been compiled passing'eval' as thekind argument.
Hints: dynamic execution of statements is supported by theexec statement. Execution of statements from a file is supported by theexecfile() function. Theglobals() andlocals() functions returns the current global and local dictionary, respectively, which may be useful to pass around for use byeval() orexecfile().
The arguments are a file name and two optional dictionaries. The file is parsed and evaluated as a sequence of Python statements (similarly to a module) using theglobals andlocals dictionaries as global and local namespace. If thelocals dictionary is omitted it defaults to theglobals dictionary. If both dictionaries are omitted, the expression is executed in the environment whereexecfile() is called. The return value isNone.
Warning:The defaultlocals act as described for functionlocals() below: modifications to the defaultlocals dictionary should not be attempted. Pass an explicitlocals dictionary if you need to see effects of the code onlocals after functionexecfile() returns.execfile() cannot be used reliably to modify a function's locals.
stdio'sfopen():filename is the file name to be opened,mode indicates how the file is to be opened:'r' for reading,'w' for writing (truncating an existing file), and'a' opens it for appending (which onsome Unix systems means thatall writes append to the end of the file, regardless of the current seek position).Modes'r+','w+' and'a+' open the file for updating (note that'w+' truncates the file). Append'b' to the mode to open the file in binary mode, on systems that differentiate between binary and text files (else it is ignored). If the file cannot be opened,IOError is raised.
Ifmode is omitted, it defaults to'r'. When opening a binary file, you should append'b' to themode value for improved portability. (It's useful even on systems which don't treat binary and text files differently, where it serves as documentation.) The optionalbufsize argument specifies the file's desired buffer size: 0 means unbuffered, 1 means line buffered, any other positive value means use a buffer of (approximately) that size. A negativebufsize means to use the system default, which is usually line buffered for for tty devices and fully buffered for other files. If omitted, the system default is used.2.3
Thefile() constructor is new in Python 2.2. The previous spelling,open(), is retained for compatibility, and is an alias forfile().
None, the identity function is assumed, that is, all elements oflist that are false (zero or empty) are removed.string.atof(x). Otherwise, the argument may be a plain or long integer or a floating point number, and a floating point number with the same value (within Python's floating point precision) is returned.Note:When passing in a string, values for NaN and Infinity may be returned, depending on the underlying C library. The specific set of strings accepted which cause these values to be returned depends entirely on the C library and is known to vary.
getattr(x, 'foobar') is equivalent tox.foobar. If the named attribute does not exist,default is returned if provided, otherwiseAttributeError is raised.getattr(object,name) and seeing whether it raises an exception or not.)hex(-1) yields'0xffffffff'. When evaluated on a machine with the same word size, this literal is evaluated as -1; at a different word size, it may turn up as a large positive number or raise anOverflowError exception.eval(raw_input(prompt)).Warning:This function is not safe from user errors! It expects a valid Python expression as input; if the input is not syntactically valid, aSyntaxError will be raised. Other exceptions may be raised if there is an error during evaluation. (On the other hand, sometimes this is exactly what you need when writing a quick script for expert use.)If thereadline module was loaded, theninput() will use it to provide elaborate line editing and history features.
Consider using theraw_input() function for general input from users.
string.atoi(x[,radix]). Theradix parameter gives the base for the conversion and may be any integer in the range [2, 36], or zero. Ifradix is zero, the proper radix is guessed based on the contents of string; the interpretation is the same as for integer literals. Ifradix is specified andx is not a string,TypeError is raised. Otherwise, the argument may be a plain or long integer or a floating point number. Conversion of floating point numbers to integers truncates (towards zero).0). If it does not support either of those protocols,TypeError is raised. If the second argument,sentinel, is given, theno must be a callable object. The iterator created in this case will callo with no arguments for each call to itsnext() method; if the value returned is equal tosentinel,StopIteration will be raised, otherwise the value will be returned.New in version 2.2.sequence[:]. For instance,list('abc') returns['a', 'b', 'c'] andlist( (1, 2, 3) ) returns[1, 2, 3].string.atol(x). Theradix argument is interpreted in the same way as forint(), and may only be given whenx is a string. Otherwise, the argument may be a plain or long integer or a floating point number, and a long integer with the same value is returned. Conversion of floating point numbers to integers truncates (towards zero).None items. Iffunction isNone, the identity function is assumed; if there are multiple list arguments,map() returns a list consisting of tuples containing the corresponding items from all lists (a kind of transpose operation). Thelist arguments may be any kind of sequence; the result is always a list.oct(-1) yields'037777777777'. When evaluated on a machine with the same word size, this literal is evaluated as -1; at a different word size, it may turn up as a large positive number or raise anOverflowError exception.ord('a') returns the integer97,ord(u'
u2020') returns8224. This is the inverse ofchr() for strings and ofunichr() for Unicode characters.pow(x,y) %z). The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int and long int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example,10**2 returns100, but10**-2 returns0.01. (This last feature was added in Python 2.2. In Python 2.1 and before, if both arguments were of integer types and the second argument was negative, an exception was raised.) If the second argument is negative, the third argument must be omitted. Ifz is present,x andy must be of integer types, andy must be non-negative. (This restriction was added in Python 2.2. In Python 2.1 and before, floating 3-argumentpow() returned platform-dependent results depending on floating-point rounding accidents.)fget is a function for getting an attribute value, likewisefset is a function for setting, andfdel a function for del'ing, an attribute. Typical use is to define a managed attribute x:
class C(object): def getx(self): return self.__x def setx(self, value): self.__x = value def delx(self): del self.__x x = property(getx, setx, delx, "I'm the 'x' property.")
New in version 2.2.
1. If thestart argument is omitted, it defaults to0. The full form returns a list of plain integers[start,start +step,start + 2 *step, ...]. Ifstep is positive, the last element is the largeststart +i *step less thanstop; ifstep is negative, the last element is the largeststart +i *step greater thanstop.step must not be zero (or elseValueError is raised). Example:>>> range(10)[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> range(1, 11)[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> range(0, 30, 5)[0, 5, 10, 15, 20, 25]>>> range(0, 10, 3)[0, 3, 6, 9]>>> range(0, -10, -1)[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]>>> range(0)[]>>> range(1, 0)[]
>>> s = raw_input('--> ')--> Monty Python's Flying Circus>>> s"Monty Python's Flying Circus"If thereadline module was loaded, thenraw_input() will use it to provide elaborate line editing and history features.
reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates((((1+2)+3)+4)+5). If the optionalinitializer is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty. Ifinitializer is not given andsequence contains only one item, the first item is returned.There are a number of caveats:
If a module is syntactically correct but its initialization fails, the firstimport statement for it does not bind its name locally, but does store a (partially initialized) module object insys.modules. To reload the module you must firstimport it again (this will bind the name to the partially initialized module object) before you canreload() it.
When a module is reloaded, its dictionary (containing the module's global variables) is retained. Redefinitions of names will override the old definitions, so this is generally not a problem. If the new version of a module does not define a name that was defined by the old version, the old definition remains. This feature can be used to the module's advantage if it maintains a global table or cache of objects -- with atry statement it can test for the table's presence and skip its initialization if desired.
It is legal though generally not very useful to reload built-in or dynamically loaded modules, except forsys,__main__ and__builtin__. In many cases, however, extension modules are not designed to be initialized more than once, and may fail in arbitrary ways when reloaded.
If a module imports objects from another module usingfrom ...import ..., callingreload() for the other module does not redefine the objects imported from it -- one way around this is to re-execute thefrom statement, another is to useimport and qualified names (module.name) instead.
If a module instantiates instances of a class, reloading the module that defines the class does not affect the method definitions of the instances -- they continue to use the old class definition. The same is true for derived classes.
round(0.5) is1.0 andround(-0.5) is-1.0).setattr(x, 'foobar', 123) is equivalent tox.foobar = 123.range(start,stop,step). Thestart andstep arguments default to None. Slice objects have read-only data attributesstart,stop andstep which merely return the argument values (or their default). They have no other explicit functionality; however they are used by Numerical Python and other third party extensions. Slice objects are also generated when extended indexing syntax is used. For example: "a[start:stop:step]" or "a[start:stop, i]".A static method does not receive an implicit first argument. To declare a static method, use this idiom:
class C: def f(arg1, arg2, ...): ... f = staticmethod(f)
It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class.
Static methods in Python are similar to those found in Java or C++. For a more advanced concept, see
A typical use for calling a cooperative superclass method is:
class C(B): def meth(self, arg): super(C, self).meth(arg)
repr(object) is thatstr(object) does not always attempt to return a string that is acceptable toeval(); its goal is to return a printable string.tuple('abc') returns returns('a', 'b', 'c') andtuple([1, 2, 3]) returns(1, 2, 3).>>> import types>>> x = 'abc'>>> if type(x) is str: print "It's a string"...It's a string>>> def f(): pass...>>> if type(f) is types.FunctionType: print "It's a function"...It's a function
Theisinstance() built-in function is recommended for testing the type of an object.
unichr(97) returns the stringu'a'. This is the inverse oford() for Unicode strings. The argument must be in the range [0..65535], inclusive.ValueError is raised otherwise.New in version 2.0.Ifencoding and/orerrors are given,unicode() will decode the object which can either be an 8-bit string or a character buffer using the codec forencoding. Theencoding parameter is a string giving the name of an encoding; if the encoding is not known,LookupError is raised. Error handling is done according toerrors; this specifies the treatment of characters which are invalid in the input encoding. Iferrors is'strict' (the default), aValueError is raised on errors, while a value of'ignore' causes errors to be silently ignored, and a value of'replace' causes the official Unicode replacement character,U+FFFD, to be used to replace input characters which cannot be decoded. See also thecodecs module.
If no optional parameters are given,unicode() will mimic the behaviour ofstr() except that it returns Unicode strings instead of 8-bit strings. More precisely, ifobject is a Unicode string or subclass it will return that Unicode string without any additional decoding applied.
For objects which provide a__unicode__() method, it will call this method without arguments to create a Unicode string. For all other objects, the 8-bit string version or representation is requested and then converted to a Unicode string using the codec for the default encoding in'strict' mode.
New in version 2.0.Changed in version 2.2:Support for__unicode__() added.
None. With a single sequence argument, it returns a list of 1-tuples.New in version 2.0. | | | Python Library Reference | | | |