Glossary¶

>>>¶

The default Python prompt of theinteractive shell. Oftenseen for code examples which can be executed interactively in theinterpreter.

...¶

Can refer to:

The default Python prompt of theinteractive shell when entering thecode for an indented code block, when within a pair of matching left andright delimiters (parentheses, square brackets, curly braces or triplequotes), or after specifying a decorator.
TheEllipsis built-in constant.

abstract base class¶

Abstract base classes complementduck-typing byproviding a way to define interfaces when other techniques likehasattr() would be clumsy or subtly wrong (for example withmagic methods). ABCs introduce virtualsubclasses, which are classes that don’t inherit from a class but arestill recognized byisinstance() andissubclass(); see theabc module documentation. Python comes with many built-in ABCs fordata structures (in thecollections.abc module), numbers (in thenumbers module), streams (in theio module), import findersand loaders (in theimportlib.abc module). You can create your ownABCs with theabc module.

annotation¶

A label associated with a variable, a classattribute or a function parameter or return value,used by convention as atype hint.

Annotations of local variables cannot be accessed at runtime, butannotations of global variables, class attributes, and functionsare stored in the__annotations__special attribute of modules, classes, and functions,respectively.

Seevariable annotation,function annotation,PEP 484andPEP 526, which describe this functionality.Also seeAnnotations Best Practicesfor best practices on working with annotations.

argument¶

A value passed to afunction (ormethod) when calling thefunction. There are two kinds of argument:

keyword argument: an argument preceded by an identifier (e.g.name=) in a function call or passed as a value in a dictionarypreceded by**. For example,3 and5 are both keywordarguments in the following calls tocomplex():
```
complex(real=3,imag=5)complex(**{'real':3,'imag':5})
```
positional argument: an argument that is not a keyword argument.Positional arguments can appear at the beginning of an argument listand/or be passed as elements of aniterable preceded by*.For example,3 and5 are both positional arguments in thefollowing calls:
```
complex(3,5)complex(*(3,5))
```

Arguments are assigned to the named local variables in a function body.See theCalls section for the rules governing this assignment.Syntactically, any expression can be used to represent an argument; theevaluated value is assigned to the local variable.

See also theparameter glossary entry, the FAQ question onthe difference between arguments and parameters, andPEP 362.

asynchronous context manager¶

An object which controls the environment seen in anasyncwith statement by defining__aenter__() and__aexit__() methods. Introduced byPEP 492.

asynchronous generator¶

A function which returns anasynchronous generator iterator. Itlooks like a coroutine function defined withasyncdef exceptthat it containsyield expressions for producing a series ofvalues usable in anasyncfor loop.

Usually refers to an asynchronous generator function, but may refer to anasynchronous generator iterator in some contexts. In cases where theintended meaning isn’t clear, using the full terms avoids ambiguity.

An asynchronous generator function may containawaitexpressions as well asasyncfor, andasyncwithstatements.

asynchronous generator iterator¶

An object created by aasynchronous generator function.

This is anasynchronous iterator which when called using the__anext__() method returns an awaitable object which will executethe body of the asynchronous generator function until the nextyield expression.

Eachyield temporarily suspends processing, remembering theexecution state (including local variables and pendingtry-statements). When theasynchronous generator iterator effectivelyresumes with another awaitable returned by__anext__(), itpicks up where it left off. SeePEP 492 andPEP 525.

asynchronous iterable¶

An object, that can be used in anasyncfor statement.Must return anasynchronous iterator from its__aiter__() method. Introduced byPEP 492.

asynchronous iterator¶

An object that implements the__aiter__() and__anext__()methods.__anext__() must return anawaitable object.asyncfor resolves the awaitables returned by an asynchronousiterator’s__anext__() method until it raises aStopAsyncIteration exception. Introduced byPEP 492.

attribute¶

A value associated with an object which is usually referenced by nameusing dotted expressions.For example, if an objecto has an attributea it would be referenced aso.a.

It is possible to give an object an attribute whose name is not anidentifier as defined byIdentifiers and keywords, for example usingsetattr(), if the object allows it.Such an attribute will not be accessible using a dotted expression,and would instead need to be retrieved withgetattr().

awaitable¶

An object that can be used in anawait expression. Can beacoroutine or an object with an__await__() method.See alsoPEP 492.

BDFL¶

Benevolent Dictator For Life, a.k.a.Guido van Rossum, Python’s creator.

binary file¶

Afile object able to read and writebytes-like objects.Examples of binary files are files opened in binary mode ('rb','wb' or'rb+'),sys.stdin.buffer,sys.stdout.buffer, and instances ofio.BytesIO andgzip.GzipFile.

See alsotext file for a file object able to read and writestr objects.

borrowed reference¶

In Python’s C API, a borrowed reference is a reference to an object,where the code using the object does not own the reference.It becomes a danglingpointer if the object is destroyed. For example, a garbage collection canremove the laststrong reference to the object and so destroy it.

CallingPy_INCREF() on theborrowed reference isrecommended to convert it to astrong reference in-place, exceptwhen the object cannot be destroyed before the last usage of the borrowedreference. ThePy_NewRef() function can be used to create a newstrong reference.

bytes-like object¶

An object that supports theBuffer Protocol and canexport a C-contiguous buffer. This includes allbytes,bytearray, andarray.array objects, as well as manycommonmemoryview objects. Bytes-like objects canbe used for various operations that work with binary data; these includecompression, saving to a binary file, and sending over a socket.

Some operations need the binary data to be mutable. The documentationoften refers to these as “read-write bytes-like objects”. Examplemutable buffer objects includebytearray and amemoryview of abytearray.Other operations require the binary data to be stored inimmutable objects (“read-only bytes-like objects”); examplesof these includebytes and amemoryviewof abytes object.

bytecode¶

Python source code is compiled into bytecode, the internal representationof a Python program in the CPython interpreter. The bytecode is alsocached in.pyc files so that executing the same file isfaster the second time (recompilation from source to bytecode can beavoided). This “intermediate language” is said to run on avirtual machine that executes the machine code corresponding toeach bytecode. Do note that bytecodes are not expected to work betweendifferent Python virtual machines, nor to be stable between Pythonreleases.

A list of bytecode instructions can be found in the documentation forthe dis module.

callable¶

A callable is an object that can be called, possibly with a setof arguments (seeargument), with the following syntax:

callable(argument1,argument2,argumentN)

Afunction, and by extension amethod, is a callable.An instance of a class that implements the__call__()method is also a callable.

callback¶

A subroutine function which is passed as an argument to be executed atsome point in the future.

class¶

A template for creating user-defined objects. Class definitionsnormally contain method definitions which operate on instances of theclass.

class variable¶

A variable defined in a class and intended to be modified only atclass level (i.e., not in an instance of the class).

closure variable¶

Afree variable referenced from anested scope that is defined in an outerscope rather than being resolved at runtime from the globals or builtin namespaces.May be explicitly defined with thenonlocal keyword to allow write access,or implicitly defined if the variable is only being read.

For example, in theinner function in the following code, bothx andprint arefree variables, but onlyx is aclosure variable:

defouter():x=0definner():nonlocalxx+=1print(x)returninner

Due to thecodeobject.co_freevars attribute (which, despite its name, onlyincludes the names of closure variables rather than listing all referenced freevariables), the more generalfree variable term is sometimes used evenwhen the intended meaning is to refer specifically to closure variables.

complex number¶

An extension of the familiar real number system in which all numbers areexpressed as a sum of a real part and an imaginary part. Imaginarynumbers are real multiples of the imaginary unit (the square root of-1), often writteni in mathematics orj inengineering. Python has built-in support for complex numbers, which arewritten with this latter notation; the imaginary part is written with aj suffix, e.g.,3+1j. To get access to complex equivalents of themath module, usecmath. Use of complex numbers is a fairlyadvanced mathematical feature. If you’re not aware of a need for them,it’s almost certain you can safely ignore them.

context¶

This term has different meanings depending on where and how it is used.Some common meanings:

The temporary state or environment established by acontextmanager via awith statement.
The collection of keyvalue bindings associated with a particularcontextvars.Context object and accessed viaContextVar objects. Also seecontextvariable.
Acontextvars.Context object. Also seecurrentcontext.

context management protocol¶

The__enter__() and__exit__() methods calledby thewith statement. SeePEP 343.

context manager¶

An object which implements thecontext management protocol andcontrols the environment seen in awith statement. SeePEP 343.

context variable¶

A variable whose value depends on which context is thecurrentcontext. Values are accessed viacontextvars.ContextVarobjects. Context variables are primarily used to isolate state betweenconcurrent asynchronous tasks.

contiguous¶

A buffer is considered contiguous exactly if it is eitherC-contiguous orFortran contiguous. Zero-dimensional buffers areC and Fortran contiguous. In one-dimensional arrays, the itemsmust be laid out in memory next to each other, in order ofincreasing indexes starting from zero. In multidimensionalC-contiguous arrays, the last index varies the fastest whenvisiting items in order of memory address. However, inFortran contiguous arrays, the first index varies the fastest.

coroutine¶

Coroutines are a more generalized form of subroutines. Subroutines areentered at one point and exited at another point. Coroutines can beentered, exited, and resumed at many different points. They can beimplemented with theasyncdef statement. See alsoPEP 492.

coroutine function¶

A function which returns acoroutine object. A coroutinefunction may be defined with theasyncdef statement,and may containawait,asyncfor, andasyncwith keywords. These were introducedbyPEP 492.

CPython¶

The canonical implementation of the Python programming language, asdistributed onpython.org. The term “CPython”is used when necessary to distinguish this implementation from otherssuch as Jython or IronPython.

current context¶

Thecontext (contextvars.Context object) that iscurrently used byContextVar objects to access (getor set) the values ofcontext variables. Eachthread has its own current context. Frameworks for executing asynchronoustasks (seeasyncio) associate each task with a context whichbecomes the current context whenever the task starts or resumes execution.

decorator¶

A function returning another function, usually applied as a functiontransformation using the@wrapper syntax. Common examples fordecorators areclassmethod() andstaticmethod().

The decorator syntax is merely syntactic sugar, the following twofunction definitions are semantically equivalent:

deff(arg):...f=staticmethod(f)@staticmethoddeff(arg):...

The same concept exists for classes, but is less commonly used there. Seethe documentation forfunction definitions andclass definitions for more about decorators.

descriptor¶

Any object which defines the methods__get__(),__set__(), or__delete__().When a class attribute is a descriptor, its specialbinding behavior is triggered upon attribute lookup. Normally, usinga.b to get, set or delete an attribute looks up the object namedb inthe class dictionary fora, but ifb is a descriptor, the respectivedescriptor method gets called. Understanding descriptors is a key to adeep understanding of Python because they are the basis for many featuresincluding functions, methods, properties, class methods, static methods,and reference to super classes.

For more information about descriptors’ methods, seeImplementing Descriptorsor theDescriptor How To Guide.

dictionary¶

An associative array, where arbitrary keys are mapped to values. Thekeys can be any object with__hash__() and__eq__() methods.Called a hash in Perl.

dictionary comprehension¶

A compact way to process all or part of the elements in an iterable andreturn a dictionary with the results.results={n:n**2forninrange(10)} generates a dictionary containing keyn mapped tovaluen**2. SeeDisplays for lists, sets and dictionaries.

dictionary view¶

The objects returned fromdict.keys(),dict.values(), anddict.items() are called dictionary views. They provide a dynamicview on the dictionary’s entries, which means that when the dictionarychanges, the view reflects these changes. To force thedictionary view to become a full list uselist(dictview). SeeDictionary view objects.

docstring¶

A string literal which appears as the first expression in a class,function or module. While ignored when the suite is executed, it isrecognized by the compiler and put into the__doc__ attributeof the enclosing class, function or module. Since it is available viaintrospection, it is the canonical place for documentation of theobject.

duck-typing¶

A programming style which does not look at an object’s type to determineif it has the right interface; instead, the method or attribute is simplycalled or used (“If it looks like a duck and quacks like a duck, itmust be a duck.”) By emphasizing interfaces rather than specific types,well-designed code improves its flexibility by allowing polymorphicsubstitution. Duck-typing avoids tests usingtype() orisinstance(). (Note, however, that duck-typing can be complementedwithabstract base classes.) Instead, ittypically employshasattr() tests orEAFP programming.

EAFP¶

Easier to ask for forgiveness than permission. This common Python codingstyle assumes the existence of valid keys or attributes and catchesexceptions if the assumption proves false. This clean and fast style ischaracterized by the presence of manytry andexceptstatements. The technique contrasts with theLBYL stylecommon to many other languages such as C.

expression¶

A piece of syntax which can be evaluated to some value. In other words,an expression is an accumulation of expression elements like literals,names, attribute access, operators or function calls which all return avalue. In contrast to many other languages, not all language constructsare expressions. There are alsostatements which cannot be usedas expressions, such aswhile. Assignments are also statements,not expressions.

extension module¶

A module written in C or C++, using Python’s C API to interact with thecore and with user code.

f-string¶

String literals prefixed with'f' or'F' are commonly called“f-strings” which is short forformatted string literals. See alsoPEP 498.

file object¶

An object exposing a file-oriented API (with methods such asread() orwrite()) to an underlying resource. Dependingon the way it was created, a file object can mediate access to a realon-disk file or to another type of storage or communication device(for example standard input/output, in-memory buffers, sockets, pipes,etc.). File objects are also calledfile-like objects orstreams.

There are actually three categories of file objects: rawbinary files, bufferedbinary files andtext files.Their interfaces are defined in theio module. The canonicalway to create a file object is by using theopen() function.

file-like object¶

A synonym forfile object.

filesystem encoding and error handler¶

Encoding and error handler used by Python to decode bytes from theoperating system and encode Unicode to the operating system.

The filesystem encoding must guarantee to successfully decode all bytesbelow 128. If the file system encoding fails to provide this guarantee,API functions can raiseUnicodeError.

Thesys.getfilesystemencoding() andsys.getfilesystemencodeerrors() functions can be used to get thefilesystem encoding and error handler.

Thefilesystem encoding and error handler are configured atPython startup by thePyConfig_Read() function: seefilesystem_encoding andfilesystem_errors members ofPyConfig.

See also thelocale encoding.

finder¶

An object that tries to find theloader for a module that isbeing imported.

There are two types of finder:meta path finders for use withsys.meta_path, andpathentry finders for use withsys.path_hooks.

SeeFinders and loaders andimportlib for much more detail.

floor division¶

Mathematical division that rounds down to nearest integer. The floordivision operator is//. For example, the expression11//4evaluates to2 in contrast to the2.75 returned by float truedivision. Note that(-11)//4 is-3 because that is-2.75roundeddownward. SeePEP 238.

free threading¶

A threading model where multiple threads can run Python bytecodesimultaneously within the same interpreter. This is in contrast totheglobal interpreter lock which allows only one thread toexecute Python bytecode at a time. SeePEP 703.

free variable¶

Formally, as defined in thelanguage execution model, a freevariable is any variable used in a namespace which is not a local variable in thatnamespace. Seeclosure variable for an example.Pragmatically, due to the name of thecodeobject.co_freevars attribute,the term is also sometimes used as a synonym forclosure variable.

function¶

A series of statements which returns some value to a caller. It can alsobe passed zero or morearguments which may be used inthe execution of the body. See alsoparameter,method,and theFunction definitions section.

function annotation¶

Anannotation of a function parameter or return value.

Function annotations are usually used fortype hints: for example, this function is expected to take twoint arguments and is also expected to have anintreturn value:

defsum_two_numbers(a:int,b:int)->int:returna+b

Function annotation syntax is explained in sectionFunction definitions.

Seevariable annotation andPEP 484,which describe this functionality.Also seeAnnotations Best Practicesfor best practices on working with annotations.

__future__¶

Afuture statement,from__future__import<feature>,directs the compiler to compile the current module using syntax orsemantics that will become standard in a future release of Python.The__future__ module documents the possible values offeature. By importing this module and evaluating its variables,you can see when a new feature was first added to the language andwhen it will (or did) become the default:

>>>import__future__>>>__future__.division_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection¶

The process of freeing memory when it is not used anymore. Pythonperforms garbage collection via reference counting and a cyclic garbagecollector that is able to detect and break reference cycles. Thegarbage collector can be controlled using thegc module.

generator¶

A function which returns agenerator iterator. It looks like anormal function except that it containsyield expressionsfor producing a series of values usable in a for-loop or that can beretrieved one at a time with thenext() function.

Usually refers to a generator function, but may refer to agenerator iterator in some contexts. In cases where the intendedmeaning isn’t clear, using the full terms avoids ambiguity.

generator iterator¶

An object created by agenerator function.

Eachyield temporarily suspends processing, remembering theexecution state (including local variables and pendingtry-statements). When thegenerator iterator resumes, it picks up whereit left off (in contrast to functions which start fresh on everyinvocation).

generator expression¶

Anexpression that returns aniterator. It looks like a normal expressionfollowed by afor clause defining a loop variable, range,and an optionalif clause. The combined expressiongenerates values for an enclosing function:

>>>sum(i*iforiinrange(10))# sum of squares 0, 1, 4, ... 81285

generic function¶

A function composed of multiple functions implementing the same operationfor different types. Which implementation should be used during a call isdetermined by the dispatch algorithm.

See also thesingle dispatch glossary entry, thefunctools.singledispatch() decorator, andPEP 443.

generic type¶

Atype that can be parameterized; typically acontainer class such aslist ordict. Used fortype hints andannotations.

For more details, seegeneric alias types,PEP 483,PEP 484,PEP 585, and thetyping module.

GIL¶

Seeglobal interpreter lock.

global interpreter lock¶

The mechanism used by theCPython interpreter to assure thatonly one thread executes Pythonbytecode at a time.This simplifies the CPython implementation by making the object model(including critical built-in types such asdict) implicitlysafe against concurrent access. Locking the entire interpretermakes it easier for the interpreter to be multi-threaded, at theexpense of much of the parallelism afforded by multi-processormachines.

However, some extension modules, either standard or third-party,are designed so as to release the GIL when doing computationally intensivetasks such as compression or hashing. Also, the GIL is always releasedwhen doing I/O.

As of Python 3.13, the GIL can be disabled using the--disable-gilbuild configuration. After building Python with this option, code must berun with-Xgil=0 or after setting thePYTHON_GIL=0environment variable. This feature enables improved performance formulti-threaded applications and makes it easier to use multi-core CPUsefficiently. For more details, seePEP 703.

hash-based pyc¶

A bytecode cache file that uses the hash rather than the last-modifiedtime of the corresponding source file to determine its validity. SeeCached bytecode invalidation.

hashable¶

An object ishashable if it has a hash value which never changes duringits lifetime (it needs a__hash__() method), and can becompared to other objects (it needs an__eq__() method).Hashable objects whichcompare equal must have the same hash value.

Hashability makes an object usable as a dictionary key and a set member,because these data structures use the hash value internally.

Most of Python’s immutable built-in objects are hashable; mutablecontainers (such as lists or dictionaries) are not; immutablecontainers (such as tuples and frozensets) are only hashable iftheir elements are hashable. Objects which areinstances of user-defined classes are hashable by default. They allcompare unequal (except with themselves), and their hash value is derivedfrom theirid().

IDLE¶

An Integrated Development and Learning Environment for Python.IDLE — Python editor and shell is a basic editor and interpreter environmentwhich ships with the standard distribution of Python.

immortal¶

Immortal objects are a CPython implementation detail introducedinPEP 683.

If an object is immortal, itsreference count is never modified,and therefore it is never deallocated while the interpreter is running.For example,True andNone are immortal in CPython.

immutable¶

An object with a fixed value. Immutable objects include numbers, strings andtuples. Such an object cannot be altered. A new object has tobe created if a different value has to be stored. They play an importantrole in places where a constant hash value is needed, for example as a keyin a dictionary.

import path¶

A list of locations (orpath entries) that aresearched by thepath based finder for modules to import. Duringimport, this list of locations usually comes fromsys.path, butfor subpackages it may also come from the parent package’s__path__attribute.

importing¶

The process by which Python code in one module is made available toPython code in another module.

importer¶

An object that both finds and loads a module; both afinder andloader object.

interactive¶

Python has an interactive interpreter which means you can enterstatements and expressions at the interpreter prompt, immediatelyexecute them and see their results. Just launchpython with noarguments (possibly by selecting it from your computer’s mainmenu). It is a very powerful way to test out new ideas or inspectmodules and packages (rememberhelp(x)). For more on interactivemode, seeInteractive Mode.

interpreted¶

Python is an interpreted language, as opposed to a compiled one,though the distinction can be blurry because of the presence of thebytecode compiler. This means that source files can be run directlywithout explicitly creating an executable which is then run.Interpreted languages typically have a shorter development/debug cyclethan compiled ones, though their programs generally also run moreslowly. See alsointeractive.

interpreter shutdown¶

When asked to shut down, the Python interpreter enters a special phasewhere it gradually releases all allocated resources, such as modulesand various critical internal structures. It also makes several callsto thegarbage collector. This can triggerthe execution of code in user-defined destructors or weakref callbacks.Code executed during the shutdown phase can encounter variousexceptions as the resources it relies on may not function anymore(common examples are library modules or the warnings machinery).

The main reason for interpreter shutdown is that the__main__ moduleor the script being run has finished executing.

iterable¶

An object capable of returning its members one at a time. Examples ofiterables include all sequence types (such aslist,str,andtuple) and some non-sequence types likedict,file objects, and objects of any classes you definewith an__iter__() method or with a__getitem__() methodthat implementssequence semantics.

Iterables can beused in afor loop and in many other places where a sequence isneeded (zip(),map(), …). When an iterable object is passedas an argument to the built-in functioniter(), it returns aniterator for the object. This iterator is good for one pass over the setof values. When using iterables, it is usually not necessary to calliter() or deal with iterator objects yourself. Theforstatement does that automatically for you, creating a temporary unnamedvariable to hold the iterator for the duration of the loop. See alsoiterator,sequence, andgenerator.

iterator¶

An object representing a stream of data. Repeated calls to the iterator’s__next__() method (or passing it to the built-in functionnext()) return successive items in the stream. When no more dataare available aStopIteration exception is raised instead. At thispoint, the iterator object is exhausted and any further calls to its__next__() method just raiseStopIteration again. Iteratorsare required to have an__iter__() method that returns the iteratorobject itself so every iterator is also iterable and may be used in mostplaces where other iterables are accepted. One notable exception is codewhich attempts multiple iteration passes. A container object (such as alist) produces a fresh new iterator each time you pass it to theiter() function or use it in afor loop. Attempting thiswith an iterator will just return the same exhausted iterator object usedin the previous iteration pass, making it appear like an empty container.

More information can be found inIterator Types.

CPython implementation detail: CPython does not consistently apply the requirement that an iteratordefine__iter__().And also please note that the free-threading CPython does not guaranteethe thread-safety of iterator operations.

key function¶

A key function or collation function is a callable that returns a valueused for sorting or ordering. For example,locale.strxfrm() isused to produce a sort key that is aware of locale specific sortconventions.

A number of tools in Python accept key functions to control how elementsare ordered or grouped. They includemin(),max(),sorted(),list.sort(),heapq.merge(),heapq.nsmallest(),heapq.nlargest(), anditertools.groupby().

There are several ways to create a key function. For example. thestr.lower() method can serve as a key function for case insensitivesorts. Alternatively, a key function can be built from alambda expression such aslambdar:(r[0],r[2]). Also,operator.attrgetter(),operator.itemgetter(), andoperator.methodcaller() are three key function constructors. See theSorting HOW TO for examples of how to create and use key functions.

keyword argument¶

Seeargument.

lambda¶

An anonymous inline function consisting of a singleexpressionwhich is evaluated when the function is called. The syntax to createa lambda function islambda[parameters]:expression

LBYL¶

Look before you leap. This coding style explicitly tests forpre-conditions before making calls or lookups. This style contrasts withtheEAFP approach and is characterized by the presence of manyif statements.

In a multi-threaded environment, the LBYL approach can risk introducing arace condition between “the looking” and “the leaping”. For example, thecode,ifkeyinmapping:returnmapping[key] can fail if anotherthread removeskey frommapping after the test, but before the lookup.This issue can be solved with locks or by using the EAFP approach.

lexical analyzer¶

Formal name for thetokenizer; seetoken.

list¶

A built-in Pythonsequence. Despite its name it is more akinto an array in other languages than to a linked list since access toelements isO(1).

list comprehension¶

A compact way to process all or part of the elements in a sequence andreturn a list with the results.result=['{:#04x}'.format(x)forxinrange(256)ifx%2==0] generates a list of strings containingeven hex numbers (0x..) in the range from 0 to 255. Theifclause is optional. If omitted, all elements inrange(256) areprocessed.

loader¶

An object that loads a module.It must define theexec_module() andcreate_module() methodsto implement theLoader interface.A loader is typically returned by afinder.See also:

locale encoding¶

On Unix, it is the encoding of the LC_CTYPE locale. It can be set withlocale.setlocale(locale.LC_CTYPE,new_locale).

On Windows, it is the ANSI code page (ex:"cp1252").

On Android and VxWorks, Python uses"utf-8" as the locale encoding.

locale.getencoding() can be used to get the locale encoding.

magic method¶

An informal synonym forspecial method.

mapping¶

A container object that supports arbitrary key lookups and implements themethods specified in thecollections.abc.Mapping orcollections.abc.MutableMappingabstract base classes. Examplesincludedict,collections.defaultdict,collections.OrderedDict andcollections.Counter.

meta path finder¶

Afinder returned by a search ofsys.meta_path. Meta pathfinders are related to, but different frompath entry finders.

Seeimportlib.abc.MetaPathFinder for the methods that meta pathfinders implement.

metaclass¶

The class of a class. Class definitions create a class name, a classdictionary, and a list of base classes. The metaclass is responsible fortaking those three arguments and creating the class. Most object orientedprogramming languages provide a default implementation. What makes Pythonspecial is that it is possible to create custom metaclasses. Most usersnever need this tool, but when the need arises, metaclasses can providepowerful, elegant solutions. They have been used for logging attributeaccess, adding thread-safety, tracking object creation, implementingsingletons, and many other tasks.

More information can be found inMetaclasses.

method¶

A function which is defined inside a class body. If called as an attributeof an instance of that class, the method will get the instance object asits firstargument (which is usually calledself).Seefunction andnested scope.

method resolution order¶

Method Resolution Order is the order in which base classes are searchedfor a member during lookup. SeeThe Python 2.3 Method Resolution Order for details of thealgorithm used by the Python interpreter since the 2.3 release.

module¶

An object that serves as an organizational unit of Python code. Moduleshave a namespace containing arbitrary Python objects. Modules are loadedinto Python by the process ofimporting.

Movatterモバイル変換

Navigation

Glossary¶

Previous topic

Next topic

This page

Navigation