blob: df470515d61ce557cb0e523645ed7466032b5330 [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 Brandl6faee4e2010-09-21 14:48:28 +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
Éric Araujofa088db2011-06-04 18:42:38 +020030 Abstract base classes complement :term:`duck-typing` by
Georg Brandl22b34312009-07-26 14:54:51 +000031 providing a way to define interfaces when other techniques like
Éric Araujofa088db2011-06-04 18:42:38 +020032 :func:`hasattr` would be clumsy or subtly wrong (for example with
Éric Araujo04ac59a2011-08-19 09:07:46 +020033 :ref:`magic methods <special-lookup>`). ABCs introduce virtual
34 subclasses, which are classes that don't inherit from a class but are
35 still recognized by :func:`isinstance` and :func:`issubclass`; see the
36 :mod:`abc` module documentation. Python comes with many built-in ABCs for
Éric Araujo459b4522011-06-04 21:16:42 +020037 data structures (in the :mod:`collections.abc` module), numbers (in the
Éric Araujofa088db2011-06-04 18:42:38 +020038 :mod:`numbers` module), streams (in the :mod:`io` module), import finders
39 and loaders (in the :mod:`importlib.abc` module). You can create your own
40 ABCs with the :mod:`abc` module.
Benjamin Peterson41181742008-07-02 20:22:54 +000041
Christian Heimesd8654cf2007-12-02 15:22:16 +000042 argument
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -080043 A value passed to a :term:`function` (or :term:`method`) when calling the
Zachary Waree1391a02013-11-22 13:58:34 -060044 function. There are two kinds of argument:
Christian Heimesd8654cf2007-12-02 15:22:16 +000045
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -080046 * :dfn:`keyword argument`: an argument preceded by an identifier (e.g.
47 ``name=``) in a function call or passed as a value in a dictionary
48 preceded by ``**``. For example, ``3`` and ``5`` are both keyword
49 arguments in the following calls to :func:`complex`::
50
51 complex(real=3, imag=5)
52 complex(**{'real': 3, 'imag': 5})
53
54 * :dfn:`positional argument`: an argument that is not a keyword argument.
55 Positional arguments can appear at the beginning of an argument list
56 and/or be passed as elements of an :term:`iterable` preceded by ``*``.
57 For example, ``3`` and ``5`` are both positional arguments in the
58 following calls::
59
60 complex(3, 5)
61 complex(*(3, 5))
62
63 Arguments are assigned to the named local variables in a function body.
64 See the :ref:`calls` section for the rules governing this assignment.
65 Syntactically, any expression can be used to represent an argument; the
66 evaluated value is assigned to the local variable.
67
68 See also the :term:`parameter` glossary entry, the FAQ question on
69 :ref:`the difference between arguments and parameters
70 <faq-argument-vs-parameter>`, and :pep:`362`.
Benjamin Peterson5478b472008-09-17 22:25:09 +000071
72 attribute
73 A value associated with an object which is referenced by name using
74 dotted expressions. For example, if an object *o* has an attribute
75 *a* it would be referenced as *o.a*.
Georg Brandl48310cd2009-01-03 21:18:54 +000076
Guido van Rossumf10aa982007-08-17 18:30:38 +000077 BDFL
78 Benevolent Dictator For Life, a.k.a. `Guido van Rossum
79 <http://www.python.org/~guido/>`_, Python's creator.
Georg Brandl48310cd2009-01-03 21:18:54 +000080
Ezio Melottiaa54e2f2013-04-30 23:33:31 +030081 bytes-like object
Antoine Pitrou5de183a2013-05-04 20:18:34 +020082 An object that supports the :ref:`bufferobjects`, like :class:`bytes`,
83 :class:`bytearray` or :class:`memoryview`. Bytes-like objects can
84 be used for various operations that expect binary data, such as
85 compression, saving to a binary file or sending over a socket.
86 Some operations need the binary data to be mutable, in which case
87 not all bytes-like objects can apply.
Ezio Melottiaa54e2f2013-04-30 23:33:31 +030088
Georg Brandl9afde1c2007-11-01 20:32:30 +000089 bytecode
90 Python source code is compiled into bytecode, the internal representation
Brett Cannon8315fd12010-07-02 22:03:00 +000091 of a Python program in the CPython interpreter. The bytecode is also
92 cached in ``.pyc`` and ``.pyo`` files so that executing the same file is
93 faster the second time (recompilation from source to bytecode can be
94 avoided). This "intermediate language" is said to run on a
95 :term:`virtual machine` that executes the machine code corresponding to
96 each bytecode. Do note that bytecodes are not expected to work between
97 different Python virtual machines, nor to be stable between Python
98 releases.
Benjamin Peterson5478b472008-09-17 22:25:09 +000099
Georg Brandl2cb72d32010-07-03 10:26:54 +0000100 A list of bytecode instructions can be found in the documentation for
101 :ref:`the dis module <bytecodes>`.
102
Benjamin Peterson5478b472008-09-17 22:25:09 +0000103 class
104 A template for creating user-defined objects. Class definitions
105 normally contain method definitions which operate on instances of the
106 class.
Georg Brandl48310cd2009-01-03 21:18:54 +0000107
Benjamin Peterson5478b472008-09-17 22:25:09 +0000108 coercion
109 The implicit conversion of an instance of one type to another during an
110 operation which involves two arguments of the same type. For example,
111 ``int(3.15)`` converts the floating point number to the integer ``3``, but
112 in ``3+4.5``, each argument is of a different type (one int, one float),
113 and both must be converted to the same type before they can be added or it
Benjamin Peterson2d718222008-11-21 00:25:02 +0000114 will raise a ``TypeError``. Without coercion, all arguments of even
Benjamin Peterson5478b472008-09-17 22:25:09 +0000115 compatible types would have to be normalized to the same value by the
116 programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``.
Georg Brandl48310cd2009-01-03 21:18:54 +0000117
Guido van Rossumf10aa982007-08-17 18:30:38 +0000118 complex number
119 An extension of the familiar real number system in which all numbers are
120 expressed as a sum of a real part and an imaginary part. Imaginary
121 numbers are real multiples of the imaginary unit (the square root of
122 ``-1``), often written ``i`` in mathematics or ``j`` in
Georg Brandl22b34312009-07-26 14:54:51 +0000123 engineering. Python has built-in support for complex numbers, which are
Guido van Rossumf10aa982007-08-17 18:30:38 +0000124 written with this latter notation; the imaginary part is written with a
125 ``j`` suffix, e.g., ``3+1j``. To get access to complex equivalents of the
126 :mod:`math` module, use :mod:`cmath`. Use of complex numbers is a fairly
127 advanced mathematical feature. If you're not aware of a need for them,
128 it's almost certain you can safely ignore them.
Georg Brandl48310cd2009-01-03 21:18:54 +0000129
Christian Heimes895627f2007-12-08 17:28:33 +0000130 context manager
Benjamin Peterson5478b472008-09-17 22:25:09 +0000131 An object which controls the environment seen in a :keyword:`with`
Christian Heimes895627f2007-12-08 17:28:33 +0000132 statement by defining :meth:`__enter__` and :meth:`__exit__` methods.
133 See :pep:`343`.
134
Benjamin Peterson5478b472008-09-17 22:25:09 +0000135 CPython
Antoine Pitrou00342812011-01-06 16:31:28 +0000136 The canonical implementation of the Python programming language, as
137 distributed on `python.org <http://python.org>`_. The term "CPython"
138 is used when necessary to distinguish this implementation from others
139 such as Jython or IronPython.
Benjamin Peterson5478b472008-09-17 22:25:09 +0000140
Christian Heimesd8654cf2007-12-02 15:22:16 +0000141 decorator
142 A function returning another function, usually applied as a function
143 transformation using the ``@wrapper`` syntax. Common examples for
144 decorators are :func:`classmethod` and :func:`staticmethod`.
145
146 The decorator syntax is merely syntactic sugar, the following two
147 function definitions are semantically equivalent::
148
149 def f(...):
150 ...
151 f = staticmethod(f)
152
153 @staticmethod
154 def f(...):
155 ...
156
Georg Brandlaf265f42008-12-07 15:06:20 +0000157 The same concept exists for classes, but is less commonly used there. See
158 the documentation for :ref:`function definitions <function>` and
159 :ref:`class definitions <class>` for more about decorators.
Georg Brandla09ca382007-12-02 18:20:12 +0000160
Guido van Rossumf10aa982007-08-17 18:30:38 +0000161 descriptor
Benjamin Peterson5478b472008-09-17 22:25:09 +0000162 Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or
Georg Brandl85eb8c12007-08-31 16:33:38 +0000163 :meth:`__delete__`. When a class attribute is a descriptor, its special
Georg Brandl9afde1c2007-11-01 20:32:30 +0000164 binding behavior is triggered upon attribute lookup. Normally, using
165 *a.b* to get, set or delete an attribute looks up the object named *b* in
166 the class dictionary for *a*, but if *b* is a descriptor, the respective
167 descriptor method gets called. Understanding descriptors is a key to a
168 deep understanding of Python because they are the basis for many features
169 including functions, methods, properties, class methods, static methods,
170 and reference to super classes.
171
172 For more information about descriptors' methods, see :ref:`descriptors`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000173
Guido van Rossumf10aa982007-08-17 18:30:38 +0000174 dictionary
Senthil Kumaran6080db72012-03-12 10:05:34 -0700175 An associative array, where arbitrary keys are mapped to values. The
176 keys can be any object with :meth:`__hash__` and :meth:`__eq__` methods.
177 Called a hash in Perl.
Georg Brandl3dbca812008-07-23 16:10:53 +0000178
179 docstring
Benjamin Peterson5478b472008-09-17 22:25:09 +0000180 A string literal which appears as the first expression in a class,
181 function or module. While ignored when the suite is executed, it is
182 recognized by the compiler and put into the :attr:`__doc__` attribute
183 of the enclosing class, function or module. Since it is available via
184 introspection, it is the canonical place for documentation of the
Georg Brandl3dbca812008-07-23 16:10:53 +0000185 object.
Georg Brandl48310cd2009-01-03 21:18:54 +0000186
187 duck-typing
Georg Brandl73b1c7b2010-07-10 10:39:57 +0000188 A programming style which does not look at an object's type to determine
189 if it has the right interface; instead, the method or attribute is simply
190 called or used ("If it looks like a duck and quacks like a duck, it
Guido van Rossumf10aa982007-08-17 18:30:38 +0000191 must be a duck.") By emphasizing interfaces rather than specific types,
192 well-designed code improves its flexibility by allowing polymorphic
193 substitution. Duck-typing avoids tests using :func:`type` or
Georg Brandl8a1c2542010-07-11 08:36:20 +0000194 :func:`isinstance`. (Note, however, that duck-typing can be complemented
Éric Araujo0519b092011-08-19 00:39:19 +0200195 with :term:`abstract base classes <abstract base class>`.) Instead, it
196 typically employs :func:`hasattr` tests or :term:`EAFP` programming.
Georg Brandl48310cd2009-01-03 21:18:54 +0000197
Guido van Rossumf10aa982007-08-17 18:30:38 +0000198 EAFP
199 Easier to ask for forgiveness than permission. This common Python coding
200 style assumes the existence of valid keys or attributes and catches
201 exceptions if the assumption proves false. This clean and fast style is
202 characterized by the presence of many :keyword:`try` and :keyword:`except`
Georg Brandl48310cd2009-01-03 21:18:54 +0000203 statements. The technique contrasts with the :term:`LBYL` style
Benjamin Peterson5478b472008-09-17 22:25:09 +0000204 common to many other languages such as C.
Guido van Rossumf10aa982007-08-17 18:30:38 +0000205
Christian Heimesd8654cf2007-12-02 15:22:16 +0000206 expression
207 A piece of syntax which can be evaluated to some value. In other words,
Benjamin Peterson5478b472008-09-17 22:25:09 +0000208 an expression is an accumulation of expression elements like literals,
209 names, attribute access, operators or function calls which all return a
210 value. In contrast to many other languages, not all language constructs
211 are expressions. There are also :term:`statement`\s which cannot be used
212 as expressions, such as :keyword:`if`. Assignments are also statements,
213 not expressions.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000214
Guido van Rossumf10aa982007-08-17 18:30:38 +0000215 extension module
Georg Brandl9d9848e2010-12-28 11:48:53 +0000216 A module written in C or C++, using Python's C API to interact with the
217 core and with user code.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000218
Antoine Pitrou0b65b0f2010-09-15 09:58:26 +0000219 file object
220 An object exposing a file-oriented API (with methods such as
Georg Brandl9d9848e2010-12-28 11:48:53 +0000221 :meth:`read()` or :meth:`write()`) to an underlying resource. Depending
222 on the way it was created, a file object can mediate access to a real
Eli Benderskydbaedb82012-03-30 11:02:05 +0300223 on-disk file or to another type of storage or communication device
Georg Brandl9d9848e2010-12-28 11:48:53 +0000224 (for example standard input/output, in-memory buffers, sockets, pipes,
225 etc.). File objects are also called :dfn:`file-like objects` or
226 :dfn:`streams`.
Antoine Pitrou0b65b0f2010-09-15 09:58:26 +0000227
Georg Brandl9d9848e2010-12-28 11:48:53 +0000228 There are actually three categories of file objects: raw binary files,
229 buffered binary files and text files. Their interfaces are defined in the
230 :mod:`io` module. The canonical way to create a file object is by using
231 the :func:`open` function.
Antoine Pitrou0b65b0f2010-09-15 09:58:26 +0000232
233 file-like object
234 A synonym for :term:`file object`.
235
Brett Cannon51d4aab2009-01-25 04:21:39 +0000236 finder
237 An object that tries to find the :term:`loader` for a module. It must
Barry Warsawd7d21942012-07-29 16:36:17 -0400238 implement either a method named :meth:`find_loader` or a method named
239 :meth:`find_module`. See :pep:`302` and :pep:`420` for details and
240 :class:`importlib.abc.Finder` for an :term:`abstract base class`.
Brett Cannon51d4aab2009-01-25 04:21:39 +0000241
Benjamin Peterson2d718222008-11-21 00:25:02 +0000242 floor division
Raymond Hettingerf37ca3c2010-09-01 22:11:53 +0000243 Mathematical division that rounds down to nearest integer. The floor
244 division operator is ``//``. For example, the expression ``11 // 4``
245 evaluates to ``2`` in contrast to the ``2.75`` returned by float true
246 division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75``
247 rounded *downward*. See :pep:`238`.
Benjamin Peterson2d718222008-11-21 00:25:02 +0000248
Christian Heimesd8654cf2007-12-02 15:22:16 +0000249 function
250 A series of statements which returns some value to a caller. It can also
Chris Jerdonekb4309942012-12-25 14:54:44 -0800251 be passed zero or more :term:`arguments <argument>` which may be used in
252 the execution of the body. See also :term:`parameter`, :term:`method`,
253 and the :ref:`function` section.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000254
R David Murray25cd0912013-05-06 12:58:16 -0400255 function annotation
256 An arbitrary metadata value associated with a function parameter or return
257 value. Its syntax is explained in section :ref:`function`. Annotations
258 may be accessed via the :attr:`__annotations__` special attribute of a
259 function object.
260
261 Python itself does not assign any particular meaning to function
262 annotations. They are intended to be interpreted by third-party libraries
263 or tools. See :pep:`3107`, which describes some of their potential uses.
264
Guido van Rossumf10aa982007-08-17 18:30:38 +0000265 __future__
Raymond Hettingerf37ca3c2010-09-01 22:11:53 +0000266 A pseudo-module which programmers can use to enable new language features
Benjamin Peterson2d718222008-11-21 00:25:02 +0000267 which are not compatible with the current interpreter.
268
269 By importing the :mod:`__future__` module and evaluating its variables,
270 you can see when a new feature was first added to the language and when it
271 becomes the default::
Georg Brandl48310cd2009-01-03 21:18:54 +0000272
Guido van Rossumf10aa982007-08-17 18:30:38 +0000273 >>> import __future__
274 >>> __future__.division
275 _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
276
277 garbage collection
278 The process of freeing memory when it is not used anymore. Python
279 performs garbage collection via reference counting and a cyclic garbage
280 collector that is able to detect and break reference cycles.
Georg Brandl48310cd2009-01-03 21:18:54 +0000281
Benjamin Peterson08bf91c2010-04-11 16:12:57 +0000282 .. index:: single: generator
283
Guido van Rossumf10aa982007-08-17 18:30:38 +0000284 generator
Benjamin Peterson5478b472008-09-17 22:25:09 +0000285 A function which returns an iterator. It looks like a normal function
Raymond Hettingerf37ca3c2010-09-01 22:11:53 +0000286 except that it contains :keyword:`yield` statements for producing a series
287 a values usable in a for-loop or that can be retrieved one at a time with
288 the :func:`next` function. Each :keyword:`yield` temporarily suspends
289 processing, remembering the location execution state (including local
290 variables and pending try-statements). When the generator resumes, it
291 picks-up where it left-off (in contrast to functions which start fresh on
Éric Araujoe0854f92011-05-27 04:36:52 +0200292 every invocation).
Georg Brandl48310cd2009-01-03 21:18:54 +0000293
Guido van Rossumf10aa982007-08-17 18:30:38 +0000294 .. index:: single: generator expression
Georg Brandl48310cd2009-01-03 21:18:54 +0000295
Guido van Rossumf10aa982007-08-17 18:30:38 +0000296 generator expression
Benjamin Peterson08bf91c2010-04-11 16:12:57 +0000297 An expression that returns an iterator. It looks like a normal expression
Guido van Rossumf10aa982007-08-17 18:30:38 +0000298 followed by a :keyword:`for` expression defining a loop variable, range,
299 and an optional :keyword:`if` expression. The combined expression
300 generates values for an enclosing function::
Georg Brandl48310cd2009-01-03 21:18:54 +0000301
Guido van Rossumf10aa982007-08-17 18:30:38 +0000302 >>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
303 285
Georg Brandl48310cd2009-01-03 21:18:54 +0000304
Łukasz Langafdcf2b72013-06-07 22:54:03 +0200305 generic function
306 A function composed of multiple functions implementing the same operation
307 for different types. Which implementation should be used during a call is
308 determined by the dispatch algorithm.
309
310 See also the :term:`single dispatch` glossary entry, the
311 :func:`functools.singledispatch` decorator, and :pep:`443`.
312
313
Guido van Rossumf10aa982007-08-17 18:30:38 +0000314 GIL
315 See :term:`global interpreter lock`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000316
Guido van Rossumf10aa982007-08-17 18:30:38 +0000317 global interpreter lock
Antoine Pitrou00342812011-01-06 16:31:28 +0000318 The mechanism used by the :term:`CPython` interpreter to assure that
319 only one thread executes Python :term:`bytecode` at a time.
320 This simplifies the CPython implementation by making the object model
321 (including critical built-in types such as :class:`dict`) implicitly
322 safe against concurrent access. Locking the entire interpreter
323 makes it easier for the interpreter to be multi-threaded, at the
324 expense of much of the parallelism afforded by multi-processor
325 machines.
326
327 However, some extension modules, either standard or third-party,
328 are designed so as to release the GIL when doing computationally-intensive
329 tasks such as compression or hashing. Also, the GIL is always released
330 when doing I/O.
331
332 Past efforts to create a "free-threaded" interpreter (one which locks
333 shared data at a much finer granularity) have not been successful
334 because performance suffered in the common single-processor case. It
335 is believed that overcoming this performance issue would make the
336 implementation much more complicated and therefore costlier to maintain.
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000337
338 hashable
Benjamin Peterson5478b472008-09-17 22:25:09 +0000339 An object is *hashable* if it has a hash value which never changes during
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000340 its lifetime (it needs a :meth:`__hash__` method), and can be compared to
Georg Brandl05f5ab72008-09-24 09:11:47 +0000341 other objects (it needs an :meth:`__eq__` method). Hashable objects which
342 compare equal must have the same hash value.
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000343
344 Hashability makes an object usable as a dictionary key and a set member,
345 because these data structures use the hash value internally.
346
Benjamin Peterson5478b472008-09-17 22:25:09 +0000347 All of Python's immutable built-in objects are hashable, while no mutable
348 containers (such as lists or dictionaries) are. Objects which are
Guido van Rossum2cc30da2007-11-02 23:46:40 +0000349 instances of user-defined classes are hashable by default; they all
Ezio Melotti188ad852013-02-01 05:18:44 +0200350 compare unequal (except with themselves), and their hash value is their
351 :func:`id`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000352
Guido van Rossumf10aa982007-08-17 18:30:38 +0000353 IDLE
354 An Integrated Development Environment for Python. IDLE is a basic editor
Benjamin Peterson5478b472008-09-17 22:25:09 +0000355 and interpreter environment which ships with the standard distribution of
Raymond Hettingerf37ca3c2010-09-01 22:11:53 +0000356 Python.
Georg Brandl48310cd2009-01-03 21:18:54 +0000357
Guido van Rossumf10aa982007-08-17 18:30:38 +0000358 immutable
Benjamin Peterson5478b472008-09-17 22:25:09 +0000359 An object with a fixed value. Immutable objects include numbers, strings and
360 tuples. Such an object cannot be altered. A new object has to
Guido van Rossumf10aa982007-08-17 18:30:38 +0000361 be created if a different value has to be stored. They play an important
362 role in places where a constant hash value is needed, for example as a key
363 in a dictionary.
Benjamin Peterson2d718222008-11-21 00:25:02 +0000364
Barry Warsawdadebab2012-07-31 16:03:09 -0400365 import path
366 A list of locations (or :term:`path entries <path entry>`) that are
Nick Coghlan1685db02012-08-20 13:49:08 +1000367 searched by the :term:`path based finder` for modules to import. During
Barry Warsawdadebab2012-07-31 16:03:09 -0400368 import, this list of locations usually comes from :data:`sys.path`, but
369 for subpackages it may also come from the parent package's ``__path__``
370 attribute.
371
Barry Warsawd7d21942012-07-29 16:36:17 -0400372 importing
373 The process by which Python code in one module is made available to
374 Python code in another module.
375
Brett Cannon51d4aab2009-01-25 04:21:39 +0000376 importer
377 An object that both finds and loads a module; both a
378 :term:`finder` and :term:`loader` object.
379
Guido van Rossumf10aa982007-08-17 18:30:38 +0000380 interactive
Benjamin Peterson5478b472008-09-17 22:25:09 +0000381 Python has an interactive interpreter which means you can enter
382 statements and expressions at the interpreter prompt, immediately
383 execute them and see their results. Just launch ``python`` with no
384 arguments (possibly by selecting it from your computer's main
385 menu). It is a very powerful way to test out new ideas or inspect
386 modules and packages (remember ``help(x)``).
Georg Brandl48310cd2009-01-03 21:18:54 +0000387
Guido van Rossumf10aa982007-08-17 18:30:38 +0000388 interpreted
Benjamin Peterson5478b472008-09-17 22:25:09 +0000389 Python is an interpreted language, as opposed to a compiled one,
390 though the distinction can be blurry because of the presence of the
391 bytecode compiler. This means that source files can be run directly
392 without explicitly creating an executable which is then run.
393 Interpreted languages typically have a shorter development/debug cycle
394 than compiled ones, though their programs generally also run more
395 slowly. See also :term:`interactive`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000396
Guido van Rossumf10aa982007-08-17 18:30:38 +0000397 iterable
Ezio Melottid581fff2013-01-02 22:29:09 +0200398 An object capable of returning its members one at a time. Examples of
399 iterables include all sequence types (such as :class:`list`, :class:`str`,
400 and :class:`tuple`) and some non-sequence types like :class:`dict`,
401 :term:`file objects <file object>`, and objects of any classes you define
402 with an :meth:`__iter__` or :meth:`__getitem__` method. Iterables can be
403 used in a :keyword:`for` loop and in many other places where a sequence is
404 needed (:func:`zip`, :func:`map`, ...). When an iterable object is passed
405 as an argument to the built-in function :func:`iter`, it returns an
406 iterator for the object. This iterator is good for one pass over the set
407 of values. When using iterables, it is usually not necessary to call
408 :func:`iter` or deal with iterator objects yourself. The ``for``
Guido van Rossumf10aa982007-08-17 18:30:38 +0000409 statement does that automatically for you, creating a temporary unnamed
410 variable to hold the iterator for the duration of the loop. See also
411 :term:`iterator`, :term:`sequence`, and :term:`generator`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000412
Guido van Rossumf10aa982007-08-17 18:30:38 +0000413 iterator
414 An object representing a stream of data. Repeated calls to the iterator's
Ezio Melotti7fa82222012-10-12 13:42:08 +0300415 :meth:`~iterator.__next__` method (or passing it to the built-in function
Georg Brandlb30f3302011-01-06 09:23:56 +0000416 :func:`next`) return successive items in the stream. When no more data
417 are available a :exc:`StopIteration` exception is raised instead. At this
Benjamin Petersone7c78b22008-07-03 20:28:26 +0000418 point, the iterator object is exhausted and any further calls to its
Georg Brandlb30f3302011-01-06 09:23:56 +0000419 :meth:`__next__` method just raise :exc:`StopIteration` again. Iterators
420 are required to have an :meth:`__iter__` method that returns the iterator
Guido van Rossumf10aa982007-08-17 18:30:38 +0000421 object itself so every iterator is also iterable and may be used in most
422 places where other iterables are accepted. One notable exception is code
Benjamin Peterson5478b472008-09-17 22:25:09 +0000423 which attempts multiple iteration passes. A container object (such as a
Guido van Rossumf10aa982007-08-17 18:30:38 +0000424 :class:`list`) produces a fresh new iterator each time you pass it to the
425 :func:`iter` function or use it in a :keyword:`for` loop. Attempting this
426 with an iterator will just return the same exhausted iterator object used
427 in the previous iteration pass, making it appear like an empty container.
Georg Brandl48310cd2009-01-03 21:18:54 +0000428
Georg Brandl9afde1c2007-11-01 20:32:30 +0000429 More information can be found in :ref:`typeiter`.
430
Georg Brandlc275e152010-11-05 07:10:41 +0000431 key function
432 A key function or collation function is a callable that returns a value
433 used for sorting or ordering. For example, :func:`locale.strxfrm` is
434 used to produce a sort key that is aware of locale specific sort
435 conventions.
436
437 A number of tools in Python accept key functions to control how elements
438 are ordered or grouped. They include :func:`min`, :func:`max`,
439 :func:`sorted`, :meth:`list.sort`, :func:`heapq.nsmallest`,
440 :func:`heapq.nlargest`, and :func:`itertools.groupby`.
441
442 There are several ways to create a key function. For example. the
443 :meth:`str.lower` method can serve as a key function for case insensitive
444 sorts. Alternatively, an ad-hoc key function can be built from a
445 :keyword:`lambda` expression such as ``lambda r: (r[0], r[2])``. Also,
Sandro Tosi165a2c22012-04-01 01:50:00 +0200446 the :mod:`operator` module provides three key function constructors:
Georg Brandlc275e152010-11-05 07:10:41 +0000447 :func:`~operator.attrgetter`, :func:`~operator.itemgetter`, and
448 :func:`~operator.methodcaller`. See the :ref:`Sorting HOW TO
449 <sortinghowto>` for examples of how to create and use key functions.
450
Christian Heimesd8654cf2007-12-02 15:22:16 +0000451 keyword argument
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -0800452 See :term:`argument`.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000453
454 lambda
455 An anonymous inline function consisting of a single :term:`expression`
456 which is evaluated when the function is called. The syntax to create
457 a lambda function is ``lambda [arguments]: expression``
458
Guido van Rossumf10aa982007-08-17 18:30:38 +0000459 LBYL
460 Look before you leap. This coding style explicitly tests for
461 pre-conditions before making calls or lookups. This style contrasts with
462 the :term:`EAFP` approach and is characterized by the presence of many
463 :keyword:`if` statements.
Benjamin Peterson5478b472008-09-17 22:25:09 +0000464
Raymond Hettinger09f44142010-12-17 20:19:50 +0000465 In a multi-threaded environment, the LBYL approach can risk introducing a
466 race condition between "the looking" and "the leaping". For example, the
467 code, ``if key in mapping: return mapping[key]`` can fail if another
468 thread removes *key* from *mapping* after the test, but before the lookup.
469 This issue can be solved with locks or by using the EAFP approach.
470
Benjamin Peterson5478b472008-09-17 22:25:09 +0000471 list
472 A built-in Python :term:`sequence`. Despite its name it is more akin
473 to an array in other languages than to a linked list since access to
474 elements are O(1).
Georg Brandl48310cd2009-01-03 21:18:54 +0000475
Guido van Rossumf10aa982007-08-17 18:30:38 +0000476 list comprehension
Benjamin Peterson5478b472008-09-17 22:25:09 +0000477 A compact way to process all or part of the elements in a sequence and
Georg Brandlede6c2a2010-01-05 10:22:04 +0000478 return a list with the results. ``result = ['{:#04x}'.format(x) for x in
Benjamin Peterson5478b472008-09-17 22:25:09 +0000479 range(256) if x % 2 == 0]`` generates a list of strings containing
480 even hex numbers (0x..) in the range from 0 to 255. The :keyword:`if`
481 clause is optional. If omitted, all elements in ``range(256)`` are
482 processed.
Georg Brandl48310cd2009-01-03 21:18:54 +0000483
Brett Cannon51d4aab2009-01-25 04:21:39 +0000484 loader
485 An object that loads a module. It must define a method named
486 :meth:`load_module`. A loader is typically returned by a
Brett Cannone43b0602009-03-21 03:11:16 +0000487 :term:`finder`. See :pep:`302` for details and
488 :class:`importlib.abc.Loader` for an :term:`abstract base class`.
Brett Cannon51d4aab2009-01-25 04:21:39 +0000489
Guido van Rossumf10aa982007-08-17 18:30:38 +0000490 mapping
Raymond Hettingere3ee66f2011-01-08 23:44:37 +0000491 A container object that supports arbitrary key lookups and implements the
Éric Araujob8edbdf2011-09-01 05:57:12 +0200492 methods specified in the :class:`~collections.abc.Mapping` or
493 :class:`~collections.abc.MutableMapping`
Éric Araujofa088db2011-06-04 18:42:38 +0200494 :ref:`abstract base classes <collections-abstract-base-classes>`. Examples
495 include :class:`dict`, :class:`collections.defaultdict`,
Raymond Hettingere3ee66f2011-01-08 23:44:37 +0000496 :class:`collections.OrderedDict` and :class:`collections.Counter`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000497
Barry Warsawd7d21942012-07-29 16:36:17 -0400498 meta path finder
499 A finder returned by a search of :data:`sys.meta_path`. Meta path
Barry Warsawdadebab2012-07-31 16:03:09 -0400500 finders are related to, but different from :term:`path entry finders
501 <path entry finder>`.
Barry Warsawd7d21942012-07-29 16:36:17 -0400502
Guido van Rossumf10aa982007-08-17 18:30:38 +0000503 metaclass
504 The class of a class. Class definitions create a class name, a class
505 dictionary, and a list of base classes. The metaclass is responsible for
506 taking those three arguments and creating the class. Most object oriented
507 programming languages provide a default implementation. What makes Python
508 special is that it is possible to create custom metaclasses. Most users
509 never need this tool, but when the need arises, metaclasses can provide
510 powerful, elegant solutions. They have been used for logging attribute
511 access, adding thread-safety, tracking object creation, implementing
512 singletons, and many other tasks.
Georg Brandl9afde1c2007-11-01 20:32:30 +0000513
514 More information can be found in :ref:`metaclasses`.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000515
516 method
Benjamin Peterson5478b472008-09-17 22:25:09 +0000517 A function which is defined inside a class body. If called as an attribute
Christian Heimesd8654cf2007-12-02 15:22:16 +0000518 of an instance of that class, the method will get the instance object as
519 its first :term:`argument` (which is usually called ``self``).
520 See :term:`function` and :term:`nested scope`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000521
Michael Foord95fc51d2010-11-20 15:07:30 +0000522 method resolution order
523 Method Resolution Order is the order in which base classes are searched
524 for a member during lookup. See `The Python 2.3 Method Resolution Order
525 <http://www.python.org/download/releases/2.3/mro/>`_.
526
Barry Warsawd7d21942012-07-29 16:36:17 -0400527 module
528 An object that serves as an organizational unit of Python code. Modules
Barry Warsawc1e721b2012-07-30 16:24:12 -0400529 have a namespace containing arbitrary Python objects. Modules are loaded
Barry Warsawd7d21942012-07-29 16:36:17 -0400530 into Python by the process of :term:`importing`.
531
Georg Brandlbcce1252013-10-08 08:06:18 +0200532 See also :term:`package`.
533
Michael Foord95fc51d2010-11-20 15:07:30 +0000534 MRO
535 See :term:`method resolution order`.
536
Guido van Rossumf10aa982007-08-17 18:30:38 +0000537 mutable
538 Mutable objects can change their value but keep their :func:`id`. See
539 also :term:`immutable`.
Christian Heimes25bb7832008-01-11 16:17:00 +0000540
541 named tuple
Raymond Hettingerd04fa312009-02-04 19:45:13 +0000542 Any tuple-like class whose indexable elements are also accessible using
Christian Heimesd32ed6f2008-01-14 18:49:24 +0000543 named attributes (for example, :func:`time.localtime` returns a
544 tuple-like object where the *year* is accessible either with an
545 index such as ``t[0]`` or with a named attribute like ``t.tm_year``).
546
547 A named tuple can be a built-in type such as :class:`time.struct_time`,
548 or it can be created with a regular class definition. A full featured
549 named tuple can also be created with the factory function
550 :func:`collections.namedtuple`. The latter approach automatically
551 provides extra features such as a self-documenting representation like
552 ``Employee(name='jones', title='programmer')``.
Georg Brandl48310cd2009-01-03 21:18:54 +0000553
Guido van Rossumf10aa982007-08-17 18:30:38 +0000554 namespace
555 The place where a variable is stored. Namespaces are implemented as
Georg Brandl22b34312009-07-26 14:54:51 +0000556 dictionaries. There are the local, global and built-in namespaces as well
Guido van Rossumf10aa982007-08-17 18:30:38 +0000557 as nested namespaces in objects (in methods). Namespaces support
558 modularity by preventing naming conflicts. For instance, the functions
Serhiy Storchaka0d196ed2013-10-09 14:02:31 +0300559 :func:`builtins.open <.open>` and :func:`os.open` are distinguished by
560 their namespaces. Namespaces also aid readability and maintainability by
561 making it clear which module implements a function. For instance, writing
Éric Araujo7af8ebb2011-09-01 03:20:13 +0200562 :func:`random.seed` or :func:`itertools.islice` makes it clear that those
Guido van Rossumf10aa982007-08-17 18:30:38 +0000563 functions are implemented by the :mod:`random` and :mod:`itertools`
Benjamin Peterson5478b472008-09-17 22:25:09 +0000564 modules, respectively.
Georg Brandl48310cd2009-01-03 21:18:54 +0000565
Barry Warsawd7d21942012-07-29 16:36:17 -0400566 namespace package
567 A :pep:`420` :term:`package` which serves only as a container for
568 subpackages. Namespace packages may have no physical representation,
569 and specifically are not like a :term:`regular package` because they
570 have no ``__init__.py`` file.
571
Georg Brandlbcce1252013-10-08 08:06:18 +0200572 See also :term:`module`.
573
Guido van Rossumf10aa982007-08-17 18:30:38 +0000574 nested scope
575 The ability to refer to a variable in an enclosing definition. For
576 instance, a function defined inside another function can refer to
Benjamin Peterson927ccd22010-06-29 18:36:39 +0000577 variables in the outer function. Note that nested scopes by default work
578 only for reference and not for assignment. Local variables both read and
579 write in the innermost scope. Likewise, global variables read and write
580 to the global namespace. The :keyword:`nonlocal` allows writing to outer
581 scopes.
Georg Brandl48310cd2009-01-03 21:18:54 +0000582
Guido van Rossumf10aa982007-08-17 18:30:38 +0000583 new-style class
Georg Brandl85eb8c12007-08-31 16:33:38 +0000584 Old name for the flavor of classes now used for all class objects. In
585 earlier Python versions, only new-style classes could use Python's newer,
Serhiy Storchaka0d196ed2013-10-09 14:02:31 +0300586 versatile features like :attr:`~object.__slots__`, descriptors,
587 properties, :meth:`__getattribute__`, class methods, and static methods.
Georg Brandl9afde1c2007-11-01 20:32:30 +0000588
Benjamin Peterson5478b472008-09-17 22:25:09 +0000589 object
590 Any data with state (attributes or value) and defined behavior
591 (methods). Also the ultimate base class of any :term:`new-style
592 class`.
Georg Brandl48310cd2009-01-03 21:18:54 +0000593
Barry Warsawd7d21942012-07-29 16:36:17 -0400594 package
Georg Brandlbcce1252013-10-08 08:06:18 +0200595 A Python :term:`module` which can contain submodules or recursively,
Barry Warsawd7d21942012-07-29 16:36:17 -0400596 subpackages. Technically, a package is a Python module with an
597 ``__path__`` attribute.
598
Georg Brandlbcce1252013-10-08 08:06:18 +0200599 See also :term:`regular package` and :term:`namespace package`.
600
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -0800601 parameter
602 A named entity in a :term:`function` (or method) definition that
603 specifies an :term:`argument` (or in some cases, arguments) that the
Zachary Waree1391a02013-11-22 13:58:34 -0600604 function can accept. There are five kinds of parameter:
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -0800605
606 * :dfn:`positional-or-keyword`: specifies an argument that can be passed
607 either :term:`positionally <argument>` or as a :term:`keyword argument
608 <argument>`. This is the default kind of parameter, for example *foo*
609 and *bar* in the following::
610
611 def func(foo, bar=None): ...
612
613 * :dfn:`positional-only`: specifies an argument that can be supplied only
614 by position. Python has no syntax for defining positional-only
615 parameters. However, some built-in functions have positional-only
616 parameters (e.g. :func:`abs`).
617
Zachary Waree1391a02013-11-22 13:58:34 -0600618 .. _keyword-only_parameter:
619
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -0800620 * :dfn:`keyword-only`: specifies an argument that can be supplied only
621 by keyword. Keyword-only parameters can be defined by including a
622 single var-positional parameter or bare ``*`` in the parameter list
623 of the function definition before them, for example *kw_only1* and
624 *kw_only2* in the following::
625
626 def func(arg, *, kw_only1, kw_only2): ...
627
628 * :dfn:`var-positional`: specifies that an arbitrary sequence of
629 positional arguments can be provided (in addition to any positional
630 arguments already accepted by other parameters). Such a parameter can
631 be defined by prepending the parameter name with ``*``, for example
632 *args* in the following::
633
634 def func(*args, **kwargs): ...
635
636 * :dfn:`var-keyword`: specifies that arbitrarily many keyword arguments
637 can be provided (in addition to any keyword arguments already accepted
638 by other parameters). Such a parameter can be defined by prepending
639 the parameter name with ``**``, for example *kwargs* in the example
640 above.
641
642 Parameters can specify both optional and required arguments, as well as
643 default values for some optional arguments.
644
645 See also the :term:`argument` glossary entry, the FAQ question on
646 :ref:`the difference between arguments and parameters
647 <faq-argument-vs-parameter>`, the :class:`inspect.Parameter` class, the
648 :ref:`function` section, and :pep:`362`.
649
Barry Warsawdadebab2012-07-31 16:03:09 -0400650 path entry
651 A single location on the :term:`import path` which the :term:`path
Nick Coghlan1685db02012-08-20 13:49:08 +1000652 based finder` consults to find modules for importing.
Barry Warsawdadebab2012-07-31 16:03:09 -0400653
654 path entry finder
655 A :term:`finder` returned by a callable on :data:`sys.path_hooks`
656 (i.e. a :term:`path entry hook`) which knows how to locate modules given
657 a :term:`path entry`.
658
659 path entry hook
660 A callable on the :data:`sys.path_hook` list which returns a :term:`path
661 entry finder` if it knows how to find modules on a specific :term:`path
662 entry`.
663
Nick Coghlan1685db02012-08-20 13:49:08 +1000664 path based finder
Barry Warsawdadebab2012-07-31 16:03:09 -0400665 One of the default :term:`meta path finders <meta path finder>` which
666 searches an :term:`import path` for modules.
Barry Warsawd7d21942012-07-29 16:36:17 -0400667
668 portion
669 A set of files in a single directory (possibly stored in a zip file)
670 that contribute to a namespace package, as defined in :pep:`420`.
671
Christian Heimesd8654cf2007-12-02 15:22:16 +0000672 positional argument
Chris Jerdonekc2a7fd62012-11-28 02:29:33 -0800673 See :term:`argument`.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000674
Nick Coghlan4dae27a2013-10-20 13:22:04 +1000675 provisional API
676 A provisional API is one which has been deliberately excluded from
Barry Warsawd7d21942012-07-29 16:36:17 -0400677 the standard library's backwards compatibility guarantees. While major
Nick Coghlan4dae27a2013-10-20 13:22:04 +1000678 changes to such interfaces are not expected, as long as they are marked
Eli Bendersky6bdb6502012-03-30 10:52:25 +0300679 provisional, backwards incompatible changes (up to and including removal
Nick Coghlan4dae27a2013-10-20 13:22:04 +1000680 of the interface) may occur if deemed necessary by core developers. Such
Eli Bendersky6bdb6502012-03-30 10:52:25 +0300681 changes will not be made gratuitously -- they will occur only if serious
Nick Coghlan4dae27a2013-10-20 13:22:04 +1000682 fundamental flaws are uncovered that were missed prior to the inclusion
683 of the API.
684
685 Even for provisional APIs, backwards incompatible changes are seen as
686 a "solution of last resort" - every attempt will still be made to find
687 a backwards compatible resolution to any identified problems.
Eli Bendersky6bdb6502012-03-30 10:52:25 +0300688
Barry Warsawd7d21942012-07-29 16:36:17 -0400689 This process allows the standard library to continue to evolve over
690 time, without locking in problematic design errors for extended periods
691 of time. See :pep:`411` for more details.
Eli Bendersky6bdb6502012-03-30 10:52:25 +0300692
Nick Coghlan4dae27a2013-10-20 13:22:04 +1000693 provisional package
694 See :term:`provisional API`.
695
Guido van Rossumf10aa982007-08-17 18:30:38 +0000696 Python 3000
Barry Warsawd7d21942012-07-29 16:36:17 -0400697 Nickname for the Python 3.x release line (coined long ago when the
698 release of version 3 was something in the distant future.) This is also
Benjamin Peterson1e2f0502008-05-26 12:52:02 +0000699 abbreviated "Py3k".
Guido van Rossumf10aa982007-08-17 18:30:38 +0000700
Christian Heimesd8654cf2007-12-02 15:22:16 +0000701 Pythonic
Benjamin Peterson5478b472008-09-17 22:25:09 +0000702 An idea or piece of code which closely follows the most common idioms
703 of the Python language, rather than implementing code using concepts
704 common to other languages. For example, a common idiom in Python is
705 to loop over all elements of an iterable using a :keyword:`for`
706 statement. Many other languages don't have this type of construct, so
707 people unfamiliar with Python sometimes use a numerical counter instead::
Georg Brandl48310cd2009-01-03 21:18:54 +0000708
Christian Heimesd8654cf2007-12-02 15:22:16 +0000709 for i in range(len(food)):
Georg Brandla09ca382007-12-02 18:20:12 +0000710 print(food[i])
Christian Heimesd8654cf2007-12-02 15:22:16 +0000711
712 As opposed to the cleaner, Pythonic method::
713
714 for piece in food:
Georg Brandla09ca382007-12-02 18:20:12 +0000715 print(piece)
Christian Heimesd8654cf2007-12-02 15:22:16 +0000716
Antoine Pitrou86a36b52011-11-25 18:56:07 +0100717 qualified name
718 A dotted name showing the "path" from a module's global scope to a
719 class, function or method defined in that module, as defined in
720 :pep:`3155`. For top-level functions and classes, the qualified name
721 is the same as the object's name::
722
723 >>> class C:
724 ... class D:
725 ... def meth(self):
726 ... pass
727 ...
728 >>> C.__qualname__
729 'C'
730 >>> C.D.__qualname__
731 'C.D'
732 >>> C.D.meth.__qualname__
733 'C.D.meth'
734
Barry Warsawd7d21942012-07-29 16:36:17 -0400735 When used to refer to modules, the *fully qualified name* means the
736 entire dotted path to the module, including any parent packages,
737 e.g. ``email.mime.text``::
738
739 >>> import email.mime.text
740 >>> email.mime.text.__name__
741 'email.mime.text'
742
Guido van Rossumf10aa982007-08-17 18:30:38 +0000743 reference count
Benjamin Peterson5478b472008-09-17 22:25:09 +0000744 The number of references to an object. When the reference count of an
745 object drops to zero, it is deallocated. Reference counting is
746 generally not visible to Python code, but it is a key element of the
747 :term:`CPython` implementation. The :mod:`sys` module defines a
Georg Brandlede6c2a2010-01-05 10:22:04 +0000748 :func:`~sys.getrefcount` function that programmers can call to return the
Benjamin Peterson5478b472008-09-17 22:25:09 +0000749 reference count for a particular object.
750
Barry Warsawd7d21942012-07-29 16:36:17 -0400751 regular package
752 A traditional :term:`package`, such as a directory containing an
753 ``__init__.py`` file.
754
Georg Brandlbcce1252013-10-08 08:06:18 +0200755 See also :term:`namespace package`.
756
Guido van Rossumf10aa982007-08-17 18:30:38 +0000757 __slots__
Georg Brandl85eb8c12007-08-31 16:33:38 +0000758 A declaration inside a class that saves memory by pre-declaring space for
759 instance attributes and eliminating instance dictionaries. Though
760 popular, the technique is somewhat tricky to get right and is best
761 reserved for rare cases where there are large numbers of instances in a
762 memory-critical application.
Georg Brandl48310cd2009-01-03 21:18:54 +0000763
Guido van Rossumf10aa982007-08-17 18:30:38 +0000764 sequence
765 An :term:`iterable` which supports efficient element access using integer
Benjamin Peterson5478b472008-09-17 22:25:09 +0000766 indices via the :meth:`__getitem__` special method and defines a
Andrew Svetlov8cf1cc42012-10-05 13:26:10 +0300767 :meth:`__len__` method that returns the length of the sequence.
Guido van Rossumf10aa982007-08-17 18:30:38 +0000768 Some built-in sequence types are :class:`list`, :class:`str`,
Georg Brandl2ae8ac22009-02-05 10:40:48 +0000769 :class:`tuple`, and :class:`bytes`. Note that :class:`dict` also
Guido van Rossumf10aa982007-08-17 18:30:38 +0000770 supports :meth:`__getitem__` and :meth:`__len__`, but is considered a
771 mapping rather than a sequence because the lookups use arbitrary
772 :term:`immutable` keys rather than integers.
773
Łukasz Langafdcf2b72013-06-07 22:54:03 +0200774 single dispatch
775 A form of :term:`generic function` dispatch where the implementation is
776 chosen based on the type of a single argument.
777
Christian Heimesd8654cf2007-12-02 15:22:16 +0000778 slice
Georg Brandlc6fe37b2007-12-03 21:07:25 +0000779 An object usually containing a portion of a :term:`sequence`. A slice is
Christian Heimesd8654cf2007-12-02 15:22:16 +0000780 created using the subscript notation, ``[]`` with colons between numbers
781 when several are given, such as in ``variable_name[1:3:5]``. The bracket
Georg Brandla09ca382007-12-02 18:20:12 +0000782 (subscript) notation uses :class:`slice` objects internally.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000783
Georg Brandlaf265f42008-12-07 15:06:20 +0000784 special method
785 A method that is called implicitly by Python to execute a certain
786 operation on a type, such as addition. Such methods have names starting
787 and ending with double underscores. Special methods are documented in
788 :ref:`specialnames`.
789
Christian Heimesd8654cf2007-12-02 15:22:16 +0000790 statement
791 A statement is part of a suite (a "block" of code). A statement is either
Georg Brandl60e602d2013-10-06 11:57:13 +0200792 an :term:`expression` or one of several constructs with a keyword, such
Georg Brandla09ca382007-12-02 18:20:12 +0000793 as :keyword:`if`, :keyword:`while` or :keyword:`for`.
Christian Heimesd8654cf2007-12-02 15:22:16 +0000794
Benjamin Peterson82f614b2011-04-20 18:27:32 -0500795 struct sequence
Florent Xiclunaf8240d62011-11-11 19:58:53 +0100796 A tuple with named elements. Struct sequences expose an interface similar
Benjamin Peterson82f614b2011-04-20 18:27:32 -0500797 to :term:`named tuple` in that elements can either be accessed either by
798 index or as an attribute. However, they do not have any of the named tuple
799 methods like :meth:`~collections.somenamedtuple._make` or
800 :meth:`~collections.somenamedtuple._asdict`. Examples of struct sequences
801 include :data:`sys.float_info` and the return value of :func:`os.stat`.
802
Benjamin Peterson5478b472008-09-17 22:25:09 +0000803 triple-quoted string
804 A string which is bound by three instances of either a quotation mark
805 (") or an apostrophe ('). While they don't provide any functionality
806 not available with single-quoted strings, they are useful for a number
807 of reasons. They allow you to include unescaped single and double
808 quotes within a string and they can span multiple lines without the
809 use of the continuation character, making them especially useful when
810 writing docstrings.
811
Guido van Rossumf10aa982007-08-17 18:30:38 +0000812 type
813 The type of a Python object determines what kind of object it is; every
814 object has a type. An object's type is accessible as its
Serhiy Storchaka0d196ed2013-10-09 14:02:31 +0300815 :attr:`~instance.__class__` attribute or can be retrieved with
816 ``type(obj)``.
Benjamin Peterson5478b472008-09-17 22:25:09 +0000817
R David Murray1b00f252012-08-15 10:43:58 -0400818 universal newlines
819 A manner of interpreting text streams in which all of the following are
820 recognized as ending a line: the Unix end-of-line convention ``'\n'``,
821 the Windows convention ``'\r\n'``, and the old Macintosh convention
822 ``'\r'``. See :pep:`278` and :pep:`3116`, as well as
823 :func:`str.splitlines` for an additional use.
824
Benjamin Peterson656aa282008-11-21 23:22:00 +0000825 view
Ezio Melotti619de8f2009-06-25 18:39:31 +0000826 The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and
Benjamin Peterson656aa282008-11-21 23:22:00 +0000827 :meth:`dict.items` are called dictionary views. They are lazy sequences
828 that will see changes in the underlying dictionary. To force the
829 dictionary view to become a full list use ``list(dictview)``. See
830 :ref:`dict-views`.
831
Benjamin Peterson5478b472008-09-17 22:25:09 +0000832 virtual machine
833 A computer defined entirely in software. Python's virtual machine
834 executes the :term:`bytecode` emitted by the bytecode compiler.
Georg Brandl48310cd2009-01-03 21:18:54 +0000835
Guido van Rossumf10aa982007-08-17 18:30:38 +0000836 Zen of Python
837 Listing of Python design principles and philosophies that are helpful in
838 understanding and using the language. The listing can be found by typing
839 "``import this``" at the interactive prompt.