|
| 1 | +.. _glossary: |
| 2 | + |
| 3 | +******** |
| 4 | +Glossary |
| 5 | +******** |
| 6 | + |
| 7 | +.. if you add new entries, keep the alphabetical sorting! |
| 8 | +
|
| 9 | +.. glossary:: |
| 10 | + |
| 11 | + ``>>>`` |
| 12 | + The typical Python prompt of the interactive shell. Often seen for code |
| 13 | + examples that can be tried right away in the interpreter. |
| 14 | + |
| 15 | + ``...`` |
| 16 | + The typical Python prompt of the interactive shell when entering code for |
| 17 | + an indented code block. |
| 18 | + |
| 19 | + BDFL |
| 20 | + Benevolent Dictator For Life, a.k.a. `Guido van Rossum |
| 21 | + <http://www.python.org/~guido/>`_, Python's creator. |
| 22 | + |
| 23 | + byte code |
| 24 | + The internal representation of a Python program in the interpreter. The |
| 25 | + byte code is also cached in ``.pyc`` and ``.pyo`` files so that executing |
| 26 | + the same file is faster the second time (recompilation from source to byte |
| 27 | + code can be avoided). This "intermediate language" is said to run on a |
| 28 | + "virtual machine" that calls the subroutines corresponding to each |
| 29 | + bytecode. |
| 30 | + |
| 31 | + classic class |
| 32 | + Any class which does not inherit from :class:`object`. See |
| 33 | + :term:`new-style class`. |
| 34 | + |
| 35 | + coercion |
| 36 | + The implicit conversion of an instance of one type to another during an |
| 37 | + operation which involves two arguments of the same type. For example, |
| 38 | + ``int(3.15)`` converts the floating point number to the integer ``3``, but |
| 39 | + in ``3+4.5``, each argument is of a different type (one int, one float), |
| 40 | + and both must be converted to the same type before they can be added or it |
| 41 | + will raise a ``TypeError``. Coercion between two operands can be |
| 42 | + performed with the ``coerce`` builtin function; thus, ``3+4.5`` is |
| 43 | + equivalent to calling ``operator.add(*coerce(3, 4.5))`` and results in |
| 44 | + ``operator.add(3.0, 4.5)``. Without coercion, all arguments of even |
| 45 | + compatible types would have to be normalized to the same value by the |
| 46 | + programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``. |
| 47 | + |
| 48 | + complex number |
| 49 | + An extension of the familiar real number system in which all numbers are |
| 50 | + expressed as a sum of a real part and an imaginary part. Imaginary |
| 51 | + numbers are real multiples of the imaginary unit (the square root of |
| 52 | + ``-1``), often written ``i`` in mathematics or ``j`` in |
| 53 | + engineering. Python has builtin support for complex numbers, which are |
| 54 | + written with this latter notation; the imaginary part is written with a |
| 55 | + ``j`` suffix, e.g., ``3+1j``. To get access to complex equivalents of the |
| 56 | + :mod:`math` module, use :mod:`cmath`. Use of complex numbers is a fairly |
| 57 | + advanced mathematical feature. If you're not aware of a need for them, |
| 58 | + it's almost certain you can safely ignore them. |
| 59 | + |
| 60 | + descriptor |
| 61 | + Any *new-style* object that defines the methods :meth:`__get__`, |
| 62 | + :meth:`__set__`, or :meth:`__delete__`. When a class attribute is a |
| 63 | + descriptor, its special binding behavior is triggered upon attribute |
| 64 | + lookup. Normally, writing *a.b* looks up the object *b* in the class |
| 65 | + dictionary for *a*, but if *b* is a descriptor, the defined method gets |
| 66 | + called. Understanding descriptors is a key to a deep understanding of |
| 67 | + Python because they are the basis for many features including functions, |
| 68 | + methods, properties, class methods, static methods, and reference to super |
| 69 | + classes. |
| 70 | + |
| 71 | + dictionary |
| 72 | + An associative array, where arbitrary keys are mapped to values. The use |
| 73 | + of :class:`dict` much resembles that for :class:`list`, but the keys can |
| 74 | + be any object with a :meth:`__hash__` function, not just integers starting |
| 75 | + from zero. Called a hash in Perl. |
| 76 | + |
| 77 | + duck-typing |
| 78 | + Pythonic programming style that determines an object's type by inspection |
| 79 | + of its method or attribute signature rather than by explicit relationship |
| 80 | + to some type object ("If it looks like a duck and quacks like a duck, it |
| 81 | + must be a duck.") By emphasizing interfaces rather than specific types, |
| 82 | + well-designed code improves its flexibility by allowing polymorphic |
| 83 | + substitution. Duck-typing avoids tests using :func:`type` or |
| 84 | + :func:`isinstance`. Instead, it typically employs :func:`hasattr` tests or |
| 85 | + :term:`EAFP` programming. |
| 86 | + |
| 87 | + EAFP |
| 88 | + Easier to ask for forgiveness than permission. This common Python coding |
| 89 | + style assumes the existence of valid keys or attributes and catches |
| 90 | + exceptions if the assumption proves false. This clean and fast style is |
| 91 | + characterized by the presence of many :keyword:`try` and :keyword:`except` |
| 92 | + statements. The technique contrasts with the :term:`LBYL` style that is |
| 93 | + common in many other languages such as C. |
| 94 | + |
| 95 | + extension module |
| 96 | + A module written in C, using Python's C API to interact with the core and |
| 97 | + with user code. |
| 98 | + |
| 99 | + __future__ |
| 100 | + A pseudo module which programmers can use to enable new language features |
| 101 | + which are not compatible with the current interpreter. For example, the |
| 102 | + expression ``11/4`` currently evaluates to ``2``. If the module in which |
| 103 | + it is executed had enabled *true division* by executing:: |
| 104 | + |
| 105 | + from __future__ import division |
| 106 | + |
| 107 | + the expression ``11/4`` would evaluate to ``2.75``. By importing the |
| 108 | + :mod:`__future__` module and evaluating its variables, you can see when a |
| 109 | + new feature was first added to the language and when it will become the |
| 110 | + default:: |
| 111 | + |
| 112 | + >>> import __future__ |
| 113 | + >>> __future__.division |
| 114 | + _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192) |
| 115 | + |
| 116 | + garbage collection |
| 117 | + The process of freeing memory when it is not used anymore. Python |
| 118 | + performs garbage collection via reference counting and a cyclic garbage |
| 119 | + collector that is able to detect and break reference cycles. |
| 120 | + |
| 121 | + generator |
| 122 | + A function that returns an iterator. It looks like a normal function |
| 123 | + except that values are returned to the caller using a :keyword:`yield` |
| 124 | + statement instead of a :keyword:`return` statement. Generator functions |
| 125 | + often contain one or more :keyword:`for` or :keyword:`while` loops that |
| 126 | + :keyword:`yield` elements back to the caller. The function execution is |
| 127 | + stopped at the :keyword:`yield` keyword (returning the result) and is |
| 128 | + resumed there when the next element is requested by calling the |
| 129 | + :meth:`next` method of the returned iterator. |
| 130 | + |
| 131 | + .. index:: single: generator expression |
| 132 | + |
| 133 | + generator expression |
| 134 | + An expression that returns a generator. It looks like a normal expression |
| 135 | + followed by a :keyword:`for` expression defining a loop variable, range, |
| 136 | + and an optional :keyword:`if` expression. The combined expression |
| 137 | + generates values for an enclosing function:: |
| 138 | + |
| 139 | + >>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81 |
| 140 | + 285 |
| 141 | + |
| 142 | + GIL |
| 143 | + See :term:`global interpreter lock`. |
| 144 | + |
| 145 | + global interpreter lock |
| 146 | + The lock used by Python threads to assure that only one thread can be run |
| 147 | + at a time. This simplifies Python by assuring that no two processes can |
| 148 | + access the same memory at the same time. Locking the entire interpreter |
| 149 | + makes it easier for the interpreter to be multi-threaded, at the expense |
| 150 | + of some parallelism on multi-processor machines. Efforts have been made |
| 151 | + in the past to create a "free-threaded" interpreter (one which locks |
| 152 | + shared data at a much finer granularity), but performance suffered in the |
| 153 | + common single-processor case. |
| 154 | + |
| 155 | + IDLE |
| 156 | + An Integrated Development Environment for Python. IDLE is a basic editor |
| 157 | + and interpreter environment that ships with the standard distribution of |
| 158 | + Python. Good for beginners, it also serves as clear example code for |
| 159 | + those wanting to implement a moderately sophisticated, multi-platform GUI |
| 160 | + application. |
| 161 | + |
| 162 | + immutable |
| 163 | + An object with fixed value. Immutable objects are numbers, strings or |
| 164 | + tuples (and more). Such an object cannot be altered. A new object has to |
| 165 | + be created if a different value has to be stored. They play an important |
| 166 | + role in places where a constant hash value is needed, for example as a key |
| 167 | + in a dictionary. |
| 168 | + |
| 169 | + integer division |
| 170 | + Mathematical division discarding any remainder. For example, the |
| 171 | + expression ``11/4`` currently evaluates to ``2`` in contrast to the |
| 172 | + ``2.75`` returned by float division. Also called *floor division*. |
| 173 | + When dividing two integers the outcome will always be another integer |
| 174 | + (having the floor function applied to it). However, if one of the operands |
| 175 | + is another numeric type (such as a :class:`float`), the result will be |
| 176 | + coerced (see :term:`coercion`) to a common type. For example, an integer |
| 177 | + divided by a float will result in a float value, possibly with a decimal |
| 178 | + fraction. Integer division can be forced by using the ``//`` operator |
| 179 | + instead of the ``/`` operator. See also :term:`__future__`. |
| 180 | + |
| 181 | + interactive |
| 182 | + Python has an interactive interpreter which means that you can try out |
| 183 | + things and immediately see their results. Just launch ``python`` with no |
| 184 | + arguments (possibly by selecting it from your computer's main menu). It is |
| 185 | + a very powerful way to test out new ideas or inspect modules and packages |
| 186 | + (remember ``help(x)``). |
| 187 | + |
| 188 | + interpreted |
| 189 | + Python is an interpreted language, as opposed to a compiled one. This |
| 190 | + means that the source files can be run directly without first creating an |
| 191 | + executable which is then run. Interpreted languages typically have a |
| 192 | + shorter development/debug cycle than compiled ones, though their programs |
| 193 | + generally also run more slowly. See also :term:`interactive`. |
| 194 | + |
| 195 | + iterable |
| 196 | + A container object capable of returning its members one at a |
| 197 | + time. Examples of iterables include all sequence types (such as |
| 198 | + :class:`list`, :class:`str`, and :class:`tuple`) and some non-sequence |
| 199 | + types like :class:`dict` and :class:`file` and objects of any classes you |
| 200 | + define with an :meth:`__iter__` or :meth:`__getitem__` method. Iterables |
| 201 | + can be used in a :keyword:`for` loop and in many other places where a |
| 202 | + sequence is needed (:func:`zip`, :func:`map`, ...). When an iterable |
| 203 | + object is passed as an argument to the builtin function :func:`iter`, it |
| 204 | + returns an iterator for the object. This iterator is good for one pass |
| 205 | + over the set of values. When using iterables, it is usually not necessary |
| 206 | + to call :func:`iter` or deal with iterator objects yourself. The ``for`` |
| 207 | + statement does that automatically for you, creating a temporary unnamed |
| 208 | + variable to hold the iterator for the duration of the loop. See also |
| 209 | + :term:`iterator`, :term:`sequence`, and :term:`generator`. |
| 210 | + |
| 211 | + iterator |
| 212 | + An object representing a stream of data. Repeated calls to the iterator's |
| 213 | + :meth:`next` method return successive items in the stream. When no more |
| 214 | + data is available a :exc:`StopIteration` exception is raised instead. At |
| 215 | + this point, the iterator object is exhausted and any further calls to its |
| 216 | + :meth:`next` method just raise :exc:`StopIteration` again. Iterators are |
| 217 | + required to have an :meth:`__iter__` method that returns the iterator |
| 218 | + object itself so every iterator is also iterable and may be used in most |
| 219 | + places where other iterables are accepted. One notable exception is code |
| 220 | + that attempts multiple iteration passes. A container object (such as a |
| 221 | + :class:`list`) produces a fresh new iterator each time you pass it to the |
| 222 | + :func:`iter` function or use it in a :keyword:`for` loop. Attempting this |
| 223 | + with an iterator will just return the same exhausted iterator object used |
| 224 | + in the previous iteration pass, making it appear like an empty container. |
| 225 | + |
| 226 | + LBYL |
| 227 | + Look before you leap. This coding style explicitly tests for |
| 228 | + pre-conditions before making calls or lookups. This style contrasts with |
| 229 | + the :term:`EAFP` approach and is characterized by the presence of many |
| 230 | + :keyword:`if` statements. |
| 231 | + |
| 232 | + list comprehension |
| 233 | + A compact way to process all or a subset of elements in a sequence and |
| 234 | + return a list with the results. ``result = ["0x%02x" % x for x in |
| 235 | + range(256) if x % 2 == 0]`` generates a list of strings containing hex |
| 236 | + numbers (0x..) that are even and in the range from 0 to 255. The |
| 237 | + :keyword:`if` clause is optional. If omitted, all elements in |
| 238 | + ``range(256)`` are processed. |
| 239 | + |
| 240 | + mapping |
| 241 | + A container object (such as :class:`dict`) that supports arbitrary key |
| 242 | + lookups using the special method :meth:`__getitem__`. |
| 243 | + |
| 244 | + metaclass |
| 245 | + The class of a class. Class definitions create a class name, a class |
| 246 | + dictionary, and a list of base classes. The metaclass is responsible for |
| 247 | + taking those three arguments and creating the class. Most object oriented |
| 248 | + programming languages provide a default implementation. What makes Python |
| 249 | + special is that it is possible to create custom metaclasses. Most users |
| 250 | + never need this tool, but when the need arises, metaclasses can provide |
| 251 | + powerful, elegant solutions. They have been used for logging attribute |
| 252 | + access, adding thread-safety, tracking object creation, implementing |
| 253 | + singletons, and many other tasks. |
| 254 | + |
| 255 | + mutable |
| 256 | + Mutable objects can change their value but keep their :func:`id`. See |
| 257 | + also :term:`immutable`. |
| 258 | + |
| 259 | + namespace |
| 260 | + The place where a variable is stored. Namespaces are implemented as |
| 261 | + dictionaries. There are the local, global and builtin namespaces as well |
| 262 | + as nested namespaces in objects (in methods). Namespaces support |
| 263 | + modularity by preventing naming conflicts. For instance, the functions |
| 264 | + :func:`__builtin__.open` and :func:`os.open` are distinguished by their |
| 265 | + namespaces. Namespaces also aid readability and maintainability by making |
| 266 | + it clear which module implements a function. For instance, writing |
| 267 | + :func:`random.seed` or :func:`itertools.izip` makes it clear that those |
| 268 | + functions are implemented by the :mod:`random` and :mod:`itertools` |
| 269 | + modules respectively. |
| 270 | + |
| 271 | + nested scope |
| 272 | + The ability to refer to a variable in an enclosing definition. For |
| 273 | + instance, a function defined inside another function can refer to |
| 274 | + variables in the outer function. Note that nested scopes work only for |
| 275 | + reference and not for assignment which will always write to the innermost |
| 276 | + scope. In contrast, local variables both read and write in the innermost |
| 277 | + scope. Likewise, global variables read and write to the global namespace. |
| 278 | + |
| 279 | + new-style class |
| 280 | + Any class that inherits from :class:`object`. This includes all built-in |
| 281 | + types like :class:`list` and :class:`dict`. Only new-style classes can |
| 282 | + use Python's newer, versatile features like :attr:`__slots__`, |
| 283 | + descriptors, properties, :meth:`__getattribute__`, class methods, and |
| 284 | + static methods. |
| 285 | + |
| 286 | + Python 3000 |
| 287 | + Nickname for the next major Python version, 3.0 (coined long ago when the |
| 288 | + release of version 3 was something in the distant future.) |
| 289 | + |
| 290 | + reference count |
| 291 | + The number of places where a certain object is referenced to. When the |
| 292 | + reference count drops to zero, an object is deallocated. While reference |
| 293 | + counting is invisible on the Python code level, it is used on the |
| 294 | + implementation level to keep track of allocated memory. |
| 295 | + |
| 296 | + __slots__ |
| 297 | + A declaration inside a :term:`new-style class` that saves memory by |
| 298 | + pre-declaring space for instance attributes and eliminating instance |
| 299 | + dictionaries. Though popular, the technique is somewhat tricky to get |
| 300 | + right and is best reserved for rare cases where there are large numbers of |
| 301 | + instances in a memory-critical application. |
| 302 | + |
| 303 | + sequence |
| 304 | + An :term:`iterable` which supports efficient element access using integer |
| 305 | + indices via the :meth:`__getitem__` and :meth:`__len__` special methods. |
| 306 | + Some built-in sequence types are :class:`list`, :class:`str`, |
| 307 | + :class:`tuple`, and :class:`unicode`. Note that :class:`dict` also |
| 308 | + supports :meth:`__getitem__` and :meth:`__len__`, but is considered a |
| 309 | + mapping rather than a sequence because the lookups use arbitrary |
| 310 | + :term:`immutable` keys rather than integers. |
| 311 | + |
| 312 | + type |
| 313 | + The type of a Python object determines what kind of object it is; every |
| 314 | + object has a type. An object's type is accessible as its |
| 315 | + :attr:`__class__` attribute or can be retrieved with ``type(obj)``. |
| 316 | + |
| 317 | + Zen of Python |
| 318 | + Listing of Python design principles and philosophies that are helpful in |
| 319 | + understanding and using the language. The listing can be found by typing |
| 320 | + "``import this``" at the interactive prompt. |
0 commit comments