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 or within a pair of matching left and rightdelimiters (parentheses, square brackets or curly braces).

2to3

A tool that tries to convert Python 2.x code to Python 3.x code byhandling most of the incompatibilites 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 (abbreviated ABCs) complementduck-typing byproviding a way to define interfaces when other techniques likehasattr()would be clumsy. Python comes with many builtin ABCs for data structures(in thecollections module), numbers (in thenumbersmodule), and streams (in theio module). You can create your ownABC with theabc module.

argument

A value passed to a function or method, assigned to a named localvariable in the function body. A function or method may have bothpositional arguments and keyword arguments in its definition.Positional and keyword arguments may be variable-length:* acceptsor passes (if in the function definition or call) several positionalarguments in a list, while** does the same for keyword argumentsin a dictionary.

Any expression may be used within the argument list, and the evaluatedvalue is passed to the local variable.

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.

bytecode

Python source code is compiled into bytecode, the internal representationof a Python program in the interpreter. The bytecode is also cached in.pyc and.pyo files so that executing the same file is faster thesecond time (recompilation from source to bytecode can be avoided). This“intermediate language” is said to run on avirtual machinethat executes the machine code corresponding to each bytecode.

class

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

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 builtin 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. Theterm “CPython” is used in contexts when necessary to distinguish thisimplementation from others such 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. The useofdict closely resembles that forlist, but the keys canbe any object with a__hash__() function, not just integers.Called a hash in Perl.

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 pythonic programming style which determines an object’s type by inspectionof its method or attribute signature rather than by explicit relationshipto some type object (“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 complementedwith abstract base classes.) Instead, it typically 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 asif. Assignments are also statements,not expressions.

extension module

A module written in C or C++, using Python’s C API to interact with the core andwith user code.

floor division

Mathematical division discarding any remainder. The floor divisionoperator is//. For example, the expression11//4 evaluates to2 in contrast to the2.75 returned by float true division.

function

A series of statements which returns some value to a caller. It can alsobe passed zero or more arguments which may be used in the execution ofthe body. See alsoargument andmethod.

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

generator

A function which returns an iterator. It looks like a normal functionexcept that values are returned to the caller using ayieldstatement instead of areturn statement. Generator functionsoften contain one or morefor orwhile loops whichyield elements back to the caller. The function execution isstopped at theyield keyword (returning the result) and isresumed there when the next element is requested by calling the__next__() method of the returned iterator.

generator expression

An expression that returns a generator. 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 lock used by Python threads to assure that only one threadexecutes in theCPythonvirtual machine at a time.This simplifies the CPython implementation by assuring that no twoprocesses can access the same memory at the same time. Locking theentire interpreter makes it easier for the interpreter to bemulti-threaded, at the expense of much of the parallelism afforded bymulti-processor machines. Efforts have been made in the past tocreate a “free-threaded” interpreter (one which locks shared data at amuch finer granularity), but so far none have been successful becauseperformance suffered in the common single-processor case.

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.

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, and their hash value is theirid().

IDLE

An Integrated Development Environment for Python. IDLE is a basic editorand interpreter environment which ships with the standard distribution ofPython. Good for beginners, it also serves as clear example code forthose wanting to implement a moderately sophisticated, multi-platform GUIapplication.

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.

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

A container object capable of returning its members one at atime. Examples of iterables include all sequence types (such aslist,str, andtuple) and some non-sequencetypes likedict andfile and objects of any classes youdefine with an__iter__() or__getitem__() method. Iterablescan be used in afor loop and in many other places where asequence is needed (zip(),map(), ...). When an iterableobject is passed as an argument to the builtin functioniter(), itreturns an iterator for the object. This iterator is good for one passover the set of values. When using iterables, it is usually not necessaryto 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__() (or passing it to the builtin function)next()method return successive items in the stream. When no more data areavailable aStopIteration exception is raised instead. At thispoint, 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.

keyword argument

Arguments which are preceded with avariable_name= in the call.The variable name designates the local name in the function to which thevalue is assigned.** is used to accept or pass a dictionary ofkeyword arguments. Seeargument.

lambda

An anonymous inline function consisting of a singleexpressionwhich is evaluated when the function is called. The syntax to createa lambda function islambda[arguments]: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.

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

mapping

A container object (such asdict) which supports arbitrary keylookups using the special method__getitem__().

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.

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 builtin namespaces as wellas nested namespaces in objects (in methods). Namespaces supportmodularity by preventing naming conflicts. For instance, the functionsbuiltins.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

Old name for the flavor of classes now used for all class objects. Inearlier Python versions, only new-style classes could use Python’s newer,versatile features like__slots__, descriptors, properties,__getattribute__(), class methods, and static methods.

object

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

positional argument

The arguments assigned to local names inside a function or method,determined by the order in which they were given in the call.* isused to either accept multiple positional arguments (when in thedefinition), or pass several arguments as a list to a function. 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)):print(food[i])

As opposed to the cleaner, Pythonic method:

forpieceinfood:print(piece)

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 a class that saves memory by pre-declaring space forinstance attributes and eliminating instance dictionaries. Thoughpopular, the technique is somewhat tricky to get right and is bestreserved for rare cases where there are large numbers of instances in amemory-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.

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 a one of several constructs with a keyword, suchasif,while orfor.

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

view

The objects returned fromdict.keys(),dict.items(), anddict.items() are called dictionary views. They are lazy sequencesthat will see changes in the underlying dictionary. To force thedictionary view to become a full list uselist(dictview). SeeDictionary view objects.

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.