Built-in Functions¶

The Python interpreter has a number of functions and types built into it thatare always available. They are listed here in alphabetical order.

Built-in Functions
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()`	E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()`	R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(x)¶: Return the absolute value of a number. The argument may be aninteger, a floating-point number, or an object implementing__abs__().If the argument is a complex number, its magnitude is returned.

aiter(async_iterable)¶

Return anasynchronous iterator for anasynchronous iterable.Equivalent to callingx.__aiter__().

Note: Unlikeiter(),aiter() has no 2-argument variant.

Added in version 3.10.

all(iterable)¶

ReturnTrue if all elements of theiterable are true (or if the iterableis empty). Equivalent to:

defall(iterable):forelementiniterable:ifnotelement:returnFalsereturnTrue

awaitableanext(async_iterator)¶

awaitableanext(async_iterator,default)

When awaited, return the next item from the givenasynchronousiterator, ordefault if given and the iterator is exhausted.

This is the async variant of thenext() builtin, and behavessimilarly.

This calls the__anext__() method ofasync_iterator,returning anawaitable. Awaiting this returns the next value of theiterator. Ifdefault is given, it is returned if the iterator is exhausted,otherwiseStopAsyncIteration is raised.

Added in version 3.10.

any(iterable)¶

ReturnTrue if any element of theiterable is true. If the iterableis empty, returnFalse. Equivalent to:

defany(iterable):forelementiniterable:ifelement:returnTruereturnFalse

ascii(object)¶: Asrepr(), return a string containing a printable representation of anobject, but escape the non-ASCII characters in the string returned byrepr() using\x,\u, or\U escapes. This generates a stringsimilar to that returned byrepr() in Python 2.

bin(x)¶

Convert an integer number to a binary string prefixed with “0b”. The resultis a valid Python expression. Ifx is not a Pythonint object, ithas to define an__index__() method that returns an integer. Someexamples:

>>>bin(3)'0b11'>>>bin(-10)'-0b1010'

If the prefix “0b” is desired or not, you can use either of the following ways.

>>>format(14,'#b'),format(14,'b')('0b1110', '1110')>>>f'{14:#b}',f'{14:b}'('0b1110', '1110')

See alsoformat() for more information.

classbool(object=False,/)¶: Return a Boolean value, i.e. one ofTrue orFalse. The argumentis converted using the standardtruth testing procedure.If the argument is falseor omitted, this returnsFalse; otherwise, it returnsTrue. Thebool class is a subclass ofint (seeNumeric Types — int, float, complex).It cannot be subclassed further. Its only instances areFalse andTrue (seeBoolean Type - bool).
Changed in version 3.7:The parameter is now positional-only.

breakpoint(*args,**kws)¶

This function drops you into the debugger at the call site. Specifically,it callssys.breakpointhook(), passingargs andkws straightthrough. By default,sys.breakpointhook() callspdb.set_trace() expecting no arguments. In this case, it ispurely a convenience function so you don’t have to explicitly importpdb or type as much code to enter the debugger. However,sys.breakpointhook() can be set to some other function andbreakpoint() will automatically call that, allowing you to drop intothe debugger of choice.Ifsys.breakpointhook() is not accessible, this function willraiseRuntimeError.

By default, the behavior ofbreakpoint() can be changed withthePYTHONBREAKPOINT environment variable.Seesys.breakpointhook() for usage details.

Note that this is not guaranteed ifsys.breakpointhook()has been replaced.

Raises anauditing eventbuiltins.breakpoint with argumentbreakpointhook.

Added in version 3.7.

classbytearray(source=b'')

classbytearray(source,encoding)

classbytearray(source,encoding,errors)

Return a new array of bytes. Thebytearray class is a mutablesequence of integers in the range 0 <= x < 256. It has most of the usualmethods of mutable sequences, described inMutable Sequence Types, as wellas most methods that thebytes type has, seeBytes and Bytearray Operations.

The optionalsource parameter can be used to initialize the array in a fewdifferent ways:

If it is astring, you must also give theencoding (and optionally,errors) parameters;bytearray() then converts the string tobytes usingstr.encode().
If it is aninteger, the array will have that size and will beinitialized with null bytes.
If it is an object conforming to thebuffer interface,a read-only buffer of the object will be used to initialize the bytes array.
If it is aniterable, it must be an iterable of integers in the range0<=x<256, which are used as the initial contents of the array.

Without an argument, an array of size 0 is created.

classbytes(source=b'')

classbytes(source,encoding)

classbytes(source,encoding,errors)

Return a new “bytes” object which is an immutable sequence of integers inthe range0<=x<256.bytes is an immutable version ofbytearray – it has the same non-mutating methods and the sameindexing and slicing behavior.

Accordingly, constructor arguments are interpreted as forbytearray().

Bytes objects can also be created with literals, seeString and Bytes literals.

callable(object)¶: ReturnTrue if theobject argument appears callable,False if not. If this returnsTrue, it is still possible that acall fails, but if it isFalse, callingobject will never succeed.Note that classes are callable (calling a class returns a new instance);instances are callable if their class has a__call__() method.
Added in version 3.2:This function was first removed in Python 3.0 and then brought backin Python 3.2.

chr(i)¶

Return the string representing a character whose Unicode code point is theintegeri. For example,chr(97) returns the string'a', whilechr(8364) returns the string'€'. This is the inverse oford().

The valid range for the argument is from 0 through 1,114,111 (0x10FFFF inbase 16).ValueError will be raised ifi is outside that range.

@classmethod¶

Transform a method into a class method.

A class method receives the class as an implicit first argument, just like aninstance method receives the instance. To declare a class method, use thisidiom:

classC:@classmethoddeff(cls,arg1,arg2):...

The@classmethod form is a functiondecorator – seeFunction definitions for details.

A class method can be called either on the class (such asC.f()) or on an instance (suchasC().f()). The instance is ignored except for its class. If a classmethod is called for a derived class, the derived class object is passed as theimplied first argument.

Class methods are different than C++ or Java static methods. If you want those,seestaticmethod() in this section.For more information on class methods, seeThe standard type hierarchy.

Changed in version 3.9:Class methods can now wrap otherdescriptors such asproperty().

Changed in version 3.10:Class methods now inherit the method attributes(__module__,__name__,__qualname__,__doc__ and__annotations__) and have a new__wrapped__attribute.

Deprecated since version 3.11, removed in version 3.13:Class methods can no longer wrap otherdescriptors such asproperty().

compile(source,filename,mode,flags=0,dont_inherit=False,optimize=-1)¶

Compile thesource into a code or AST object. Code objects can be executedbyexec() oreval().source can either be a normal string, abyte string, or an AST object. Refer to theast module documentationfor information on how to work with AST objects.

Thefilename argument should give the file from which the code was read;pass some recognizable value if it wasn’t read from a file ('<string>' iscommonly used).

Themode argument specifies what kind of code must be compiled; it can be'exec' ifsource consists of a sequence of statements,'eval' if itconsists of a single expression, or'single' if it consists of a singleinteractive statement (in the latter case, expression statements thatevaluate to something other thanNone will be printed).

The optional argumentsflags anddont_inherit control whichcompiler options should be activatedand whichfuture features should be allowed. If neitheris present (or both are zero) the code is compiled with the same flags thataffect the code that is callingcompile(). If theflagsargument is given anddont_inherit is not (or is zero) then the compileroptions and the future statements specified by theflags argument are usedin addition to those that would be used anyway. Ifdont_inherit is anon-zero integer then theflags argument is it – the flags (futurefeatures and compiler options) in the surrounding code are ignored.

Compiler options and future statements are specified by bits which can bebitwise ORed together to specify multiple options. The bitfield required tospecify a given future feature can be found as thecompiler_flag attribute on the_Feature instance in the__future__ module.Compiler flags can be found inastmodule, withPyCF_ prefix.

The argumentoptimize specifies the optimization level of the compiler; thedefault value of-1 selects the optimization level of the interpreter asgiven by-O options. Explicit levels are0 (no optimization;__debug__ is true),1 (asserts are removed,__debug__ is false)or2 (docstrings are removed too).

This function raisesSyntaxError if the compiled source is invalid,andValueError if the source contains null bytes.

If you want to parse Python code into its AST representation, seeast.parse().

Raises anauditing eventcompile with argumentssource andfilename. This event may also be raised by implicitcompilation.

Note

When compiling a string with multi-line code in'single' or'eval' mode, input must be terminated by at least one newlinecharacter. This is to facilitate detection of incomplete and completestatements in thecode module.

Warning

It is possible to crash the Python interpreter with asufficiently large/complex string when compiling to an ASTobject due to stack depth limitations in Python’s AST compiler.

Changed in version 3.2:Allowed use of Windows and Mac newlines. Also, input in'exec' modedoes not have to end in a newline anymore. Added theoptimize parameter.

Changed in version 3.5:Previously,TypeError was raised when null bytes were encounteredinsource.

Added in version 3.8:ast.PyCF_ALLOW_TOP_LEVEL_AWAIT can now be passed in flags to enablesupport for top-levelawait,asyncfor, andasyncwith.

classcomplex(number=0,/)¶

classcomplex(string,/)

classcomplex(real=0,imag=0)

Convert a single string or number to a complex number, or create acomplex number from real and imaginary parts.

Examples:

>>>complex('+1.23')(1.23+0j)>>>complex('-4.5j')-4.5j>>>complex('-1.23+4.5j')(-1.23+4.5j)>>>complex('\t( -1.23+4.5J )\n')(-1.23+4.5j)>>>complex('-Infinity+NaNj')(-inf+nanj)>>>complex(1.23)(1.23+0j)>>>complex(imag=-4.5)-4.5j>>>complex(-1.23,4.5)(-1.23+4.5j)

If the argument is a string, it must contain either a real part (in thesame format as for float()) or an imaginary part (in the sameformat but with a'j' or'J' suffix), or both real and imaginaryparts (the sign of the imaginary part is mandatory in this case).The string can optionally be surrounded by whitespaces and the roundparentheses'(' and')', which are ignored.The string must not contain whitespace between'+','-', the'j' or'J' suffix, and the decimal number.For example,complex('1+2j') is fine, butcomplex('1+2j') raisesValueError.More precisely, the input must conform to thecomplexvalueproduction rule in the following grammar, after parentheses and leading andtrailing whitespace characters are removed:

complexvalue ::=floatvalue |floatvalue ("j" | "J") |floatvaluesignabsfloatvalue ("j" | "J")

If the argument is a number, the constructor serves as a numericconversion likeint andfloat.For a general Python objectx,complex(x) delegates tox.__complex__().If__complex__() is not defined then it falls backto__float__().If__float__() is not defined then it falls backto__index__().

If two arguments are provided or keyword arguments are used, each argumentmay be any numeric type (including complex).If both arguments are real numbers, return a complex number with the realcomponentreal and the imaginary componentimag.If both arguments are complex numbers, return a complex number with the realcomponentreal.real-imag.imag and the imaginary componentreal.imag+imag.real.If one of arguments is a real number, only its real component is used inthe above expressions.

If all arguments are omitted, returns0j.

The complex type is described inNumeric Types — int, float, complex.

Changed in version 3.6:Grouping digits with underscores as in code literals is allowed.

Changed in version 3.8:Falls back to__index__() if__complex__() and__float__() are not defined.

delattr(object,name)¶: This is a relative ofsetattr(). The arguments are an object and astring. The string must be the name of one of the object’s attributes. Thefunction deletes the named attribute, provided the object allows it. Forexample,delattr(x,'foobar') is equivalent todelx.foobar.name need not be a Python identifier (seesetattr()).

classdict(**kwarg)

classdict(mapping,**kwarg)

classdict(iterable,**kwarg)

Create a new dictionary. Thedict object is the dictionary class.Seedict andMapping Types — dict for documentation about this class.

For other containers see the built-inlist,set, andtuple classes, as well as thecollections module.

dir()¶

dir(object)

Without arguments, return the list of names in the current local scope. With anargument, attempt to return a list of valid attributes for that object.

If the object has a method named__dir__(),this method will be called andmust return the list of attributes. This allows objects that implement a custom__getattr__() or__getattribute__() functionto customize the waydir() reports their attributes.

If the object does not provide__dir__(),the function tries its best to gather information from the object’s__dict__ attribute, if defined, andfrom its type object. The resulting list is not necessarily complete and maybe inaccurate when the object has a custom__getattr__().

The defaultdir() mechanism behaves differently with different types ofobjects, as it attempts to produce the most relevant, rather than complete,information:

If the object is a module object, the list contains the names of the module’sattributes.
If the object is a type or class object, the list contains the names of itsattributes, and recursively of the attributes of its bases.
Otherwise, the list contains the object’s attributes’ names, the names of itsclass’s attributes, and recursively of the attributes of its class’s baseclasses.

The resulting list is sorted alphabetically. For example:

>>>importstruct>>>dir()# show the names in the module namespace['__builtins__', '__name__', 'struct']>>>dir(struct)# show the names in the struct module['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from']>>>classShape:...def__dir__(self):...return['area','perimeter','location']...>>>s=Shape()>>>dir(s)['area', 'location', 'perimeter']

Note

Becausedir() is supplied primarily as a convenience for use at aninteractive prompt, it tries to supply an interesting set of names morethan it tries to supply a rigorously or consistently defined set of names,and its detailed behavior may change across releases. For example,metaclass attributes are not in the result list when the argument is aclass.

divmod(a,b)¶: Take two (non-complex) numbers as arguments and return a pair of numbersconsisting of their quotient and remainder when using integer division. Withmixed operand types, the rules for binary arithmetic operators apply. Forintegers, the result is the same as(a//b,a%b). For floating-pointnumbers 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 veryclose toa, ifa%b is non-zero it has the same sign asb, and0<=abs(a%b)<abs(b).

enumerate(iterable,start=0)¶

Return an enumerate object.iterable must be a sequence, aniterator, or some other object which supports iteration.The__next__() method of the iterator returned byenumerate() returns a tuple containing a count (fromstart whichdefaults to 0) and the values obtained from iterating overiterable.

>>>seasons=['Spring','Summer','Fall','Winter']>>>list(enumerate(seasons))[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]>>>list(enumerate(seasons,start=1))[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Equivalent to:

defenumerate(iterable,start=0):n=startforeleminiterable:yieldn,elemn+=1

eval(source,/,globals=None,locals=None)¶

Parameters:

source (str |code object) – A Python expression.
globals (dict |None) – The global namespace (default:None).
locals (mapping |None) – The local namespace (default:None).

Returns:

The result of the evaluated expression.

Raises:

Syntax errors are reported as exceptions.

Warning

This function executes arbitrary code. Calling it withuser-supplied input may lead to security vulnerabilities.

Theexpression argument is parsed and evaluated as a Python expression(technically speaking, a condition list) using theglobals andlocalsmappings as global and local namespace. If theglobals dictionary ispresent and does not contain a value for the key__builtins__, areference to the dictionary of the built-in modulebuiltins isinserted under that key beforeexpression is parsed. That way you cancontrol what builtins are available to the executed code by inserting yourown__builtins__ dictionary intoglobals before passing it toeval(). If thelocals mapping is omitted it defaults to theglobals dictionary. If both mappings are omitted, the expression isexecuted with theglobals andlocals in the environment whereeval() is called. Note,eval() will only have access to thenested scopes (non-locals) in the enclosingenvironment if they are already referenced in the scope that is callingeval() (e.g. via anonlocal statement).

Example:

>>>x=1>>>eval('x+1')2

This function can also be used to execute arbitrary code objects (such asthose created bycompile()). In this case, pass a code object insteadof a string. If the code object has been compiled with'exec' as themode argument,eval()'s return value will beNone.

Hints: dynamic execution of statements is supported by theexec()function. Theglobals() andlocals() functionsreturn the current global and local dictionary, respectively, which may beuseful to pass around for use byeval() orexec().

If the given source is a string, then leading and trailing spaces and tabsare stripped.

Seeast.literal_eval() for a function that can safely evaluate stringswith expressions containing only literals.

Raises anauditing eventexec with the code objectas the argument. Code compilation events may also be raised.

Changed in version 3.13:Theglobals andlocals arguments can now be passed as keywords.

Changed in version 3.13:The semantics of the defaultlocals namespace have been adjusted asdescribed for thelocals() builtin.

exec(source,/,globals=None,locals=None,*,closure=None)¶

Warning

This function executes arbitrary code. Calling it withuser-supplied input may lead to security vulnerabilities.

This function supports dynamic execution of Python code.source must beeither a string or a code object. If it is a string, the string is parsed asa suite of Python statements which is then executed (unless a syntax erroroccurs).[1] If it is a code object, it is simply executed. In all cases,the code that’s executed is expected to be valid as file input (see thesectionFile input in the Reference Manual). Be aware that thenonlocal,yield, andreturnstatements may not be used outside offunction definitions even within the context of code passed to theexec() function. The return value isNone.

In all cases, if the optional parts are omitted, the code is executed in thecurrent scope. If onlyglobals is provided, it must be a dictionary(and not a subclass of dictionary), whichwill be used for both the global and the local variables. Ifglobals andlocals are given, they are used for the global and local variables,respectively. If provided,locals can be any mapping object. Rememberthat at the module level, globals and locals are the same dictionary.

Note

Whenexec gets two separate objects asglobals andlocals, thecode will be executed as if it were embedded in a class definition. Thismeans functions and classes defined in the executed code will not be ableto access variables assigned at the top level (as the “top level”variables are treated as class variables in a class definition).

If theglobals dictionary does not contain a value for the key__builtins__, a reference to the dictionary of the built-in modulebuiltins is inserted under that key. That way you can control whatbuiltins are available to the executed code by inserting your own__builtins__ dictionary intoglobals before passing it toexec().

Theclosure argument specifies a closure–a tuple of cellvars.It’s only valid when theobject is a code object containingfree (closure) variables.The length of the tuple must exactly match the length of the code object’sco_freevars attribute.

Raises anauditing eventexec with the code objectas the argument. Code compilation events may also be raised.

Note

The built-in functionsglobals() andlocals() return the currentglobal and local namespace, respectively, which may be useful to pass aroundfor use as the second and third argument toexec().

Note

The defaultlocals act as described for functionlocals() below.Pass an explicitlocals dictionary if you need to see effects of thecode onlocals after functionexec() returns.

Changed in version 3.11:Added theclosure parameter.

Changed in version 3.13:Theglobals andlocals arguments can now be passed as keywords.

Changed in version 3.13:The semantics of the defaultlocals namespace have been adjusted asdescribed for thelocals() builtin.

filter(function,iterable)¶

Construct an iterator from those elements ofiterable for whichfunctionis true.iterable may be either a sequence, a container whichsupports iteration, or an iterator. Iffunction isNone, the identityfunction is assumed, that is, all elements ofiterable that are false areremoved.

Note thatfilter(function,iterable) is equivalent to the generatorexpression(itemforiteminiterableiffunction(item)) if function isnotNone and(itemforiteminiterableifitem) if function isNone.

Seeitertools.filterfalse() for the complementary function that returnselements ofiterable for whichfunction is false.

classfloat(number=0.0,/)¶

classfloat(string,/)

Return a floating-point number constructed from a number or a string.

Examples:

>>>float('+1.23')1.23>>>float('   -12345\n')-12345.0>>>float('1e-003')0.001>>>float('+1E6')1000000.0>>>float('-Infinity')-inf

If the argument is a string, it should contain a decimal number, optionallypreceded by a sign, and optionally embedded in whitespace. The optionalsign may be'+' or'-'; a'+' sign has no effect on the valueproduced. The argument may also be a string representing a NaN(not-a-number), or positive or negative infinity.More precisely, the input must conform to the floatvalueproduction rule in the following grammar, after leading and trailingwhitespace characters are removed:

sign          ::= "+" | "-"infinity      ::= "Infinity" | "inf"nan           ::= "nan"digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>digitpart     ::=digit (["_"]digit)*number        ::= [digitpart] "."digitpart |digitpart ["."]exponent      ::= ("e" | "E") [sign]digitpartfloatnumber   ::=number [exponent]absfloatvalue ::=floatnumber |infinity |nanfloatvalue    ::= [sign]absfloatvalue

Case is not significant, so, for example, “inf”, “Inf”, “INFINITY”, and“iNfINity” are all acceptable spellings for positive infinity.

Otherwise, if the argument is an integer or a floating-point number, afloating-point number with the same value (within Python’s floating-pointprecision) is returned. If the argument is outside the range of a Pythonfloat, anOverflowError will be raised.

For a general Python objectx,float(x) delegates tox.__float__(). If__float__() is not defined then it falls backto__index__().

If no argument is given,0.0 is returned.

The float type is described inNumeric Types — int, float, complex.

Changed in version 3.6:Grouping digits with underscores as in code literals is allowed.

Changed in version 3.7:The parameter is now positional-only.

Changed in version 3.8:Falls back to__index__() if__float__() is not defined.

format(value,format_spec='')¶

Convert avalue to a “formatted” representation, as controlled byformat_spec. The interpretation offormat_spec will depend on the typeof thevalue argument; however, there is a standard formatting syntax thatis used by most built-in types:Format Specification Mini-Language.

The defaultformat_spec is an empty string which usually gives the sameeffect as callingstr(value).

A call toformat(value,format_spec) is translated totype(value).__format__(value,format_spec) which bypasses the instancedictionary when searching for the value’s__format__() method.ATypeError exception is raised if the method search reachesobject and theformat_spec is non-empty, or if either theformat_spec or the return value are not strings.

Changed in version 3.4:object().__format__(format_spec) raisesTypeErrorifformat_spec is not an empty string.

classfrozenset(iterable=set())

Return a newfrozenset object, optionally with elements taken fromiterable.frozenset is a built-in class. Seefrozenset andSet Types — set, frozenset for documentation about this class.

For other containers see the built-inset,list,tuple, anddict classes, as well as thecollectionsmodule.

getattr(object,name)¶
getattr(object,name,default): Return the value of the named attribute ofobject.name must be a string.If the string is the name of one of the object’s attributes, the result is thevalue of that attribute. For example,getattr(x,'foobar') is equivalent tox.foobar. If the named attribute does not exist,default is returned ifprovided, otherwiseAttributeError is raised.name need not be a Python identifier (seesetattr()).
Note
Sinceprivate name mangling happens atcompilation time, one must manually mangle a private attribute’s(attributes with two leading underscores) name in order to retrieve it withgetattr().

globals()¶: Return the dictionary implementing the current module namespace. For code withinfunctions, this is set when the function is defined and remains the sameregardless of where the function is called.

hasattr(object,name)¶: The arguments are an object and a string. The result isTrue if thestring is the name of one of the object’s attributes,False if not. (Thisis implemented by callinggetattr(object,name) and seeing whether itraises anAttributeError or not.)

hash(object)¶: Return the hash value of the object (if it has one). Hash values areintegers. They are used to quickly compare dictionary keys during adictionary lookup. Numeric values that compare equal have the same hashvalue (even if they are of different types, as is the case for 1 and 1.0).
Note
For objects with custom__hash__() methods,note thathash()truncates the return value based on the bit width of the host machine.

help()¶

help(request)

Invoke the built-in help system. (This function is intended for interactiveuse.) If no argument is given, the interactive help system starts on theinterpreter console. If the argument is a string, then the string is looked upas the name of a module, function, class, method, keyword, or documentationtopic, and a help page is printed on the console. If the argument is any otherkind of object, a help page on the object is generated.

Note that if a slash(/) appears in the parameter list of a function wheninvokinghelp(), it means that the parameters prior to the slash arepositional-only. For more info, seethe FAQ entry on positional-only parameters.

This function is added to the built-in namespace by thesite module.

Changed in version 3.4:Changes topydoc andinspect mean that the reportedsignatures for callables are now more comprehensive and consistent.

hex(x)¶

Convert an integer number to a lowercase hexadecimal string prefixed with“0x”. Ifx is not a Pythonint object, it has to define an__index__() method that returns an integer. Some examples:

>>>hex(255)'0xff'>>>hex(-42)'-0x2a'

If you want to convert an integer number to an uppercase or lower hexadecimalstring with prefix or not, you can use either of the following ways:

>>>'%#x'%255,'%x'%255,'%X'%255('0xff', 'ff', 'FF')>>>format(255,'#x'),format(255,'x'),format(255,'X')('0xff', 'ff', 'FF')>>>f'{255:#x}',f'{255:x}',f'{255:X}'('0xff', 'ff', 'FF')

See alsoformat() for more information.

See alsoint() for converting a hexadecimal string to aninteger using a base of 16.

Note

To obtain a hexadecimal string representation for a float, use thefloat.hex() method.

id(object)¶

Return the “identity” of an object. This is an integer whichis guaranteed to be unique and constant for this object during its lifetime.Two objects with non-overlapping lifetimes may have the sameid()value.

CPython implementation detail: This is the address of the object in memory.

Raises anauditing eventbuiltins.id with argumentid.

input()¶

input(prompt)

If theprompt argument is present, it is written to standard output withouta trailing newline. The function then reads a line from input, converts itto a string (stripping a trailing newline), and returns that. When EOF isread,EOFError is raised. Example:

>>>s=input('--> ')--> Monty Python's Flying Circus>>>s"Monty Python's Flying Circus"

If thereadline module was loaded, theninput() will use itto provide elaborate line editing and history features.

Raises anauditing eventbuiltins.input withargumentprompt before reading input

Raises anauditing eventbuiltins.input/resultwith the result after successfully reading input.

classint(number=0,/)¶

classint(string,/,base=10)

Return an integer object constructed from a number or a string, or return0 if no arguments are given.

Examples:

>>>int(123.45)123>>>int('123')123>>>int('   -12_345\n')-12345>>>int('FACE',16)64206>>>int('0xface',0)64206>>>int('01110011',base=2)115

If the argument defines __int__(),int(x) returnsx.__int__(). If the argument defines__index__(),it returnsx.__index__(). If the argument defines__trunc__(),it returnsx.__trunc__().For floating-point numbers, this truncates towards zero.

If the argument is not a number or ifbase is given, then it must be a string,bytes, orbytearray instance representing an integerin radixbase. Optionally, the string can be preceded by+ or-(with no space in between), have leading zeros, be surrounded by whitespace,and have single underscores interspersed between digits.

A base-n integer string contains digits, each representing a value from 0 ton-1. The values 0–9 can be represented by any Unicode decimal digit. Thevalues 10–35 can be represented bya toz (orA toZ). Thedefaultbase is 10. The allowed bases are 0 and 2–36. Base-2, -8, and -16strings can be optionally prefixed with0b/0B,0o/0O, or0x/0X, as with integer literals in code. For base 0, the string isinterpreted in a similar way to aninteger literal in code,in that the actual base is 2, 8, 10, or 16 as determined by the prefix. Base0 also disallows leading zeros:int('010',0) is not legal, whileint('010') andint('010',8) are.

The integer type is described inNumeric Types — int, float, complex.

Changed in version 3.4:Ifbase is not an instance ofint and thebase object has abase.__index__ method, that method is calledto obtain an integer for the base. Previous versions usedbase.__int__ instead ofbase.__index__.

Changed in version 3.6:Grouping digits with underscores as in code literals is allowed.

Changed in version 3.7:The first parameter is now positional-only.

Changed in version 3.8:Falls back to__index__() if__int__() is not defined.

Changed in version 3.11:The delegation to__trunc__() is deprecated.

Changed in version 3.11:int string inputs and string representations can be limited tohelp avoid denial of service attacks. AValueError is raised whenthe limit is exceeded while converting a string to anint orwhen converting anint into a string would exceed the limit.See theinteger string conversion length limitation documentation.

isinstance(object,classinfo)¶: ReturnTrue if theobject argument is an instance of theclassinfoargument, or of a (direct, indirect, orvirtual) subclass thereof. Ifobject is notan object of the given type, the function always returnsFalse.Ifclassinfo is a tuple of type objects (or recursively, other suchtuples) or aUnion Type of multiple types, returnTrue ifobject is an instance of any of the types.Ifclassinfo is not a type or tuple of types and such tuples,aTypeError exception is raised.TypeError may not beraised for an invalid type if an earlier check succeeds.
Changed in version 3.10:classinfo can be aUnion Type.

issubclass(class,classinfo)¶: ReturnTrue ifclass is a subclass (direct, indirect, orvirtual) ofclassinfo. Aclass is considered a subclass of itself.classinfo may be a tuple of classobjects (or recursively, other such tuples)or aUnion Type, in which case returnTrue ifclass is asubclass of any entry inclassinfo. In any other case, aTypeErrorexception is raised.
Changed in version 3.10:classinfo can be aUnion Type.

iter(object)¶

iter(object,sentinel)

Return aniterator object. The first argument is interpreted verydifferently depending on the presence of the second argument. Without asecond argument,object must be a collection object which supports theiterable protocol (the__iter__() method),or it must supportthe sequence protocol (the__getitem__() method with integer argumentsstarting at0). If it does not support either of those protocols,TypeError is raised. If the second argument,sentinel, is given,thenobject must be a callable object. The iterator created in this casewill callobject with no arguments for each call to its__next__() method; if the value returned is equal tosentinel,StopIteration will be raised, otherwise the value willbe returned.

See alsoIterator Types.

One useful application of the second form ofiter() is to build ablock-reader. For example, reading fixed-width blocks from a binarydatabase file until the end of file is reached:

fromfunctoolsimportpartialwithopen('mydata.db','rb')asf:forblockiniter(partial(f.read,64),b''):process_block(block)

len(s)¶: Return the length (the number of items) of an object. The argument may be asequence (such as a string, bytes, tuple, list, or range) or a collection(such as a dictionary, set, or frozen set).
CPython implementation detail:len raisesOverflowError on lengths larger thansys.maxsize, such asrange(2**100).

classlist
classlist(iterable): Rather than being a function,list is actually a mutablesequence type, as documented inLists andSequence Types — list, tuple, range.

locals()¶

Return a mapping object representing the current local symbol table, withvariable names as the keys, and their currently bound references as thevalues.

At module scope, as well as when usingexec() oreval() witha single namespace, this function returns the same namespace asglobals().

At class scope, it returns the namespace that will be passed to themetaclass constructor.

When usingexec() oreval() with separate local and globalarguments, it returns the local namespace passed in to the function call.

In all of the above cases, each call tolocals() in a given frame ofexecution will return thesame mapping object. Changes made throughthe mapping object returned fromlocals() will be visible as assigned,reassigned, or deleted local variables, and assigning, reassigning, ordeleting local variables will immediately affect the contents of thereturned mapping object.

In anoptimized scope (including functions, generators, andcoroutines), each call tolocals() instead returns a fresh dictionarycontaining the current bindings of the function’s local variables and anynonlocal cell references. In this case, name binding changes made via thereturned dict arenot written back to the corresponding local variablesor nonlocal cell references, and assigning, reassigning, or deleting localvariables and nonlocal cell references doesnot affect the contentsof previously returned dictionaries.

Callinglocals() as part of a comprehension in a function, generator, orcoroutine is equivalent to calling it in the containing scope, except thatthe comprehension’s initialised iteration variables will be included. Inother scopes, it behaves as if the comprehension were running as a nestedfunction.

Callinglocals() as part of a generator expression is equivalent tocalling it in a nested generator function.

Changed in version 3.12:The behaviour oflocals() in a comprehension has been updated asdescribed inPEP 709.

Changed in version 3.13:As part ofPEP 667, the semantics of mutating the mapping objectsreturned from this function are now defined. The behavior inoptimized scopes is now as described above.Aside from being defined, the behaviour in other scopes remainsunchanged from previous versions.

map(function,iterable,*iterables)¶: Return an iterator that appliesfunction to every item ofiterable,yielding the results. If additionaliterables arguments are passed,function must take that many arguments and is applied to the items from alliterables in parallel. With multiple iterables, the iterator stops when theshortest iterable is exhausted. For cases where the function inputs arealready arranged into argument tuples, seeitertools.starmap().

max(iterable,*,key=None)¶

max(iterable,*,default,key=None)

max(arg1,arg2,*args,key=None)

Return the largest item in an iterable or the largest of two or morearguments.

If one positional argument is provided, it should be an iterable.The largest item in the iterable is returned. If two or more positionalarguments are provided, the largest of the positional arguments isreturned.

There are two optional keyword-only arguments. Thekey argument specifiesa one-argument ordering function like that used forlist.sort(). Thedefault argument specifies an object to return if the provided iterable isempty. If the iterable is empty anddefault is not provided, aValueError is raised.

If multiple items are maximal, the function returns the first oneencountered. This is consistent with other sort-stability preserving toolssuch assorted(iterable,key=keyfunc,reverse=True)[0] andheapq.nlargest(1,iterable,key=keyfunc).

Changed in version 3.4:Added thedefault keyword-only parameter.

Changed in version 3.8:Thekey can beNone.

classmemoryview(object): Return a “memory view” object created from the given argument. SeeMemory Views for more information.

min(iterable,*,key=None)¶

min(iterable,*,default,key=None)

min(arg1,arg2,*args,key=None)

Return the smallest item in an iterable or the smallest of two or morearguments.

If one positional argument is provided, it should be an iterable.The smallest item in the iterable is returned. If two or more positionalarguments are provided, the smallest of the positional arguments isreturned.

If multiple items are minimal, the function returns the first oneencountered. This is consistent with other sort-stability preserving toolssuch assorted(iterable,key=keyfunc)[0] andheapq.nsmallest(1,iterable,key=keyfunc).

Changed in version 3.4:Added thedefault keyword-only parameter.

Changed in version 3.8:Thekey can beNone.

next(iterator)¶
next(iterator,default): Retrieve the next item from theiterator by calling its__next__() method. Ifdefault is given, it is returnedif the iterator is exhausted, otherwiseStopIteration is raised.

classobject¶: This is the ultimate base class of all other classes. It has methodsthat are common to all instances of Python classes. When the constructoris called, it returns a new featureless object. The constructor does notaccept any arguments.
Note
object instances donot have__dict__attributes, so you can’t assign arbitrary attributes to an instance ofobject.

oct(x)¶

Convert an integer number to an octal string prefixed with “0o”. The resultis a valid Python expression. Ifx is not a Pythonint object, ithas to define an__index__() method that returns an integer. Forexample:

>>>oct(8)'0o10'>>>oct(-56)'-0o70'

If you want to convert an integer number to an octal string either with the prefix“0o” or not, you can use either of the following ways.

>>>'%#o'%10,'%o'%10('0o12', '12')>>>format(10,'#o'),format(10,'o')('0o12', '12')>>>f'{10:#o}',f'{10:o}'('0o12', '12')

See alsoformat() for more information.

open(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)¶

Openfile and return a correspondingfile object. If the filecannot be opened, anOSError is raised. SeeReading and Writing Files for more examples of how to use this function.

file is apath-like object giving the pathname (absolute orrelative to the current working directory) of the file to be opened or aninteger file descriptor of the file to be wrapped. (If a file descriptor isgiven, it is closed when the returned I/O object is closed unlessclosefdis set toFalse.)

mode is an optional string that specifies the mode in which the file isopened. It defaults to'r' which means open for reading in text mode.Other common values are'w' for writing (truncating the file if italready exists),'x' for exclusive creation, and'a' for appending(which onsome Unix systems, means thatall writes append to the end ofthe file regardless of the current seek position). In text mode, ifencoding is not specified the encoding used is platform-dependent:locale.getencoding() is called to get the current locale encoding.(For reading and writing raw bytes use binary mode and leaveencoding unspecified.) The available modes are:

Character	Meaning
`'r'`	open for reading (default)
`'w'`	open for writing, truncating the file first
`'x'`	open for exclusive creation, failing if the file already exists
`'a'`	open for writing, appending to the end of file if it exists
`'b'`	binary mode
`'t'`	text mode (default)
`'+'`	open for updating (reading and writing)

The default mode is'r' (open for reading text, a synonym of'rt').Modes'w+' and'w+b' open and truncate the file. Modes'r+'and'r+b' open the file with no truncation.

As mentioned in theOverview, Python distinguishes between binaryand text I/O. Files opened in binary mode (including'b' in themodeargument) return contents asbytes objects without any decoding. Intext mode (the default, or when't' is included in themode argument),the contents of the file are returned asstr, the bytes having beenfirst decoded using a platform-dependent encoding or using the specifiedencoding if given.

Note

Python doesn’t depend on the underlying operating system’s notion of textfiles; all the processing is done by Python itself, and is thereforeplatform-independent.

buffering is an optional integer used to set the buffering policy. Pass 0to switch buffering off (only allowed in binary mode), 1 to select linebuffering (only usable when writing in text mode), and an integer > 1 to indicate the sizein bytes of a fixed-size chunk buffer. Note that specifying a buffer size thisway applies for binary buffered I/O, butTextIOWrapper (i.e., files openedwithmode='r+') would have another buffering. To disable buffering inTextIOWrapper, consider using thewrite_through flag forio.TextIOWrapper.reconfigure(). When nobuffering argument isgiven, the default buffering policy works as follows:

Binary files are buffered in fixed-size chunks; the size of the buffer ischosen using a heuristic trying to determine the underlying device’s “blocksize” and falling back onio.DEFAULT_BUFFER_SIZE. On many systems,the buffer will typically be 4096 or 8192 bytes long.
“Interactive” text files (files for whichisatty()returnsTrue) use line buffering. Other text files use the policydescribed above for binary files.

encoding is the name of the encoding used to decode or encode the file.This should only be used in text mode. The default encoding is platformdependent (whateverlocale.getencoding() returns), but anytext encoding supported by Python can be used.See thecodecs module for the list of supported encodings.

errors is an optional string that specifies how encoding and decodingerrors are to be handled—this cannot be used in binary mode.A variety of standard error handlers are available(listed underError Handlers), though anyerror handling name that has been registered withcodecs.register_error() is also valid. The standard namesinclude:

'strict' to raise aValueError exception if there isan encoding error. The default value ofNone has the sameeffect.
'ignore' ignores errors. Note that ignoring encoding errorscan lead to data loss.
'replace' causes a replacement marker (such as'?') to be insertedwhere there is malformed data.
'surrogateescape' will represent any incorrect bytes as lowsurrogate code units ranging from U+DC80 to U+DCFF.These surrogate code units will then be turned back intothe same bytes when thesurrogateescape error handler is usedwhen writing data. This is useful for processing files in anunknown encoding.
'xmlcharrefreplace' is only supported when writing to a file.Characters not supported by the encoding are replaced with theappropriate XML character reference&#nnn;.
'backslashreplace' replaces malformed data by Python’s backslashedescape sequences.
'namereplace' (also only supported when writing)replaces unsupported characters with\N{...} escape sequences.

newline determines how to parse newline characters from the stream.It can beNone,'','\n','\r', and'\r\n'. It works as follows:

When reading input from the stream, ifnewline isNone, universalnewlines mode is enabled. Lines in the input can end in'\n','\r', or'\r\n', and these are translated into'\n' beforebeing returned to the caller. If it is'', universal newlines mode isenabled, but line endings are returned to the caller untranslated. If ithas any of the other legal values, input lines are only terminated by thegiven string, and the line ending is returned to the caller untranslated.
When writing output to the stream, ifnewline isNone, any'\n'characters written are translated to the system default line separator,os.linesep. Ifnewline is'' or'\n', no translationtakes place. Ifnewline is any of the other legal values, any'\n'characters written are translated to the given string.

Ifclosefd isFalse and a file descriptor rather than a filename wasgiven, the underlying file descriptor will be kept open when the file isclosed. If a filename is givenclosefd must beTrue (the default);otherwise, an error will be raised.

A custom opener can be used by passing a callable asopener. The underlyingfile descriptor for the file object is then obtained by callingopener with(file,flags).opener must return an open file descriptor (passingos.open asopener results in functionality similar to passingNone).

The newly created file isnon-inheritable.

The following example uses thedir_fd parameter of theos.open() function to open a file relative to a given directory:

>>>importos>>>dir_fd=os.open('somedir',os.O_RDONLY)>>>defopener(path,flags):...returnos.open(path,flags,dir_fd=dir_fd)...>>>withopen('spamspam.txt','w',opener=opener)asf:...print('This will be written to somedir/spamspam.txt',file=f)...>>>os.close(dir_fd)# don't leak a file descriptor

The type offile object returned by theopen() functiondepends on the mode. Whenopen() is used to open a file in a textmode ('w','r','wt','rt', etc.), it returns a subclass ofio.TextIOBase (specificallyio.TextIOWrapper). When usedto open a file in a binary mode with buffering, the returned class is asubclass ofio.BufferedIOBase. The exact class varies: in readbinary mode, it returns anio.BufferedReader; in write binary andappend binary modes, it returns anio.BufferedWriter, and inread/write mode, it returns anio.BufferedRandom. When buffering isdisabled, the raw stream, a subclass ofio.RawIOBase,io.FileIO, is returned.

See also the file handling modules, such asfileinput,io(whereopen() is declared),os,os.path,tempfile,andshutil.

Raises anauditing eventopen with argumentspath,mode,flags.

Themode andflags arguments may have been modified or inferred fromthe original call.

Changed in version 3.3:

Theopener parameter was added.
The'x' mode was added.
IOError used to be raised, it is now an alias ofOSError.
FileExistsError is now raised if the file opened in exclusivecreation mode ('x') already exists.

Changed in version 3.4:

The file is now non-inheritable.

Changed in version 3.5:

If the system call is interrupted and the signal handler does not raise anexception, the function now retries the system call instead of raising anInterruptedError exception (seePEP 475 for the rationale).
The'namereplace' error handler was added.

Changed in version 3.6:

Support added to accept objects implementingos.PathLike.
On Windows, opening a console buffer may return a subclass ofio.RawIOBase other thanio.FileIO.

Changed in version 3.11:The'U' mode has been removed.

ord(c)¶: Given a string representing one Unicode character, return an integerrepresenting the Unicode code point of that character. For example,ord('a') returns the integer97 andord('€') (Euro sign)returns8364. This is the inverse ofchr().

pow(base,exp,mod=None)¶

Returnbase to the powerexp; ifmod is present, returnbase to thepowerexp, modulomod (computed more efficiently thanpow(base,exp)%mod). The two-argument formpow(base,exp) isequivalent to using the power operator:base**exp.

The arguments must have numeric types. With mixed operand types, thecoercion rules for binary arithmetic operators apply. Forintoperands, the result has the same type as the operands (after coercion)unless the second argument is negative; in that case, all arguments areconverted to float and a float result is delivered. For example,pow(10,2)returns100, butpow(10,-2) returns0.01. For a negative base oftypeint orfloat and a non-integral exponent, a complexresult is delivered. For example,pow(-9,0.5) returns a value closeto3j. Whereas, for a negative base of typeint orfloatwith an integral exponent, a float result is delivered. For example,pow(-9,2.0) returns81.0.

Forint operandsbase andexp, ifmod is present,mod mustalso be of integer type andmod must be nonzero. Ifmod is present andexp is negative,base must be relatively prime tomod. In that case,pow(inv_base,-exp,mod) is returned, whereinv_base is an inverse tobase modulomod.

Here’s an example of computing an inverse for38 modulo97:

>>>pow(38,-1,mod=97)23>>>23*38%97==1True

Changed in version 3.8:Forint operands, the three-argument form ofpow now allowsthe second argument to be negative, permitting computation of modularinverses.

Changed in version 3.8:Allow keyword arguments. Formerly, only positional arguments weresupported.

print(*objects,sep='',end='\n',file=None,flush=False)¶

Printobjects to the text streamfile, separated bysep and followedbyend.sep,end,file, andflush, if present, must be given as keywordarguments.

All non-keyword arguments are converted to strings likestr() does andwritten to the stream, separated bysep and followed byend. Bothsepandend must be strings; they can also beNone, which means to use thedefault values. If noobjects are given,print() will just writeend.

Thefile argument must be an object with awrite(string) method; if itis not present orNone,sys.stdout will be used. Since printedarguments are converted to text strings,print() cannot be used withbinary mode file objects. For these, usefile.write(...) instead.

Output buffering is usually determined byfile.However, ifflush is true, the stream is forcibly flushed.

Changed in version 3.3:Added theflush keyword argument.

classproperty(fget=None,fset=None,fdel=None,doc=None)¶

Return a property attribute.

fget is a function for getting an attribute value.fset is a functionfor setting an attribute value.fdel is a function for deleting an attributevalue. Anddoc creates a docstring for the attribute.

A typical use is to define a managed attributex:

classC:def__init__(self):self._x=Nonedefgetx(self):returnself._xdefsetx(self,value):self._x=valuedefdelx(self):delself._xx=property(getx,setx,delx,"I'm the 'x' property.")

Ifc is an instance ofC,c.x will invoke the getter,c.x=value will invoke the setter, anddelc.x the deleter.

If given,doc will be the docstring of the property attribute. Otherwise, theproperty will copyfget’s docstring (if it exists). This makes it possible tocreate read-only properties easily usingproperty() as adecorator:

classParrot:def__init__(self):self._voltage=100000@propertydefvoltage(self):"""Get the current voltage."""returnself._voltage

The@property decorator turns thevoltage() method into a “getter”for a read-only attribute with the same name, and it sets the docstring forvoltage to “Get the current voltage.”

@getter¶

@setter¶

@deleter¶

A property object hasgetter,setter,anddeleter methods usable as decorators that create acopy of the property with the corresponding accessor function set to thedecorated function. This is best explained with an example:

classC:def__init__(self):self._x=None@propertydefx(self):"""I'm the 'x' property."""returnself._x@x.setterdefx(self,value):self._x=value@x.deleterdefx(self):delself._x

This code is exactly equivalent to the first example. Be sure to give theadditional functions the same name as the original property (x in thiscase.)

The returned property object also has the attributesfget,fset, andfdel corresponding to the constructor arguments.

Changed in version 3.5:The docstrings of property objects are now writeable.

__name__¶: Attribute holding the name of the property. The name of the propertycan be changed at runtime.
Added in version 3.13.

classrange(stop)
classrange(start,stop,step=1): Rather than being a function,range is actually an immutablesequence type, as documented inRanges andSequence Types — list, tuple, range.

repr(object)¶

Return a string containing a printable representation of an object. For manytypes, this function makes an attempt to return a string that would yield anobject with the same value when passed toeval(); otherwise, therepresentation is a string enclosed in angle brackets that contains the nameof the type of the object together with additional information oftenincluding the name and address of the object. A class can control what thisfunction returns for its instancesby defining a__repr__() method.Ifsys.displayhook() is not accessible, this function will raiseRuntimeError.

This class has a custom representation that can be evaluated:

classPerson:def__init__(self,name,age):self.name=nameself.age=agedef__repr__(self):returnf"Person('{self.name}',{self.age})"

reversed(seq)¶: Return a reverseiterator.seq must be an object which hasa__reversed__() method or supports the sequence protocol (the__len__() method and the__getitem__() methodwith integer arguments starting at0).

round(number,ndigits=None)¶

Returnnumber rounded tondigits precision after the decimalpoint. Ifndigits is omitted or isNone, it returns thenearest integer to its input.

For the built-in types supportinground(), values are rounded to theclosest multiple of 10 to the power minusndigits; if two multiples areequally close, rounding is done toward the even choice (so, for example,bothround(0.5) andround(-0.5) are0, andround(1.5) is2). Any integer value is valid forndigits (positive, zero, ornegative). The return value is an integer ifndigits is omitted orNone.Otherwise, the return value has the same type asnumber.

For a general Python objectnumber,round delegates tonumber.__round__.

Note

The behavior ofround() for floats can be surprising: for example,round(2.675,2) gives2.67 instead of the expected2.68.This is not a bug: it’s a result of the fact that most decimal fractionscan’t be represented exactly as a float. SeeFloating-Point Arithmetic: Issues and Limitations formore information.

classset

classset(iterable)

Return a newset object, optionally with elements taken fromiterable.set is a built-in class. Seeset andSet Types — set, frozenset for documentation about this class.

For other containers see the built-infrozenset,list,tuple, anddict classes, as well as thecollectionsmodule.

setattr(object,name,value)¶

This is the counterpart ofgetattr(). The arguments are an object, astring, and an arbitrary value. The string may name an existing attribute or anew attribute. The function assigns the value to the attribute, provided theobject allows it. For example,setattr(x,'foobar',123) is equivalent tox.foobar=123.

name need not be a Python identifier as defined inIdentifiers and keywordsunless the object chooses to enforce that, for example in a custom__getattribute__() or via__slots__.An attribute whose name is not an identifier will not be accessible usingthe dot notation, but is accessible throughgetattr() etc..

Note

Sinceprivate name mangling happens atcompilation time, one must manually mangle a private attribute’s(attributes with two leading underscores) name in order to set it withsetattr().

classslice(stop)¶

classslice(start,stop,step=None)

Return aslice object representing the set of indices specified byrange(start,stop,step). Thestart andstep arguments default toNone.

start¶

stop¶

step¶: Slice objects have read-only data attributesstart,stop, andstep which merely return the argumentvalues (or their default). They have no other explicit functionality;however, they are used by NumPy and other third-party packages.

Slice objects are also generated when extended indexing syntax is used. Forexample:a[start:stop:step] ora[start:stop,i]. Seeitertools.islice() for an alternate version that returns aniterator.

Changed in version 3.12:Slice objects are nowhashable (providedstart,stop, andstep are hashable).

sorted(iterable,/,*,key=None,reverse=False)¶

Return a new sorted list from the items initerable.

Has two optional arguments which must be specified as keyword arguments.

key specifies a function of one argument that is used to extract a comparisonkey from each element initerable (for example,key=str.lower). Thedefault value isNone (compare the elements directly).

reverse is a boolean value. If set toTrue, then the list elements aresorted as if each comparison were reversed.

Usefunctools.cmp_to_key() to convert an old-stylecmp function to akey function.

The built-insorted() function is guaranteed to be stable. A sort isstable if it guarantees not to change the relative order of elements thatcompare equal — this is helpful for sorting in multiple passes (forexample, sort by department, then by salary grade).

The sort algorithm uses only< comparisons between items. Whiledefining an__lt__() method will suffice for sorting,PEP 8 recommends that all sixrich comparisons be implemented. This will help avoid bugs when usingthe same data with other ordering tools such asmax() that relyon a different underlying method. Implementing all six comparisonsalso helps avoid confusion for mixed type comparisons which can callreflected the__gt__() method.

For sorting examples and a brief sorting tutorial, seeSorting Techniques.

@staticmethod¶

Transform a method into a static method.

A static method does not receive an implicit first argument. To declare a staticmethod, use this idiom:

classC:@staticmethoddeff(arg1,arg2,argN):...

The@staticmethod form is a functiondecorator – seeFunction definitions for details.

A static method can be called either on the class (such asC.f()) or onan instance (such asC().f()).Moreover, the static methoddescriptor is also callable, so it canbe used in the class definition (such asf()).

Static methods in Python are similar to those found in Java or C++. Also, seeclassmethod() for a variant that is useful for creating alternate classconstructors.

Like all decorators, it is also possible to callstaticmethod asa regular function and do something with its result. This is neededin some cases where you need a reference to a function from a classbody and you want to avoid the automatic transformation to instancemethod. For these cases, use this idiom:

defregular_function():...classC:method=staticmethod(regular_function)

For more information on static methods, seeThe standard type hierarchy.

Changed in version 3.10:Static methods now inherit the method attributes(__module__,__name__,__qualname__,__doc__ and__annotations__), have a new__wrapped__ attribute,and are now callable as regular functions.

classstr(object='')

classstr(object=b'',encoding='utf-8',errors='strict')

Return astr version ofobject. Seestr() for details.

str is the built-in stringclass. For general informationabout strings, seeText Sequence Type — str.

sum(iterable,/,start=0)¶

Sumsstart and the items of aniterable from left to right and returns thetotal. Theiterable’s items are normally numbers, and the start value is notallowed to be a string.

For some use cases, there are good alternatives tosum().The preferred, fast way to concatenate a sequence of strings is by calling''.join(sequence). To add floating-point values with extended precision,seemath.fsum(). To concatenate a series of iterables, consider usingitertools.chain().

Changed in version 3.8:Thestart parameter can be specified as a keyword argument.

Changed in version 3.12:Summation of floats switched to an algorithmthat gives higher accuracy and better commutativity on most builds.

classsuper¶

classsuper(type,object_or_type=None)

Return a proxy object that delegates method calls to a parent or siblingclass oftype. This is useful for accessing inherited methods that havebeen overridden in a class.

Theobject_or_type determines themethod resolution orderto be searched. The search starts from the class right after thetype.

For example, if__mro__ ofobject_or_type isD->B->C->A->object and the value oftype isB,thensuper() searchesC->A->object.

The__mro__ attribute of the class corresponding toobject_or_type lists the method resolution search order used by bothgetattr() andsuper(). The attribute is dynamic and can changewhenever the inheritance hierarchy is updated.

If the second argument is omitted, the super object returned is unbound. Ifthe second argument is an object,isinstance(obj,type) must be true. Ifthe second argument is a type,issubclass(type2,type) must be true (thisis useful for classmethods).

When called directly within an ordinary method of a class, both arguments maybe omitted (“zero-argumentsuper()”). In this case,type will be theenclosing class, andobj will be the first argument of the immediatelyenclosing function (typicallyself). (This means that zero-argumentsuper() will not work as expected within nested functions, includinggenerator expressions, which implicitly create nested functions.)

There are two typical use cases forsuper. In a class hierarchy withsingle inheritance,super can be used to refer to parent classes withoutnaming them explicitly, thus making the code more maintainable. This useclosely parallels the use ofsuper in other programming languages.

The second use case is to support cooperative multiple inheritance in adynamic execution environment. This use case is unique to Python and isnot found in statically compiled languages or languages that only supportsingle inheritance. This makes it possible to implement “diamond diagrams”where multiple base classes implement the same method. Good design dictatesthat such implementations have the same calling signature in every case (because theorder of calls is determined at runtime, because that order adaptsto changes in the class hierarchy, and because that order can includesibling classes that are unknown prior to runtime).

For both use cases, a typical superclass call looks like this:

classC(B):defmethod(self,arg):super().method(arg)# This does the same thing as:# super(C, self).method(arg)

In addition to method lookups,super() also works for attributelookups. One possible use case for this is callingdescriptorsin a parent or sibling class.

Note thatsuper() is implemented as part of the binding process forexplicit dotted attribute lookups such assuper().__getitem__(name).It does so by implementing its own__getattribute__() methodfor searchingclasses in a predictable order that supports cooperative multiple inheritance.Accordingly,super() is undefined for implicit lookups using statements oroperators such assuper()[name].

Also note that, aside from the zero argument form,super() is notlimited to use inside methods. The two argument form specifies thearguments exactly and makes the appropriate references. The zeroargument form only works inside a class definition, as the compiler fillsin the necessary details to correctly retrieve the class being defined,as well as accessing the current instance for ordinary methods.

For practical suggestions on how to design cooperative classes usingsuper(), seeguide to using super().

classtuple
classtuple(iterable): Rather than being a function,tuple is actually an immutablesequence type, as documented inTuples andSequence Types — list, tuple, range.

classtype(object)¶

classtype(name,bases,dict,**kwds)

With one argument, return the type of anobject. The return value is atype object and generally the same object as returned byobject.__class__.

Theisinstance() built-in function is recommended for testing the typeof an object, because it takes subclasses into account.

With three arguments, return a new type object. This is essentially adynamic form of theclass statement. Thename string isthe class name and becomes the__name__ attribute.Thebases tuple contains the base classes and becomes the__bases__ attribute; if empty,object, theultimate base of all classes, is added. Thedict dictionary containsattribute and method definitions for the class body; it may be copiedor wrapped before becoming the__dict__ attribute.The following two statements create identicaltype objects:

>>>classX:...a=1...>>>X=type('X',(),dict(a=1))

Movatterモバイル変換

Navigation

Built-in Functions¶

Previous topic

Next topic

This page

Navigation