7
.. if you add new entries, keep the alphabetical sorting!
12
The default Python prompt of the interactive shell. Often seen for code
13
examples which can be executed interactively in the interpreter.
16
The default Python prompt of the interactive shell when entering code for
17
an indented code block or within a pair of matching left and right
18
delimiters (parentheses, square brackets or curly braces).
21
A tool that tries to convert Python 2.x code to Python 3.x code by
22
handling most of the incompatibilites which can be detected by parsing the
23
source and traversing the parse tree.
25
2to3 is available in the standard library as :mod:`lib2to3`; a standalone
26
entry point is provided as :file:`Tools/scripts/2to3`. See
27
:ref:`2to3-reference`.
30
Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
31
providing a way to define interfaces when other techniques like :func:`hasattr`
32
would be clumsy. Python comes with many builtin ABCs for data structures
33
(in the :mod:`collections` module), numbers (in the :mod:`numbers`
34
module), and streams (in the :mod:`io` module). You can create your own
35
ABC with the :mod:`abc` module.
38
A value passed to a function or method, assigned to a named local
39
variable in the function body. A function or method may have both
40
positional arguments and keyword arguments in its definition.
41
Positional and keyword arguments may be variable-length: ``*`` accepts
42
or passes (if in the function definition or call) several positional
43
arguments in a list, while ``**`` does the same for keyword arguments
46
Any expression may be used within the argument list, and the evaluated
47
value is passed to the local variable.
50
A value associated with an object which is referenced by name using
51
dotted expressions. For example, if an object *o* has an attribute
52
*a* it would be referenced as *o.a*.
55
Benevolent Dictator For Life, a.k.a. `Guido van Rossum
56
<http://www.python.org/~guido/>`_, Python's creator.
59
Python source code is compiled into bytecode, the internal representation
60
of a Python program in the interpreter. The bytecode is also cached in
61
``.pyc`` and ``.pyo`` files so that executing the same file is faster the
62
second time (recompilation from source to bytecode can be avoided). This
63
"intermediate language" is said to run on a :term:`virtual machine`
64
that executes the machine code corresponding to each bytecode.
67
A template for creating user-defined objects. Class definitions
68
normally contain method definitions which operate on instances of the
72
The implicit conversion of an instance of one type to another during an
73
operation which involves two arguments of the same type. For example,
74
``int(3.15)`` converts the floating point number to the integer ``3``, but
75
in ``3+4.5``, each argument is of a different type (one int, one float),
76
and both must be converted to the same type before they can be added or it
77
will raise a ``TypeError``. Without coercion, all arguments of even
78
compatible types would have to be normalized to the same value by the
79
programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``.
82
An extension of the familiar real number system in which all numbers are
83
expressed as a sum of a real part and an imaginary part. Imaginary
84
numbers are real multiples of the imaginary unit (the square root of
85
``-1``), often written ``i`` in mathematics or ``j`` in
86
engineering. Python has builtin support for complex numbers, which are
87
written with this latter notation; the imaginary part is written with a
88
``j`` suffix, e.g., ``3+1j``. To get access to complex equivalents of the
89
:mod:`math` module, use :mod:`cmath`. Use of complex numbers is a fairly
90
advanced mathematical feature. If you're not aware of a need for them,
91
it's almost certain you can safely ignore them.
94
An object which controls the environment seen in a :keyword:`with`
95
statement by defining :meth:`__enter__` and :meth:`__exit__` methods.
99
The canonical implementation of the Python programming language. The
100
term "CPython" is used in contexts when necessary to distinguish this
101
implementation from others such as Jython or IronPython.
104
A function returning another function, usually applied as a function
105
transformation using the ``@wrapper`` syntax. Common examples for
106
decorators are :func:`classmethod` and :func:`staticmethod`.
108
The decorator syntax is merely syntactic sugar, the following two
109
function definitions are semantically equivalent::
119
The same concept exists for classes, but is less commonly used there. See
120
the documentation for :ref:`function definitions <function>` and
121
:ref:`class definitions <class>` for more about decorators.
124
Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or
125
:meth:`__delete__`. When a class attribute is a descriptor, its special
126
binding behavior is triggered upon attribute lookup. Normally, using
127
*a.b* to get, set or delete an attribute looks up the object named *b* in
128
the class dictionary for *a*, but if *b* is a descriptor, the respective
129
descriptor method gets called. Understanding descriptors is a key to a
130
deep understanding of Python because they are the basis for many features
131
including functions, methods, properties, class methods, static methods,
132
and reference to super classes.
134
For more information about descriptors' methods, see :ref:`descriptors`.
137
An associative array, where arbitrary keys are mapped to values. The use
138
of :class:`dict` closely resembles that for :class:`list`, but the keys can
139
be any object with a :meth:`__hash__` function, not just integers.
140
Called a hash in Perl.
143
A string literal which appears as the first expression in a class,
144
function or module. While ignored when the suite is executed, it is
145
recognized by the compiler and put into the :attr:`__doc__` attribute
146
of the enclosing class, function or module. Since it is available via
147
introspection, it is the canonical place for documentation of the
151
A pythonic programming style which determines an object's type by inspection
152
of its method or attribute signature rather than by explicit relationship
153
to some type object ("If it looks like a duck and quacks like a duck, it
154
must be a duck.") By emphasizing interfaces rather than specific types,
155
well-designed code improves its flexibility by allowing polymorphic
156
substitution. Duck-typing avoids tests using :func:`type` or
157
:func:`isinstance`. (Note, however, that duck-typing can be complemented
158
with abstract base classes.) Instead, it typically employs :func:`hasattr`
159
tests or :term:`EAFP` programming.
162
Easier to ask for forgiveness than permission. This common Python coding
163
style assumes the existence of valid keys or attributes and catches
164
exceptions if the assumption proves false. This clean and fast style is
165
characterized by the presence of many :keyword:`try` and :keyword:`except`
166
statements. The technique contrasts with the :term:`LBYL` style
167
common to many other languages such as C.
170
A piece of syntax which can be evaluated to some value. In other words,
171
an expression is an accumulation of expression elements like literals,
172
names, attribute access, operators or function calls which all return a
173
value. In contrast to many other languages, not all language constructs
174
are expressions. There are also :term:`statement`\s which cannot be used
175
as expressions, such as :keyword:`if`. Assignments are also statements,
179
A module written in C or C++, using Python's C API to interact with the core and
183
An object that tries to find the :term:`loader` for a module. It must
184
implement a method named :meth:`find_module`. See :pep:`302` for
185
details and :class:`importlib.abc.Finder` for an
186
:term:`abstract base class`.
189
Mathematical division discarding any remainder. The floor division
190
operator is ``//``. For example, the expression ``11//4`` evaluates to
191
``2`` in contrast to the ``2.75`` returned by float true division.
194
A series of statements which returns some value to a caller. It can also
195
be passed zero or more arguments which may be used in the execution of
196
the body. See also :term:`argument` and :term:`method`.
199
A pseudo module which programmers can use to enable new language features
200
which are not compatible with the current interpreter.
202
By importing the :mod:`__future__` module and evaluating its variables,
203
you can see when a new feature was first added to the language and when it
204
becomes the default::
206
>>> import __future__
207
>>> __future__.division
208
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
211
The process of freeing memory when it is not used anymore. Python
212
performs garbage collection via reference counting and a cyclic garbage
213
collector that is able to detect and break reference cycles.
216
A function which returns an iterator. It looks like a normal function
217
except that values are returned to the caller using a :keyword:`yield`
218
statement instead of a :keyword:`return` statement. Generator functions
219
often contain one or more :keyword:`for` or :keyword:`while` loops which
220
:keyword:`yield` elements back to the caller. The function execution is
221
stopped at the :keyword:`yield` keyword (returning the result) and is
222
resumed there when the next element is requested by calling the
223
:meth:`__next__` method of the returned iterator.
225
.. index:: single: generator expression
228
An expression that returns a generator. It looks like a normal expression
229
followed by a :keyword:`for` expression defining a loop variable, range,
230
and an optional :keyword:`if` expression. The combined expression
231
generates values for an enclosing function::
233
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
237
See :term:`global interpreter lock`.
239
global interpreter lock
240
The lock used by Python threads to assure that only one thread
241
executes in the :term:`CPython` :term:`virtual machine` at a time.
242
This simplifies the CPython implementation by assuring that no two
243
processes can access the same memory at the same time. Locking the
244
entire interpreter makes it easier for the interpreter to be
245
multi-threaded, at the expense of much of the parallelism afforded by
246
multi-processor machines. Efforts have been made in the past to
247
create a "free-threaded" interpreter (one which locks shared data at a
248
much finer granularity), but so far none have been successful because
249
performance suffered in the common single-processor case.
252
An object is *hashable* if it has a hash value which never changes during
253
its lifetime (it needs a :meth:`__hash__` method), and can be compared to
254
other objects (it needs an :meth:`__eq__` method). Hashable objects which
255
compare equal must have the same hash value.
257
Hashability makes an object usable as a dictionary key and a set member,
258
because these data structures use the hash value internally.
260
All of Python's immutable built-in objects are hashable, while no mutable
261
containers (such as lists or dictionaries) are. Objects which are
262
instances of user-defined classes are hashable by default; they all
263
compare unequal, and their hash value is their :func:`id`.
266
An Integrated Development Environment for Python. IDLE is a basic editor
267
and interpreter environment which ships with the standard distribution of
268
Python. Good for beginners, it also serves as clear example code for
269
those wanting to implement a moderately sophisticated, multi-platform GUI
273
An object with a fixed value. Immutable objects include numbers, strings and
274
tuples. Such an object cannot be altered. A new object has to
275
be created if a different value has to be stored. They play an important
276
role in places where a constant hash value is needed, for example as a key
280
An object that both finds and loads a module; both a
281
:term:`finder` and :term:`loader` object.
284
Python has an interactive interpreter which means you can enter
285
statements and expressions at the interpreter prompt, immediately
286
execute them and see their results. Just launch ``python`` with no
287
arguments (possibly by selecting it from your computer's main
288
menu). It is a very powerful way to test out new ideas or inspect
289
modules and packages (remember ``help(x)``).
292
Python is an interpreted language, as opposed to a compiled one,
293
though the distinction can be blurry because of the presence of the
294
bytecode compiler. This means that source files can be run directly
295
without explicitly creating an executable which is then run.
296
Interpreted languages typically have a shorter development/debug cycle
297
than compiled ones, though their programs generally also run more
298
slowly. See also :term:`interactive`.
301
A container object capable of returning its members one at a
302
time. Examples of iterables include all sequence types (such as
303
:class:`list`, :class:`str`, and :class:`tuple`) and some non-sequence
304
types like :class:`dict` and :class:`file` and objects of any classes you
305
define with an :meth:`__iter__` or :meth:`__getitem__` method. Iterables
306
can be used in a :keyword:`for` loop and in many other places where a
307
sequence is needed (:func:`zip`, :func:`map`, ...). When an iterable
308
object is passed as an argument to the builtin function :func:`iter`, it
309
returns an iterator for the object. This iterator is good for one pass
310
over the set of values. When using iterables, it is usually not necessary
311
to call :func:`iter` or deal with iterator objects yourself. The ``for``
312
statement does that automatically for you, creating a temporary unnamed
313
variable to hold the iterator for the duration of the loop. See also
314
:term:`iterator`, :term:`sequence`, and :term:`generator`.
317
An object representing a stream of data. Repeated calls to the iterator's
318
:meth:`__next__` (or passing it to the builtin function) :func:`next`
319
method return successive items in the stream. When no more data are
320
available a :exc:`StopIteration` exception is raised instead. At this
321
point, the iterator object is exhausted and any further calls to its
322
:meth:`next` method just raise :exc:`StopIteration` again. Iterators are
323
required to have an :meth:`__iter__` method that returns the iterator
324
object itself so every iterator is also iterable and may be used in most
325
places where other iterables are accepted. One notable exception is code
326
which attempts multiple iteration passes. A container object (such as a
327
:class:`list`) produces a fresh new iterator each time you pass it to the
328
:func:`iter` function or use it in a :keyword:`for` loop. Attempting this
329
with an iterator will just return the same exhausted iterator object used
330
in the previous iteration pass, making it appear like an empty container.
332
More information can be found in :ref:`typeiter`.
335
Arguments which are preceded with a ``variable_name=`` in the call.
336
The variable name designates the local name in the function to which the
337
value is assigned. ``**`` is used to accept or pass a dictionary of
338
keyword arguments. See :term:`argument`.
341
An anonymous inline function consisting of a single :term:`expression`
342
which is evaluated when the function is called. The syntax to create
343
a lambda function is ``lambda [arguments]: expression``
346
Look before you leap. This coding style explicitly tests for
347
pre-conditions before making calls or lookups. This style contrasts with
348
the :term:`EAFP` approach and is characterized by the presence of many
349
:keyword:`if` statements.
352
A built-in Python :term:`sequence`. Despite its name it is more akin
353
to an array in other languages than to a linked list since access to
357
A compact way to process all or part of the elements in a sequence and
358
return a list with the results. ``result = ["0x%02x" % x for x in
359
range(256) if x % 2 == 0]`` generates a list of strings containing
360
even hex numbers (0x..) in the range from 0 to 255. The :keyword:`if`
361
clause is optional. If omitted, all elements in ``range(256)`` are
365
An object that loads a module. It must define a method named
366
:meth:`load_module`. A loader is typically returned by a
367
:term:`finder`. See :pep:`302` for details and
368
:class:`importlib.abc.Loader` for an :term:`abstract base class`.
371
A container object (such as :class:`dict`) which supports arbitrary key
372
lookups using the special method :meth:`__getitem__`.
375
The class of a class. Class definitions create a class name, a class
376
dictionary, and a list of base classes. The metaclass is responsible for
377
taking those three arguments and creating the class. Most object oriented
378
programming languages provide a default implementation. What makes Python
379
special is that it is possible to create custom metaclasses. Most users
380
never need this tool, but when the need arises, metaclasses can provide
381
powerful, elegant solutions. They have been used for logging attribute
382
access, adding thread-safety, tracking object creation, implementing
383
singletons, and many other tasks.
385
More information can be found in :ref:`metaclasses`.
388
A function which is defined inside a class body. If called as an attribute
389
of an instance of that class, the method will get the instance object as
390
its first :term:`argument` (which is usually called ``self``).
391
See :term:`function` and :term:`nested scope`.
394
Mutable objects can change their value but keep their :func:`id`. See
395
also :term:`immutable`.
398
Any tuple-like class whose indexable elements are also accessible using
399
named attributes (for example, :func:`time.localtime` returns a
400
tuple-like object where the *year* is accessible either with an
401
index such as ``t[0]`` or with a named attribute like ``t.tm_year``).
403
A named tuple can be a built-in type such as :class:`time.struct_time`,
404
or it can be created with a regular class definition. A full featured
405
named tuple can also be created with the factory function
406
:func:`collections.namedtuple`. The latter approach automatically
407
provides extra features such as a self-documenting representation like
408
``Employee(name='jones', title='programmer')``.
411
The place where a variable is stored. Namespaces are implemented as
412
dictionaries. There are the local, global and builtin namespaces as well
413
as nested namespaces in objects (in methods). Namespaces support
414
modularity by preventing naming conflicts. For instance, the functions
415
:func:`builtins.open` and :func:`os.open` are distinguished by their
416
namespaces. Namespaces also aid readability and maintainability by making
417
it clear which module implements a function. For instance, writing
418
:func:`random.seed` or :func:`itertools.izip` makes it clear that those
419
functions are implemented by the :mod:`random` and :mod:`itertools`
420
modules, respectively.
423
The ability to refer to a variable in an enclosing definition. For
424
instance, a function defined inside another function can refer to
425
variables in the outer function. Note that nested scopes work only for
426
reference and not for assignment which will always write to the innermost
427
scope. In contrast, local variables both read and write in the innermost
428
scope. Likewise, global variables read and write to the global namespace.
431
Old name for the flavor of classes now used for all class objects. In
432
earlier Python versions, only new-style classes could use Python's newer,
433
versatile features like :attr:`__slots__`, descriptors, properties,
434
:meth:`__getattribute__`, class methods, and static methods.
437
Any data with state (attributes or value) and defined behavior
438
(methods). Also the ultimate base class of any :term:`new-style
442
The arguments assigned to local names inside a function or method,
443
determined by the order in which they were given in the call. ``*`` is
444
used to either accept multiple positional arguments (when in the
445
definition), or pass several arguments as a list to a function. See
449
Nickname for the Python 3.x release line (coined long ago when the release
450
of version 3 was something in the distant future.) This is also
454
An idea or piece of code which closely follows the most common idioms
455
of the Python language, rather than implementing code using concepts
456
common to other languages. For example, a common idiom in Python is
457
to loop over all elements of an iterable using a :keyword:`for`
458
statement. Many other languages don't have this type of construct, so
459
people unfamiliar with Python sometimes use a numerical counter instead::
461
for i in range(len(food)):
464
As opposed to the cleaner, Pythonic method::
470
The number of references to an object. When the reference count of an
471
object drops to zero, it is deallocated. Reference counting is
472
generally not visible to Python code, but it is a key element of the
473
:term:`CPython` implementation. The :mod:`sys` module defines a
474
:func:`getrefcount` function that programmers can call to return the
475
reference count for a particular object.
478
A declaration inside a class that saves memory by pre-declaring space for
479
instance attributes and eliminating instance dictionaries. Though
480
popular, the technique is somewhat tricky to get right and is best
481
reserved for rare cases where there are large numbers of instances in a
482
memory-critical application.
485
An :term:`iterable` which supports efficient element access using integer
486
indices via the :meth:`__getitem__` special method and defines a
487
:meth:`len` method that returns the length of the sequence.
488
Some built-in sequence types are :class:`list`, :class:`str`,
489
:class:`tuple`, and :class:`bytes`. Note that :class:`dict` also
490
supports :meth:`__getitem__` and :meth:`__len__`, but is considered a
491
mapping rather than a sequence because the lookups use arbitrary
492
:term:`immutable` keys rather than integers.
495
An object usually containing a portion of a :term:`sequence`. A slice is
496
created using the subscript notation, ``[]`` with colons between numbers
497
when several are given, such as in ``variable_name[1:3:5]``. The bracket
498
(subscript) notation uses :class:`slice` objects internally.
501
A method that is called implicitly by Python to execute a certain
502
operation on a type, such as addition. Such methods have names starting
503
and ending with double underscores. Special methods are documented in
507
A statement is part of a suite (a "block" of code). A statement is either
508
an :term:`expression` or a one of several constructs with a keyword, such
509
as :keyword:`if`, :keyword:`while` or :keyword:`for`.
512
A string which is bound by three instances of either a quotation mark
513
(") or an apostrophe ('). While they don't provide any functionality
514
not available with single-quoted strings, they are useful for a number
515
of reasons. They allow you to include unescaped single and double
516
quotes within a string and they can span multiple lines without the
517
use of the continuation character, making them especially useful when
521
The type of a Python object determines what kind of object it is; every
522
object has a type. An object's type is accessible as its
523
:attr:`__class__` attribute or can be retrieved with ``type(obj)``.
526
The objects returned from :meth:`dict.keys`, :meth:`dict.items`, and
527
:meth:`dict.items` are called dictionary views. They are lazy sequences
528
that will see changes in the underlying dictionary. To force the
529
dictionary view to become a full list use ``list(dictview)``. See
533
A computer defined entirely in software. Python's virtual machine
534
executes the :term:`bytecode` emitted by the bytecode compiler.
537
Listing of Python design principles and philosophies that are helpful in
538
understanding and using the language. The listing can be found by typing
539
"``import this``" at the interactive prompt.
added
removed
Doc/glossary.rst
