| blob | a69a0f81fa8950a4096e740e4e06af222e9461f7 |
1 .. _glossary:
3 ********
4 Glossary
5 ********
7 .. if you add new entries, keep the alphabetical sorting!
9 .. glossary::
11 ``>>>``
12 The default Python prompt of the interactive shell. Often seen for code
13 examples which can be executed interactively in the interpreter.
15 ``...``
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).
20 2to3
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`.
29 abstract base class
30 Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
31 providing a way to define interfaces when other techniques like
32 :func:`hasattr` would be clumsy. Python comes with many built-in ABCs for
33 data structures (in the :mod:`collections` module), numbers (in the
34 :mod:`numbers` module), and streams (in the :mod:`io` module). You can
35 create your own ABC with the :mod:`abc` module.
37 argument
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
44 in a dictionary.
46 Any expression may be used within the argument list, and the evaluated
47 value is passed to the local variable.
49 attribute
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*.
54 BDFL
55 Benevolent Dictator For Life, a.k.a. `Guido van Rossum
56 <http://www.python.org/~guido/>`_, Python's creator.
58 bytecode
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.
66 class
67 A template for creating user-defined objects. Class definitions
68 normally contain method definitions which operate on instances of the
69 class.
71 coercion
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``.
81 complex number
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 built-in 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.
93 context manager
94 An object which controls the environment seen in a :keyword:`with`
95 statement by defining :meth:`__enter__` and :meth:`__exit__` methods.
96 See :pep:`343`.
98 CPython
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.
103 decorator
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::
111 def f(...):
112 ...
113 f = staticmethod(f)
115 @staticmethod
116 def f(...):
117 ...
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.
123 descriptor
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`.
136 dictionary
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.
142 docstring
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
148 object.
150 duck-typing
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.
161 EAFP
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.
169 expression
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,
176 not expressions.
178 extension module
179 A module written in C or C++, using Python's C API to interact with the core and
180 with user code.
182 finder
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`.
188 floor division
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.
193 function
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`.
198 __future__
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)
210 garbage collection
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.
215 generator
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
227 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
234 285
236 GIL
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.
251 hashable
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`.
265 IDLE
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
270 application.
272 immutable
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
277 in a dictionary.
279 importer
280 An object that both finds and loads a module; both a
281 :term:`finder` and :term:`loader` object.
283 interactive
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)``).
291 interpreted
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`.
300 iterable
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 built-in 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`.
316 iterator
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`.
334 keyword argument
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`.
340 lambda
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``
345 LBYL
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.
351 list
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
354 elements are O(1).
356 list comprehension
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
362 processed.
364 loader
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`.
370 mapping
371 A container object (such as :class:`dict`) which supports arbitrary key
372 lookups using the special method :meth:`__getitem__`.
374 metaclass
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`.
387 method
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`.
393 mutable
394 Mutable objects can change their value but keep their :func:`id`. See
395 also :term:`immutable`.
397 named tuple
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')``.
410 namespace
411 The place where a variable is stored. Namespaces are implemented as
412 dictionaries. There are the local, global and built-in 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.
422 nested scope
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.
430 new-style class
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.
436 object
437 Any data with state (attributes or value) and defined behavior
438 (methods). Also the ultimate base class of any :term:`new-style
439 class`.
441 positional argument
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
446 :term:`argument`.
448 Python 3000
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
451 abbreviated "Py3k".
453 Pythonic
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)):
462 print(food[i])
464 As opposed to the cleaner, Pythonic method::
466 for piece in food:
467 print(piece)
469 reference count
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.
477 __slots__
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.
484 sequence
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.
494 slice
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.
500 special method
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
504 :ref:`specialnames`.
506 statement
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`.
511 triple-quoted string
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
518 writing docstrings.
520 type
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)``.
525 view
526 The objects returned from :meth:`dict.keys`, :meth:`dict.values`, 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
530 :ref:`dict-views`.
532 virtual machine
533 A computer defined entirely in software. Python's virtual machine
534 executes the :term:`bytecode` emitted by the bytecode compiler.
536 Zen of Python
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.