Glossary¶

>>>

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

...

The default Python prompt of the interactive shell when entering code foran indented code block, when within a pair of matching left and rightdelimiters (parentheses, square brackets, curly braces or triple quotes),or after specifying a decorator.

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 module), numbers (in thenumbers module), and streams (in theio module). You cancreate your own ABCs with theabc module.

argument

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

• 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 and the FAQ question onthe difference between arguments and parameters.

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.

BDFL

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

bytes-like object

An object that supports thebuffer protocol,likestr,bytearray ormemoryview.Bytes-like objects can be used for various operations that expectbinary data, such as compression, saving to a binary file or sendingover a socket. Some operations need the binary data to be mutable,in which case not all bytes-like objects can apply.

bytecode

Python source code is compiled into bytecode, the internal representationof a Python program in the CPython interpreter. The bytecode is alsocached in.pyc and.pyo 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.

class

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

classic class

Any class which does not inherit fromobject. Seenew-style class. Classic classes have been removed in Python 3.

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. Coercion between two operands can beperformed with thecoerce built-in function; thus,3+4.5 isequivalent to callingoperator.add(*coerce(3,4.5)) and results inoperator.add(3.0,4.5). 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.

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

Anynew-style object which defines the methods__get__(),__set__(), or__delete__(). When a class attribute is adescriptor, its special binding behavior is triggered upon attributelookup. Normally, usinga.b to get, set or delete an attribute looks upthe object namedb in the class dictionary fora, but ifb is adescriptor, the respective descriptor method gets called. Understandingdescriptors is a key to a deep understanding of Python because they arethe basis for many features including 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 view

The objects returned fromdict.viewkeys(),dict.viewvalues(),anddict.viewitems() 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 asprint orif. Assignmentsare 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.

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: raw binary files,buffered binary files and text files. Their interfaces are defined in theio module. The canonical way to create a file object is by usingtheopen() function.

file-like object

A synonym forfile object.

finder

An object that tries to find theloader for a module. It mustimplement a method namedfind_module(). SeePEP 302 fordetails.

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.

__future__

A pseudo-module which programmers can use to enable new language featureswhich are not compatible with the current interpreter. For example, theexpression11/4 currently evaluates to2. If the module in whichit is executed had enabledtrue division by executing:

from__future__importdivision

the expression11/4 would evaluate to2.75. By importing the__future__ module and evaluating its variables, you can see when anew feature was first added to the language and when it will become thedefault:

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

generator

A function which returns an iterator. It looks like a normal functionexcept that it containsyield statements for producing a seriesof values usable in a for-loop or that can be retrieved one at a time withthenext() function. Eachyield temporarily suspendsprocessing, remembering the location execution state (including localvariables and pending try-statements). When the generator resumes, itpicks up where it left off (in contrast to functions which start fresh onevery invocation).

generator expression

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

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

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.

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__() or__cmp__() method).Hashable objects which compare 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.

All of Python’s immutable built-in objects are hashable, while no mutablecontainers (such as lists or dictionaries) are. 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.

integer division

Mathematical division discarding any remainder. For example, theexpression11/4 currently evaluates to2 in contrast to the2.75 returned by float division. Also calledfloor division.When dividing two integers the outcome will always be another integer(having the floor function applied to it). However, if one of the operandsis another numeric type (such as afloat), the result will becoerced (seecoercion) to a common type. For example, an integerdivided by a float will result in a float value, possibly with a decimalfraction. Integer division can be forced by using the// operatorinstead of the/ operator. See also__future__.

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.

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 likedictandfile and objects of any classes you definewith an__iter__() or__getitem__() method. 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’snext() method return successive items in the stream. When no moredata are available aStopIteration exception is raised instead. Atthis point, the iterator object is exhausted and any further calls to itsnext() method just raiseStopIteration again. Iterators arerequired 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.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, an ad-hoc 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=["0x%02x"%xforxinrange(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.

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.

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 inCustomizing class creation.

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.

See alsopackage.

MRO

Seemethod resolution order.

mutable

Mutable objects can change their value but keep theirid(). Seealsoimmutable.

named tuple

Any tuple-like class whose indexable elements are also accessible usingnamed attributes (for example,time.localtime() returns atuple-like object where theyear is accessible either with anindex such ast[0] or with a named attribute liket.tm_year).

A named tuple can be a built-in type such astime.struct_time,or it can be created with a regular class definition. A full featurednamed tuple can also be created with the factory functioncollections.namedtuple(). The latter approach automaticallyprovides extra features such as a self-documenting representation likeEmployee(name='jones',title='programmer').

namespace

The place where a variable is stored. Namespaces are implemented asdictionaries. There are the local, global and built-in namespaces as wellas nested namespaces in objects (in methods). Namespaces supportmodularity by preventing naming conflicts. For instance, the functions__builtin__.open() andos.open() are distinguished by theirnamespaces. Namespaces also aid readability and maintainability by makingit clear which module implements a function. For instance, writingrandom.seed() oritertools.izip() makes it clear that thosefunctions are implemented by therandom anditertoolsmodules, respectively.

nested scope

The ability to refer to a variable in an enclosing definition. Forinstance, a function defined inside another function can refer tovariables in the outer function. Note that nested scopes work only forreference and not for assignment which will always write to the innermostscope. In contrast, local variables both read and write in the innermostscope. Likewise, global variables read and write to the global namespace.

new-style class

Any class which inherits fromobject. This includes all built-intypes likelist anddict. Only new-style classes canuse Python’s newer, versatile features like__slots__,descriptors, properties, and__getattribute__().

More information can be found inNew-style and classic classes.

object

Any data with state (attributes or value) and defined behavior(methods). Also the ultimate base class of anynew-styleclass.

package

A Pythonmodule which can contain submodules or recursively,subpackages. Technically, a package is a Python module with an__path__ attribute.

parameter

A named entity in afunction (or method) definition thatspecifies anargument (or in some cases, arguments) that thefunction can accept. There are four types of parameters:

• positional-or-keyword: specifies an argument that can be passedeitherpositionally or as akeyword argument. This is the default kind of parameter, for examplefooandbar in the following:

  deffunc(foo,bar=None):...

• positional-only: specifies an argument that can be supplied onlyby position. Python has no syntax for defining positional-onlyparameters. However, some built-in functions have positional-onlyparameters (e.g.abs()).

• var-positional: specifies that an arbitrary sequence ofpositional arguments can be provided (in addition to any positionalarguments already accepted by other parameters). Such a parameter canbe defined by prepending the parameter name with*, for exampleargs in the following:

  deffunc(*args,**kwargs):...

• var-keyword: specifies that arbitrarily many keyword argumentscan be provided (in addition to any keyword arguments already acceptedby other parameters). Such a parameter can be defined by prependingthe parameter name with**, for examplekwargs in the exampleabove.

Parameters can specify both optional and required arguments, as well asdefault values for some optional arguments.

See also theargument glossary entry, the FAQ question onthe difference between arguments and parameters, and theFunction definitions section.

PEP

Python Enhancement Proposal. A PEP is a design documentproviding information to the Python community, or describing a newfeature for Python or its processes or environment. PEPs shouldprovide a concise technical specification and a rationale for proposedfeatures.

PEPs are intended to be the primary mechanisms for proposing major newfeatures, for collecting community input on an issue, and for documentingthe design decisions that have gone into Python. The PEP author isresponsible for building consensus within the community and documentingdissenting opinions.

SeePEP 1.

positional argument

Seeargument.

Python 3000

Nickname for the Python 3.x release line (coined long ago when the releaseof version 3 was something in the distant future.) This is alsoabbreviated “Py3k”.

Pythonic

An idea or piece of code which closely follows the most common idiomsof the Python language, rather than implementing code using conceptscommon to other languages. For example, a common idiom in Python isto loop over all elements of an iterable using aforstatement. Many other languages don’t have this type of construct, sopeople unfamiliar with Python sometimes use a numerical counter instead:

foriinrange(len(food)):printfood[i]

As opposed to the cleaner, Pythonic method:

forpieceinfood:printpiece

reference count

The number of references to an object. When the reference count of anobject drops to zero, it is deallocated. Reference counting isgenerally not visible to Python code, but it is a key element of theCPython implementation. Thesys module defines agetrefcount() function that programmers can call to return thereference count for a particular object.

__slots__

A declaration inside anew-style class that saves memory bypre-declaring space for instance attributes and eliminating instancedictionaries. Though popular, the technique is somewhat tricky to getright and is best reserved for rare cases where there are large numbers ofinstances in a memory-critical application.

sequence

Aniterable which supports efficient element access using integerindices via the__getitem__() special method and defines alen() method that returns the length of the sequence.Some built-in sequence types arelist,str,tuple, andunicode. Note thatdict alsosupports__getitem__() and__len__(), but is considered amapping rather than a sequence because the lookups use arbitraryimmutable keys rather than integers.

slice

An object usually containing a portion of asequence. A slice iscreated using the subscript notation,[] with colons between numberswhen several are given, such as invariable_name[1:3:5]. The bracket(subscript) notation usesslice objects internally (or in olderversions,__getslice__() and__setslice__()).

special method

A method that is called implicitly by Python to execute a certainoperation on a type, such as addition. Such methods have names startingand ending with double underscores. Special methods are documented inSpecial method names.

statement

A statement is part of a suite (a “block” of code). A statement is eitheranexpression or one of several constructs with a keyword, suchasif,while orfor.

struct sequence

A tuple with named elements. Struct sequences expose an interface similiartonamed tuple in that elements can be accessed either byindex or as an attribute. However, they do not have any of the named tuplemethods like_make() or_asdict(). Examples of struct sequencesincludesys.float_info and the return value ofos.stat().

triple-quoted string

A string which is bound by three instances of either a quotation mark(“) or an apostrophe (‘). While they don’t provide any functionalitynot available with single-quoted strings, they are useful for a numberof reasons. They allow you to include unescaped single and doublequotes within a string and they can span multiple lines without theuse of the continuation character, making them especially useful whenwriting docstrings.

type

The type of a Python object determines what kind of object it is; everyobject has a type. An object’s type is accessible as its__class__ attribute or can be retrieved withtype(obj).

universal newlines

A manner of interpreting text streams in which all of the following arerecognized as ending a line: the Unix end-of-line convention'\n',the Windows convention'\r\n', and the old Macintosh convention'\r'. SeePEP 278 andPEP 3116, as well asstr.splitlines() for an additional use.

virtual environment

A cooperatively isolated runtime environment that allows Python usersand applications to install and upgrade Python distribution packageswithout interfering with the behaviour of other Python applicationsrunning on the same system.

virtual machine

A computer defined entirely in software. Python’s virtual machineexecutes thebytecode emitted by the bytecode compiler.

Zen of Python

Listing of Python design principles and philosophies that are helpful inunderstanding and using the language. The listing can be found by typing“importthis” at the interactive prompt.