Glossary¶

>>>

The default Python prompt of the interactive shell. Often seen for codeexamples which can be executed interactively in the interpreter.

...

Can refer to:

The default Python prompt of the interactive 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.

2to3

A tool that tries to convert Python 2.x code to Python 3.x code byhandling most of the incompatibilities which can be detected by parsing thesource and traversing the parse tree.

2to3 is available in the standard library aslib2to3; a standaloneentry point is provided asTools/scripts/2to3. See2to3 - Automated Python 2 to 3 code translation.

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.

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 thelocation execution 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 referenced by name usingdotted expressions. For example, if an objecto has an attributea it would be referenced aso.a.

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.

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.

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).

coercion

The implicit conversion of an instance of one type to another during anoperation which involves two arguments of the same type. For example,int(3.15) converts the floating point number to the integer3, butin3+4.5, each argument is of a different type (one int, one float),and both must be converted to the same type before they can be added or itwill raise aTypeError. Without coercion, all arguments of evencompatible types would have to be normalized to the same value by theprogrammer, e.g.,float(3)+4.5 rather than just3+4.5.

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 manager

An object which controls the environment seen in awithstatement by defining__enter__() and__exit__() methods.SeePEP 343.

context variable

A variable which can have different values depending on its context.This is similar to Thread-Local Storage in which each executionthread may have a different value for a variable. However, with contextvariables, there may be several contexts in one execution thread and themain usage for context variables is to keep track of variables inconcurrent asynchronous tasks.Seecontextvars.

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.

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(...):...f=staticmethod(f)@staticmethoddeff(...):...

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 Descriptors.

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.

finder

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

Since Python 3.3, there are two types of finder:meta path finders for use withsys.meta_path, andpathentry finders for use withsys.path_hooks.

SeePEP 302,PEP 420 andPEP 451 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.

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.

__future__

A pseudo-module which programmers can use to enable new language featureswhich are not compatible with the current interpreter.

By importing the__future__ module and evaluating its variables,you can see when a new feature was first added to the language and when itbecomes 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 thelocation execution 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

An expression that returns an iterator. 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.

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.

Past efforts to create a “free-threaded” interpreter (one which locksshared data at a much finer granularity) have not been successfulbecause performance suffered in the common single-processor case. Itis believed that overcoming this performance issue would make theimplementation much more complicated and therefore costlier to maintain.

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 be compared toother 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 Environment for Python. IDLE is a basic editorand interpreter environment which ships with the standard distribution ofPython.

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)).

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.

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,theoperator module provides three key function constructors:attrgetter(),itemgetter(), andmethodcaller(). 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.

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 is O(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 a method namedload_module(). A loader is typically returned by afinder. SeePEP 302 for details andimportlib.abc.Loader for anabstract base class.

magic method

An informal synonym forspecial method.

mapping

A container object that supports arbitrary key lookups and implements themethods specified in theMapping orMutableMappingabstract 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