blob: 743154510fc7e71ff85957c47bff6f71c179f373 [file] [log] [blame]
Guido van Rossumf10aa982007-08-17 18:30:38 +00001.. _glossary:
2
3********
4Glossary
5********
6
7.. if you add new entries, keep the alphabetical sorting!
8
9.. glossary::
10
11 ``>>>``
Benjamin Peterson5478b472008-09-17 22:25:09 +000012 The default Python prompt of the interactive shell. Often seen for code
13 examples which can be executed interactively in the interpreter.
Georg Brandl48310cd2009-01-03 21:18:54 +000014
Guido van Rossumf10aa982007-08-17 18:30:38 +000015 ``...``
Benjamin Peterson5478b472008-09-17 22:25:09 +000016 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).
Christian Heimesd8654cf2007-12-02 15:22:16 +000019
Benjamin Petersond6313712008-07-31 16:23:04 +000020 2to3
21 A tool that tries to convert Python 2.x code to Python 3.x code by
Georg Brandl4b054662010-10-06 08:56:53 +000022 handling most of the incompatibilities which can be detected by parsing the
Benjamin Petersond6313712008-07-31 16:23:04 +000023 source and traversing the parse tree.
24
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`.
28
Georg Brandl86b2fb92008-07-16 03:43:04 +000029 abstract base class
Benjamin Peterson41181742008-07-02 20:22:54 +000030 Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
Georg Brandlc5605df2009-08-13 08:26:44 +000031 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.
Benjamin Peterson41181742008-07-02 20:22:54 +000036
Christian Heimesd8654cf2007-12-02 15:22:16 +000037 argument
Benjamin Peterson5478b472008-09-17 22:25:09 +000038 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.
Christian Heimesd8654cf2007-12-02 15:22:16 +000045
46 Any expression may be used within the argument list, and the evaluated
47 value is passed to the local variable.
Benjamin Peterson5478b472008-09-17 22:25:09 +000048
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*.
Georg Brandl48310cd2009-01-03 21:18:54 +000053
Guido van Rossumf10aa982007-08-17 18:30:38 +000054 BDFL
55 Benevolent Dictator For Life, a.k.a. `Guido van Rossum
56 <http://www.python.org/~guido/>`_, Python's creator.
Georg Brandl48310cd2009-01-03 21:18:54 +000057
Georg Brandl9afde1c2007-11-01 20:32:30 +000058 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
Benjamin Peterson5478b472008-09-17 22:25:09 +000063 "intermediate language" is said to run on a :term:`virtual machine`
64 that executes the machine code corresponding to each bytecode.
65
Georg Brandlc7b69082010-10-06 08:08:40 +000066 A list of bytecode instructions can be found in the documentation for
67 :ref:`the dis module <bytecodes>`.
68
Benjamin Peterson5478b472008-09-17 22:25:09 +000069 class
70 A template for creating user-defined objects. Class definitions
71 normally contain method definitions which operate on instances of the
72 class.
Georg Brandl48310cd2009-01-03 21:18:54 +000073
Benjamin Peterson5478b472008-09-17 22:25:09 +000074 coercion
75 The implicit conversion of an instance of one type to another during an
76 operation which involves two arguments of the same type. For example,
77 ``int(3.15)`` converts the floating point number to the integer ``3``, but
78 in ``3+4.5``, each argument is of a different type (one int, one float),
79 and both must be converted to the same type before they can be added or it
Benjamin Peterson2d718222008-11-21 00:25:02 +000080 will raise a ``TypeError``. Without coercion, all arguments of even
Benjamin Peterson5478b472008-09-17 22:25:09 +000081 compatible types would have to be normalized to the same value by the
82 programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``.
Georg Brandl48310cd2009-01-03 21:18:54 +000083
Guido van Rossumf10aa982007-08-17 18:30:38 +000084 complex number
85 An extension of the familiar real number system in which all numbers are
86 expressed as a sum of a real part and an imaginary part. Imaginary
87 numbers are real multiples of the imaginary unit (the square root of
88 ``-1``), often written ``i`` in mathematics or ``j`` in
Georg Brandlc5605df2009-08-13 08:26:44 +000089 engineering. Python has built-in support for complex numbers, which are
Guido van Rossumf10aa982007-08-17 18:30:38 +000090 written with this latter notation; the imaginary part is written with a
91 ``j`` suffix, e.g., ``3+1j``. To get access to complex equivalents of the
92 :mod:`math` module, use :mod:`cmath`. Use of complex numbers is a fairly
93 advanced mathematical feature. If you're not aware of a need for them,
94 it's almost certain you can safely ignore them.
Georg Brandl48310cd2009-01-03 21:18:54 +000095
Christian Heimes895627f2007-12-08 17:28:33 +000096 context manager
Benjamin Peterson5478b472008-09-17 22:25:09 +000097 An object which controls the environment seen in a :keyword:`with`
Christian Heimes895627f2007-12-08 17:28:33 +000098 statement by defining :meth:`__enter__` and :meth:`__exit__` methods.
99 See :pep:`343`.
100
Benjamin Peterson5478b472008-09-17 22:25:09 +0000101 CPython
Antoine Pitrou6e7d7112011-01-06 16:34:50 +0000102 The canonical implementation of the Python programming language, as
103 distributed on `python.org <http://python.org>`_. The term "CPython"
104 is used when necessary to distinguish this implementation from others
105 such as Jython or IronPython.
Benjamin Peterson5478b472008-09-17 22:25:09 +0000106
Christian Heimesd8654cf2007-12-02 15:22:16 +0000107 decorator
108 A function returning another function, usually applied as a function
109 transformation using the ``@wrapper`` syntax. Common examples for
110 decorators are :func:`classmethod` and :func:`staticmethod`.
111
112 The decorator syntax is merely syntactic sugar, the following two
113 function definitions are semantically equivalent::
114
115 def f(...):
116 ...
117 f = staticmethod(f)
118
119 @staticmethod
120 def f(...):
121 ...
122
Georg Brandlaf265f42008-12-07 15:06:20 +0000123 The same concept exists for classes, but is less commonly used there. See
124 the documentation for :ref:`function definitions <function>` and
125 :ref:`class definitions <class>` for more about decorators.
Georg Brandla09ca382007-12-02 18:20:12 +0000126
Guido van Rossumf10aa982007-08-17 18:30:38 +0000127 descriptor
Benjamin Peterson5478b472008-09-17 22:25:09 +0000128 Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or
Georg Brandl85eb8c12007-08-31 16:33:38 +0000129 :meth:`__delete__`. When a class attribute is a descriptor, its special
Georg Brandl9afde1c2007-11-01 20:32:30 +0000130 binding behavior is triggered upon attribute lookup. Normally, using
131 *a.b* to get, set or delete an attribute looks up the object named *b* in
132 the class dictionary for *a*, but if *b* is a descriptor, the respective
133 descriptor method gets called. Understanding descriptors is a key to a
134 deep understanding of Python because they are the basis for many features
135 including functions, methods, properties, class methods, static methods,
136 and reference to super classes.
137
138 For more information about descriptors' methods, see :ref:`descriptors`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000139
Guido van Rossumf10aa982007-08-17 18:30:38 +0000140 dictionary
Raymond Hettingerbd204de2010-09-01 22:21:36 +0000141 An associative array, where arbitrary keys are mapped to values. The keys
142 can be any object with :meth:`__hash__` function and :meth:`__eq__`
143 methods. Called a hash in Perl.
Georg Brandl3dbca812008-07-23 16:10:53 +0000144
145 docstring
Benjamin Peterson5478b472008-09-17 22:25:09 +0000146 A string literal which appears as the first expression in a class,
147 function or module. While ignored when the suite is executed, it is
148 recognized by the compiler and put into the :attr:`__doc__` attribute
149 of the enclosing class, function or module. Since it is available via
150 introspection, it is the canonical place for documentation of the
Georg Brandl3dbca812008-07-23 16:10:53 +0000151 object.
Georg Brandl48310cd2009-01-03 21:18:54 +0000152
153 duck-typing
Georg Brandl914a2182010-10-06 08:13:26 +0000154 A programming style which does not look at an object's type to determine
155 if it has the right interface; instead, the method or attribute is simply
156 called or used ("If it looks like a duck and quacks like a duck, it
Guido van Rossumf10aa982007-08-17 18:30:38 +0000157 must be a duck.") By emphasizing interfaces rather than specific types,
158 well-designed code improves its flexibility by allowing polymorphic
159 substitution. Duck-typing avoids tests using :func:`type` or
Georg Brandl9b42f172010-07-11 08:56:18 +0000160 :func:`isinstance`. (Note, however, that duck-typing can be complemented
161 with :term:`abstract base class`\ es.) Instead, it typically employs
162 :func:`hasattr` tests or :term:`EAFP` programming.
Georg Brandl48310cd2009-01-03 21:18:54 +0000163
Guido van Rossumf10aa982007-08-17 18:30:38 +0000164 EAFP
165 Easier to ask for forgiveness than permission. This common Python coding
166 style assumes the existence of valid keys or attributes and catches
167 exceptions if the assumption proves false. This clean and fast style is
168 characterized by the presence of many :keyword:`try` and :keyword:`except`
Georg Brandl48310cd2009-01-03 21:18:54 +0000169 statements. The technique contrasts with the :term:`LBYL` style
Benjamin Peterson5478b472008-09-17 22:25:09 +0000170 common to many other languages such as C.
Guido van Rossumf10aa982007-08-17 18:30:38 +0000171
Christian Heimesd8654cf2007-12-02 15:22:16 +0000172 expression
173 A piece of syntax which can be evaluated to some value. In other words,
Benjamin Peterson5478b472008-09-17 22:25:09 +0000174 an expression is an accumulation of expression elements like literals,
175 names, attribute access, operators or function calls which all return a
176 value. In contrast to many other languages, not all language constructs
177 are expressions. There are also :term:`statement`\s which cannot be used
178 as expressions, such as :keyword:`if`. Assignments are also statements,
179 not expressions.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000180
Guido van Rossumf10aa982007-08-17 18:30:38 +0000181 extension module
Georg Brandld98934c2011-02-25 10:03:34 +0000182 A module written in C or C++, using Python's C API to interact with the
183 core and with user code.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000184
Antoine Pitrou25d535e2010-09-15 11:25:11 +0000185 file object
186 An object exposing a file-oriented API (with methods such as
Georg Brandld98934c2011-02-25 10:03:34 +0000187 :meth:`read()` or :meth:`write()`) to an underlying resource. Depending
188 on the way it was created, a file object can mediate access to a real
189 on-disk file or to another other type of storage or communication device
190 (for example standard input/output, in-memory buffers, sockets, pipes,
191 etc.). File objects are also called :dfn:`file-like objects` or
192 :dfn:`streams`.
Antoine Pitrou25d535e2010-09-15 11:25:11 +0000193
Georg Brandld98934c2011-02-25 10:03:34 +0000194 There are actually three categories of file objects: raw binary files,
195 buffered binary files and text files. Their interfaces are defined in the
196 :mod:`io` module. The canonical way to create a file object is by using
197 the :func:`open` function.
Antoine Pitrou25d535e2010-09-15 11:25:11 +0000198
199 file-like object
200 A synonym for :term:`file object`.
201
Brett Cannon51d4aab2009-01-25 04:21:39 +0000202 finder
203 An object that tries to find the :term:`loader` for a module. It must
204 implement a method named :meth:`find_module`. See :pep:`302` for
Brett Cannone43b0602009-03-21 03:11:16 +0000205 details and :class:`importlib.abc.Finder` for an
206 :term:`abstract base class`.
Brett Cannon51d4aab2009-01-25 04:21:39 +0000207
Benjamin Peterson2d718222008-11-21 00:25:02 +0000208 floor division
Raymond Hettingerbd204de2010-09-01 22:21:36 +0000209 Mathematical division that rounds down to nearest integer. The floor
210 division operator is ``//``. For example, the expression ``11 // 4``
211 evaluates to ``2`` in contrast to the ``2.75`` returned by float true
212 division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75``
213 rounded *downward*. See :pep:`238`.
Benjamin Peterson2d718222008-11-21 00:25:02 +0000214
Christian Heimesd8654cf2007-12-02 15:22:16 +0000215 function
216 A series of statements which returns some value to a caller. It can also
217 be passed zero or more arguments which may be used in the execution of
218 the body. See also :term:`argument` and :term:`method`.
219
Guido van Rossumf10aa982007-08-17 18:30:38 +0000220 __future__
Raymond Hettingerbd204de2010-09-01 22:21:36 +0000221 A pseudo-module which programmers can use to enable new language features
Benjamin Peterson2d718222008-11-21 00:25:02 +0000222 which are not compatible with the current interpreter.
223
224 By importing the :mod:`__future__` module and evaluating its variables,
225 you can see when a new feature was first added to the language and when it
226 becomes the default::
Georg Brandl48310cd2009-01-03 21:18:54 +0000227
Guido van Rossumf10aa982007-08-17 18:30:38 +0000228 >>> import __future__
229 >>> __future__.division
230 _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
231
232 garbage collection
233 The process of freeing memory when it is not used anymore. Python
234 performs garbage collection via reference counting and a cyclic garbage
235 collector that is able to detect and break reference cycles.
Georg Brandl48310cd2009-01-03 21:18:54 +0000236
Guido van Rossumf10aa982007-08-17 18:30:38 +0000237 generator
Benjamin Peterson5478b472008-09-17 22:25:09 +0000238 A function which returns an iterator. It looks like a normal function
Raymond Hettingerbd204de2010-09-01 22:21:36 +0000239 except that it contains :keyword:`yield` statements for producing a series
240 a values usable in a for-loop or that can be retrieved one at a time with
241 the :func:`next` function. Each :keyword:`yield` temporarily suspends
242 processing, remembering the location execution state (including local
243 variables and pending try-statements). When the generator resumes, it
244 picks-up where it left-off (in contrast to functions which start fresh on
245 every invocation.
Georg Brandl48310cd2009-01-03 21:18:54 +0000246
Guido van Rossumf10aa982007-08-17 18:30:38 +0000247 .. index:: single: generator expression
Georg Brandl48310cd2009-01-03 21:18:54 +0000248
Guido van Rossumf10aa982007-08-17 18:30:38 +0000249 generator expression
250 An expression that returns a generator. It looks like a normal expression
251 followed by a :keyword:`for` expression defining a loop variable, range,
252 and an optional :keyword:`if` expression. The combined expression
253 generates values for an enclosing function::
Georg Brandl48310cd2009-01-03 21:18:54 +0000254
Guido van Rossumf10aa982007-08-17 18:30:38 +0000255 >>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
256 285
Georg Brandl48310cd2009-01-03 21:18:54 +0000257
Guido van Rossumf10aa982007-08-17 18:30:38 +0000258 GIL
259 See :term:`global interpreter lock`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000260
Guido van Rossumf10aa982007-08-17 18:30:38 +0000261 global interpreter lock
Antoine Pitrou6e7d7112011-01-06 16:34:50 +0000262 The mechanism used by the :term:`CPython` interpreter to assure that
263 only one thread executes Python :term:`bytecode` at a time.
264 This simplifies the CPython implementation by making the object model
265 (including critical built-in types such as :class:`dict`) implicitly
266 safe against concurrent access. Locking the entire interpreter
267 makes it easier for the interpreter to be multi-threaded, at the
268 expense of much of the parallelism afforded by multi-processor
269 machines.
270
271 However, some extension modules, either standard or third-party,
272 are designed so as to release the GIL when doing computationally-intensive
273 tasks such as compression or hashing. Also, the GIL is always released
274 when doing I/O.
275
276 Past efforts to create a "free-threaded" interpreter (one which locks
277 shared data at a much finer granularity) have not been successful
278 because performance suffered in the common single-processor case. It
279 is believed that overcoming this performance issue would make the
280 implementation much more complicated and therefore costlier to maintain.
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000281
282 hashable
Benjamin Peterson5478b472008-09-17 22:25:09 +0000283 An object is *hashable* if it has a hash value which never changes during
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000284 its lifetime (it needs a :meth:`__hash__` method), and can be compared to
Georg Brandl05f5ab72008-09-24 09:11:47 +0000285 other objects (it needs an :meth:`__eq__` method). Hashable objects which
286 compare equal must have the same hash value.
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000287
288 Hashability makes an object usable as a dictionary key and a set member,
289 because these data structures use the hash value internally.
290
Benjamin Peterson5478b472008-09-17 22:25:09 +0000291 All of Python's immutable built-in objects are hashable, while no mutable
292 containers (such as lists or dictionaries) are. Objects which are
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000293 instances of user-defined classes are hashable by default; they all
294 compare unequal, and their hash value is their :func:`id`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000295
Guido van Rossumf10aa982007-08-17 18:30:38 +0000296 IDLE
297 An Integrated Development Environment for Python. IDLE is a basic editor
Benjamin Peterson5478b472008-09-17 22:25:09 +0000298 and interpreter environment which ships with the standard distribution of
Raymond Hettingerbd204de2010-09-01 22:21:36 +0000299 Python.
Georg Brandl48310cd2009-01-03 21:18:54 +0000300
Guido van Rossumf10aa982007-08-17 18:30:38 +0000301 immutable
Benjamin Peterson5478b472008-09-17 22:25:09 +0000302 An object with a fixed value. Immutable objects include numbers, strings and
303 tuples. Such an object cannot be altered. A new object has to
Guido van Rossumf10aa982007-08-17 18:30:38 +0000304 be created if a different value has to be stored. They play an important
305 role in places where a constant hash value is needed, for example as a key
306 in a dictionary.
Benjamin Peterson2d718222008-11-21 00:25:02 +0000307
Brett Cannon51d4aab2009-01-25 04:21:39 +0000308 importer
309 An object that both finds and loads a module; both a
310 :term:`finder` and :term:`loader` object.
311
Guido van Rossumf10aa982007-08-17 18:30:38 +0000312 interactive
Benjamin Peterson5478b472008-09-17 22:25:09 +0000313 Python has an interactive interpreter which means you can enter
314 statements and expressions at the interpreter prompt, immediately
315 execute them and see their results. Just launch ``python`` with no
316 arguments (possibly by selecting it from your computer's main
317 menu). It is a very powerful way to test out new ideas or inspect
318 modules and packages (remember ``help(x)``).
Georg Brandl48310cd2009-01-03 21:18:54 +0000319
Guido van Rossumf10aa982007-08-17 18:30:38 +0000320 interpreted
Benjamin Peterson5478b472008-09-17 22:25:09 +0000321 Python is an interpreted language, as opposed to a compiled one,
322 though the distinction can be blurry because of the presence of the
323 bytecode compiler. This means that source files can be run directly
324 without explicitly creating an executable which is then run.
325 Interpreted languages typically have a shorter development/debug cycle
326 than compiled ones, though their programs generally also run more
327 slowly. See also :term:`interactive`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000328
Guido van Rossumf10aa982007-08-17 18:30:38 +0000329 iterable
330 A container object capable of returning its members one at a
331 time. Examples of iterables include all sequence types (such as
332 :class:`list`, :class:`str`, and :class:`tuple`) and some non-sequence
333 types like :class:`dict` and :class:`file` and objects of any classes you
334 define with an :meth:`__iter__` or :meth:`__getitem__` method. Iterables
335 can be used in a :keyword:`for` loop and in many other places where a
336 sequence is needed (:func:`zip`, :func:`map`, ...). When an iterable
Georg Brandlc5605df2009-08-13 08:26:44 +0000337 object is passed as an argument to the built-in function :func:`iter`, it
Guido van Rossumf10aa982007-08-17 18:30:38 +0000338 returns an iterator for the object. This iterator is good for one pass
339 over the set of values. When using iterables, it is usually not necessary
340 to call :func:`iter` or deal with iterator objects yourself. The ``for``
341 statement does that automatically for you, creating a temporary unnamed
342 variable to hold the iterator for the duration of the loop. See also
343 :term:`iterator`, :term:`sequence`, and :term:`generator`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000344
Guido van Rossumf10aa982007-08-17 18:30:38 +0000345 iterator
346 An object representing a stream of data. Repeated calls to the iterator's
Georg Brandl41d08152011-01-09 08:01:46 +0000347 :meth:`__next__` method (or passing it to the built-in function
348 :func:`next`) return successive items in the stream. When no more data
349 are available a :exc:`StopIteration` exception is raised instead. At this
Benjamin Petersone7c78b22008-07-03 20:28:26 +0000350 point, the iterator object is exhausted and any further calls to its
Georg Brandl41d08152011-01-09 08:01:46 +0000351 :meth:`__next__` method just raise :exc:`StopIteration` again. Iterators
352 are required to have an :meth:`__iter__` method that returns the iterator
Guido van Rossumf10aa982007-08-17 18:30:38 +0000353 object itself so every iterator is also iterable and may be used in most
354 places where other iterables are accepted. One notable exception is code
Benjamin Peterson5478b472008-09-17 22:25:09 +0000355 which attempts multiple iteration passes. A container object (such as a
Guido van Rossumf10aa982007-08-17 18:30:38 +0000356 :class:`list`) produces a fresh new iterator each time you pass it to the
357 :func:`iter` function or use it in a :keyword:`for` loop. Attempting this
358 with an iterator will just return the same exhausted iterator object used
359 in the previous iteration pass, making it appear like an empty container.
Georg Brandl48310cd2009-01-03 21:18:54 +0000360
Georg Brandl9afde1c2007-11-01 20:32:30 +0000361 More information can be found in :ref:`typeiter`.
362
Georg Brandleae40ba2010-11-05 07:11:47 +0000363 key function
364 A key function or collation function is a callable that returns a value
365 used for sorting or ordering. For example, :func:`locale.strxfrm` is
366 used to produce a sort key that is aware of locale specific sort
367 conventions.
368
369 A number of tools in Python accept key functions to control how elements
370 are ordered or grouped. They include :func:`min`, :func:`max`,
371 :func:`sorted`, :meth:`list.sort`, :func:`heapq.nsmallest`,
372 :func:`heapq.nlargest`, and :func:`itertools.groupby`.
373
374 There are several ways to create a key function. For example. the
375 :meth:`str.lower` method can serve as a key function for case insensitive
376 sorts. Alternatively, an ad-hoc key function can be built from a
377 :keyword:`lambda` expression such as ``lambda r: (r[0], r[2])``. Also,
378 the :mod:`operator` module provides three key function constuctors:
379 :func:`~operator.attrgetter`, :func:`~operator.itemgetter`, and
380 :func:`~operator.methodcaller`. See the :ref:`Sorting HOW TO
381 <sortinghowto>` for examples of how to create and use key functions.
382
Christian Heimesd8654cf2007-12-02 15:22:16 +0000383 keyword argument
384 Arguments which are preceded with a ``variable_name=`` in the call.
385 The variable name designates the local name in the function to which the
386 value is assigned. ``**`` is used to accept or pass a dictionary of
387 keyword arguments. See :term:`argument`.
388
389 lambda
390 An anonymous inline function consisting of a single :term:`expression`
391 which is evaluated when the function is called. The syntax to create
392 a lambda function is ``lambda [arguments]: expression``
393
Guido van Rossumf10aa982007-08-17 18:30:38 +0000394 LBYL
395 Look before you leap. This coding style explicitly tests for
396 pre-conditions before making calls or lookups. This style contrasts with
397 the :term:`EAFP` approach and is characterized by the presence of many
398 :keyword:`if` statements.
Benjamin Peterson5478b472008-09-17 22:25:09 +0000399
400 list
401 A built-in Python :term:`sequence`. Despite its name it is more akin
402 to an array in other languages than to a linked list since access to
403 elements are O(1).
Georg Brandl48310cd2009-01-03 21:18:54 +0000404
Guido van Rossumf10aa982007-08-17 18:30:38 +0000405 list comprehension
Benjamin Peterson5478b472008-09-17 22:25:09 +0000406 A compact way to process all or part of the elements in a sequence and
Georg Brandl31a0f862010-07-04 17:33:33 +0000407 return a list with the results. ``result = ['{:#04x}'.format(x) for x in
Benjamin Peterson5478b472008-09-17 22:25:09 +0000408 range(256) if x % 2 == 0]`` generates a list of strings containing
409 even hex numbers (0x..) in the range from 0 to 255. The :keyword:`if`
410 clause is optional. If omitted, all elements in ``range(256)`` are
411 processed.
Georg Brandl48310cd2009-01-03 21:18:54 +0000412
Brett Cannon51d4aab2009-01-25 04:21:39 +0000413 loader
414 An object that loads a module. It must define a method named
415 :meth:`load_module`. A loader is typically returned by a
Brett Cannone43b0602009-03-21 03:11:16 +0000416 :term:`finder`. See :pep:`302` for details and
417 :class:`importlib.abc.Loader` for an :term:`abstract base class`.
Brett Cannon51d4aab2009-01-25 04:21:39 +0000418
Guido van Rossumf10aa982007-08-17 18:30:38 +0000419 mapping
Benjamin Peterson5478b472008-09-17 22:25:09 +0000420 A container object (such as :class:`dict`) which supports arbitrary key
Raymond Hettingerbd204de2010-09-01 22:21:36 +0000421 lookups using the special method :meth:`__getitem__`. Mappings also
422 support :meth:`__len__`, :meth:`__iter__`, and :meth:`__contains__`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000423
Guido van Rossumf10aa982007-08-17 18:30:38 +0000424 metaclass
425 The class of a class. Class definitions create a class name, a class
426 dictionary, and a list of base classes. The metaclass is responsible for
427 taking those three arguments and creating the class. Most object oriented
428 programming languages provide a default implementation. What makes Python
429 special is that it is possible to create custom metaclasses. Most users
430 never need this tool, but when the need arises, metaclasses can provide
431 powerful, elegant solutions. They have been used for logging attribute
432 access, adding thread-safety, tracking object creation, implementing
433 singletons, and many other tasks.
Georg Brandl9afde1c2007-11-01 20:32:30 +0000434
435 More information can be found in :ref:`metaclasses`.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000436
437 method
Benjamin Peterson5478b472008-09-17 22:25:09 +0000438 A function which is defined inside a class body. If called as an attribute
Christian Heimesd8654cf2007-12-02 15:22:16 +0000439 of an instance of that class, the method will get the instance object as
440 its first :term:`argument` (which is usually called ``self``).
441 See :term:`function` and :term:`nested scope`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000442
Guido van Rossumf10aa982007-08-17 18:30:38 +0000443 mutable
444 Mutable objects can change their value but keep their :func:`id`. See
445 also :term:`immutable`.
Christian Heimes25bb7832008-01-11 16:17:00 +0000446
447 named tuple
Raymond Hettingerd04fa312009-02-04 19:45:13 +0000448 Any tuple-like class whose indexable elements are also accessible using
Christian Heimesd32ed6f2008-01-14 18:49:24 +0000449 named attributes (for example, :func:`time.localtime` returns a
450 tuple-like object where the *year* is accessible either with an
451 index such as ``t[0]`` or with a named attribute like ``t.tm_year``).
452
453 A named tuple can be a built-in type such as :class:`time.struct_time`,
454 or it can be created with a regular class definition. A full featured
455 named tuple can also be created with the factory function
456 :func:`collections.namedtuple`. The latter approach automatically
457 provides extra features such as a self-documenting representation like
458 ``Employee(name='jones', title='programmer')``.
Georg Brandl48310cd2009-01-03 21:18:54 +0000459
Guido van Rossumf10aa982007-08-17 18:30:38 +0000460 namespace
461 The place where a variable is stored. Namespaces are implemented as
Georg Brandlc5605df2009-08-13 08:26:44 +0000462 dictionaries. There are the local, global and built-in namespaces as well
Guido van Rossumf10aa982007-08-17 18:30:38 +0000463 as nested namespaces in objects (in methods). Namespaces support
464 modularity by preventing naming conflicts. For instance, the functions
Georg Brandl1a3284e2007-12-02 09:40:06 +0000465 :func:`builtins.open` and :func:`os.open` are distinguished by their
Guido van Rossumf10aa982007-08-17 18:30:38 +0000466 namespaces. Namespaces also aid readability and maintainability by making
467 it clear which module implements a function. For instance, writing
468 :func:`random.seed` or :func:`itertools.izip` makes it clear that those
469 functions are implemented by the :mod:`random` and :mod:`itertools`
Benjamin Peterson5478b472008-09-17 22:25:09 +0000470 modules, respectively.
Georg Brandl48310cd2009-01-03 21:18:54 +0000471
Guido van Rossumf10aa982007-08-17 18:30:38 +0000472 nested scope
473 The ability to refer to a variable in an enclosing definition. For
474 instance, a function defined inside another function can refer to
Benjamin Petersonf6f3f532010-06-29 18:40:09 +0000475 variables in the outer function. Note that nested scopes by default work
476 only for reference and not for assignment. Local variables both read and
477 write in the innermost scope. Likewise, global variables read and write
478 to the global namespace. The :keyword:`nonlocal` allows writing to outer
479 scopes.
Georg Brandl48310cd2009-01-03 21:18:54 +0000480
Guido van Rossumf10aa982007-08-17 18:30:38 +0000481 new-style class
Georg Brandl85eb8c12007-08-31 16:33:38 +0000482 Old name for the flavor of classes now used for all class objects. In
483 earlier Python versions, only new-style classes could use Python's newer,
484 versatile features like :attr:`__slots__`, descriptors, properties,
485 :meth:`__getattribute__`, class methods, and static methods.
Georg Brandl9afde1c2007-11-01 20:32:30 +0000486
Benjamin Peterson5478b472008-09-17 22:25:09 +0000487 object
488 Any data with state (attributes or value) and defined behavior
489 (methods). Also the ultimate base class of any :term:`new-style
490 class`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000491
Christian Heimesd8654cf2007-12-02 15:22:16 +0000492 positional argument
493 The arguments assigned to local names inside a function or method,
494 determined by the order in which they were given in the call. ``*`` is
495 used to either accept multiple positional arguments (when in the
496 definition), or pass several arguments as a list to a function. See
497 :term:`argument`.
498
Guido van Rossumf10aa982007-08-17 18:30:38 +0000499 Python 3000
Benjamin Peterson1e2f0502008-05-26 12:52:02 +0000500 Nickname for the Python 3.x release line (coined long ago when the release
501 of version 3 was something in the distant future.) This is also
502 abbreviated "Py3k".
Guido van Rossumf10aa982007-08-17 18:30:38 +0000503
Christian Heimesd8654cf2007-12-02 15:22:16 +0000504 Pythonic
Benjamin Peterson5478b472008-09-17 22:25:09 +0000505 An idea or piece of code which closely follows the most common idioms
506 of the Python language, rather than implementing code using concepts
507 common to other languages. For example, a common idiom in Python is
508 to loop over all elements of an iterable using a :keyword:`for`
509 statement. Many other languages don't have this type of construct, so
510 people unfamiliar with Python sometimes use a numerical counter instead::
Georg Brandl48310cd2009-01-03 21:18:54 +0000511
Christian Heimesd8654cf2007-12-02 15:22:16 +0000512 for i in range(len(food)):
Georg Brandla09ca382007-12-02 18:20:12 +0000513 print(food[i])
Christian Heimesd8654cf2007-12-02 15:22:16 +0000514
515 As opposed to the cleaner, Pythonic method::
516
517 for piece in food:
Georg Brandla09ca382007-12-02 18:20:12 +0000518 print(piece)
Christian Heimesd8654cf2007-12-02 15:22:16 +0000519
Guido van Rossumf10aa982007-08-17 18:30:38 +0000520 reference count
Benjamin Peterson5478b472008-09-17 22:25:09 +0000521 The number of references to an object. When the reference count of an
522 object drops to zero, it is deallocated. Reference counting is
523 generally not visible to Python code, but it is a key element of the
524 :term:`CPython` implementation. The :mod:`sys` module defines a
Georg Brandl31a0f862010-07-04 17:33:33 +0000525 :func:`~sys.getrefcount` function that programmers can call to return the
Benjamin Peterson5478b472008-09-17 22:25:09 +0000526 reference count for a particular object.
527
Guido van Rossumf10aa982007-08-17 18:30:38 +0000528 __slots__
Georg Brandl85eb8c12007-08-31 16:33:38 +0000529 A declaration inside a class that saves memory by pre-declaring space for
530 instance attributes and eliminating instance dictionaries. Though
531 popular, the technique is somewhat tricky to get right and is best
532 reserved for rare cases where there are large numbers of instances in a
533 memory-critical application.
Georg Brandl48310cd2009-01-03 21:18:54 +0000534
Guido van Rossumf10aa982007-08-17 18:30:38 +0000535 sequence
536 An :term:`iterable` which supports efficient element access using integer
Benjamin Peterson5478b472008-09-17 22:25:09 +0000537 indices via the :meth:`__getitem__` special method and defines a
538 :meth:`len` method that returns the length of the sequence.
Guido van Rossumf10aa982007-08-17 18:30:38 +0000539 Some built-in sequence types are :class:`list`, :class:`str`,
Georg Brandl2ae8ac22009-02-05 10:40:48 +0000540 :class:`tuple`, and :class:`bytes`. Note that :class:`dict` also
Guido van Rossumf10aa982007-08-17 18:30:38 +0000541 supports :meth:`__getitem__` and :meth:`__len__`, but is considered a
542 mapping rather than a sequence because the lookups use arbitrary
543 :term:`immutable` keys rather than integers.
544
Christian Heimesd8654cf2007-12-02 15:22:16 +0000545 slice
Georg Brandlc6fe37b2007-12-03 21:07:25 +0000546 An object usually containing a portion of a :term:`sequence`. A slice is
Christian Heimesd8654cf2007-12-02 15:22:16 +0000547 created using the subscript notation, ``[]`` with colons between numbers
548 when several are given, such as in ``variable_name[1:3:5]``. The bracket
Georg Brandla09ca382007-12-02 18:20:12 +0000549 (subscript) notation uses :class:`slice` objects internally.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000550
Georg Brandlaf265f42008-12-07 15:06:20 +0000551 special method
552 A method that is called implicitly by Python to execute a certain
553 operation on a type, such as addition. Such methods have names starting
554 and ending with double underscores. Special methods are documented in
555 :ref:`specialnames`.
556
Christian Heimesd8654cf2007-12-02 15:22:16 +0000557 statement
558 A statement is part of a suite (a "block" of code). A statement is either
559 an :term:`expression` or a one of several constructs with a keyword, such
Georg Brandla09ca382007-12-02 18:20:12 +0000560 as :keyword:`if`, :keyword:`while` or :keyword:`for`.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000561
Benjamin Peterson5478b472008-09-17 22:25:09 +0000562 triple-quoted string
563 A string which is bound by three instances of either a quotation mark
564 (") or an apostrophe ('). While they don't provide any functionality
565 not available with single-quoted strings, they are useful for a number
566 of reasons. They allow you to include unescaped single and double
567 quotes within a string and they can span multiple lines without the
568 use of the continuation character, making them especially useful when
569 writing docstrings.
570
Guido van Rossumf10aa982007-08-17 18:30:38 +0000571 type
572 The type of a Python object determines what kind of object it is; every
573 object has a type. An object's type is accessible as its
574 :attr:`__class__` attribute or can be retrieved with ``type(obj)``.
Benjamin Peterson5478b472008-09-17 22:25:09 +0000575
Benjamin Peterson656aa282008-11-21 23:22:00 +0000576 view
Ezio Melotti619de8f2009-06-25 18:39:31 +0000577 The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and
Benjamin Peterson656aa282008-11-21 23:22:00 +0000578 :meth:`dict.items` are called dictionary views. They are lazy sequences
579 that will see changes in the underlying dictionary. To force the
580 dictionary view to become a full list use ``list(dictview)``. See
581 :ref:`dict-views`.
582
Benjamin Peterson5478b472008-09-17 22:25:09 +0000583 virtual machine
584 A computer defined entirely in software. Python's virtual machine
585 executes the :term:`bytecode` emitted by the bytecode compiler.
Georg Brandl48310cd2009-01-03 21:18:54 +0000586
Guido van Rossumf10aa982007-08-17 18:30:38 +0000587 Zen of Python
588 Listing of Python design principles and philosophies that are helpful in
589 understanding and using the language. The listing can be found by typing
590 "``import this``" at the interactive prompt.