353 lines
16 KiB
TeX
353 lines
16 KiB
TeX
\chapter{Glossary\label{glossary}}
|
|
|
|
%%% keep the entries sorted and include at least one \index{} item for each
|
|
%%% cross-references are marked with \emph{entry}
|
|
|
|
\begin{description}
|
|
|
|
|
|
\index{>>>}
|
|
\item[\code{>>>}]
|
|
The typical Python prompt of the interactive shell. Often seen for
|
|
code examples that can be tried right away in the interpreter.
|
|
|
|
\index{...}
|
|
\item[\code{.\code{.}.}]
|
|
The typical Python prompt of the interactive shell when entering code
|
|
for an indented code block.
|
|
|
|
\index{BDFL}
|
|
\item[BDFL]
|
|
Benevolent Dictator For Life, a.k.a. \ulink{Guido van
|
|
Rossum}{http://www.python.org/\textasciitilde{}guido/}, Python's creator.
|
|
|
|
\index{byte code}
|
|
\item[byte code]
|
|
The internal representation of a Python program in the interpreter.
|
|
The byte code is also cached in \code{.pyc} and \code{.pyo}
|
|
files so that executing the same file is faster the second time
|
|
(recompilation from source to byte code can be avoided). This
|
|
``intermediate language'' is said to run on a ``virtual
|
|
machine'' that calls the subroutines corresponding to each bytecode.
|
|
|
|
\index{classic class}
|
|
\item[classic class]
|
|
Any class which does not inherit from \class{object}. See
|
|
\emph{new-style class}.
|
|
|
|
\index{coercion}
|
|
\item[coercion]
|
|
The implicit conversion of an instance of one type to another during an
|
|
operation which involves two arguments of the same type. For example,
|
|
{}\code{int(3.15)} converts the floating point number to the integer
|
|
{}\code{3}, but in {}\code{3+4.5}, each argument is of a different type (one
|
|
int, one float), and both must be converted to the same type before they can
|
|
be added or it will raise a {}\code{TypeError}. Coercion between two
|
|
operands can be performed with the {}\code{coerce} builtin function; thus,
|
|
{}\code{3+4.5} is equivalent to calling {}\code{operator.add(*coerce(3,
|
|
4.5))} and results in {}\code{operator.add(3.0, 4.5)}. Without coercion,
|
|
all arguments of even compatible types would have to be normalized to the
|
|
same value by the programmer, e.g., {}\code{float(3)+4.5} rather than just
|
|
{}\code{3+4.5}.
|
|
|
|
\index{complex number}
|
|
\item[complex number]
|
|
An extension of the familiar real number system in which all numbers are
|
|
expressed as a sum of a real part and an imaginary part. Imaginary numbers
|
|
are real multiples of the imaginary unit (the square root of {}\code{-1}),
|
|
often written {}\code{i} in mathematics or {}\code{j} in engineering.
|
|
Python has builtin support for complex numbers, which are written with this
|
|
latter notation; the imaginary part is written with a {}\code{j} suffix,
|
|
e.g., {}\code{3+1j}. To get access to complex equivalents of the
|
|
{}\module{math} module, use {}\module{cmath}. Use of complex numbers is a
|
|
fairly advanced mathematical feature. If you're not aware of a need for them,
|
|
it's almost certain you can safely ignore them.
|
|
|
|
\index{descriptor}
|
|
\item[descriptor]
|
|
Any \emph{new-style} object that defines the methods
|
|
{}\method{__get__()}, \method{__set__()}, or \method{__delete__()}.
|
|
When a class attribute is a descriptor, its special binding behavior
|
|
is triggered upon attribute lookup. Normally, writing \var{a.b} looks
|
|
up the object \var{b} in the class dictionary for \var{a}, but if
|
|
{}\var{b} is a descriptor, the defined method gets called.
|
|
Understanding descriptors is a key to a deep understanding of Python
|
|
because they are the basis for many features including functions,
|
|
methods, properties, class methods, static methods, and reference to
|
|
super classes.
|
|
|
|
\index{dictionary}
|
|
\item[dictionary]
|
|
An associative array, where arbitrary keys are mapped to values. The
|
|
use of \class{dict} much resembles that for \class{list}, but the keys
|
|
can be any object with a \method{__hash__()} function, not just
|
|
integers starting from zero. Called a hash in Perl.
|
|
|
|
\index{duck-typing}
|
|
\item[duck-typing]
|
|
Pythonic programming style that determines an object's type by inspection
|
|
of its method or attribute signature rather than by explicit relationship
|
|
to some type object ("If it looks like a duck and quacks like a duck, it
|
|
must be a duck.") By emphasizing interfaces rather than specific types,
|
|
well-designed code improves its flexibility by allowing polymorphic
|
|
substitution. Duck-typing avoids tests using \function{type()} or
|
|
\function{isinstance()}. Instead, it typically employs
|
|
\function{hasattr()} tests or {}\emph{EAFP} programming.
|
|
|
|
\index{EAFP}
|
|
\item[EAFP]
|
|
Easier to ask for forgiveness than permission. This common Python
|
|
coding style assumes the existence of valid keys or attributes and
|
|
catches exceptions if the assumption proves false. This clean and
|
|
fast style is characterized by the presence of many \keyword{try} and
|
|
{}\keyword{except} statements. The technique contrasts with the
|
|
{}\emph{LBYL} style that is common in many other languages such as C.
|
|
|
|
\index{__future__}
|
|
\item[__future__]
|
|
A pseudo module which programmers can use to enable new language
|
|
features which are not compatible with the current interpreter. For
|
|
example, the expression \code{11/4} currently evaluates to \code{2}.
|
|
If the module in which it is executed had enabled \emph{true division}
|
|
by executing:
|
|
|
|
\begin{verbatim}
|
|
from __future__ import division
|
|
\end{verbatim}
|
|
|
|
the expression \code{11/4} would evaluate to \code{2.75}. By
|
|
importing the \ulink{\module{__future__}}{../lib/module-future.html}
|
|
module and evaluating its variables, you can see when a new feature
|
|
was first added to the language and when it will become the default:
|
|
|
|
\begin{verbatim}
|
|
>>> import __future__
|
|
>>> __future__.division
|
|
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
|
|
\end{verbatim}
|
|
|
|
\index{generator}
|
|
\item[generator]
|
|
A function that returns an iterator. It looks like a normal function except
|
|
that values are returned to the caller using a \keyword{yield} statement
|
|
instead of a {}\keyword{return} statement. Generator functions often
|
|
contain one or more {}\keyword{for} or \keyword{while} loops that
|
|
\keyword{yield} elements back to the caller. The function execution is
|
|
stopped at the {}\keyword{yield} keyword (returning the result) and is
|
|
resumed there when the next element is requested by calling the
|
|
\method{next()} method of the returned iterator.
|
|
|
|
\index{generator expression}
|
|
\item[generator expression]
|
|
An expression that returns a generator. It looks like a normal expression
|
|
followed by a \keyword{for} expression defining a loop variable, range, and
|
|
an optional \keyword{if} expression. The combined expression generates
|
|
values for an enclosing function:
|
|
|
|
\begin{verbatim}
|
|
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81
|
|
285
|
|
\end{verbatim}
|
|
|
|
\index{GIL}
|
|
\item[GIL]
|
|
See \emph{global interpreter lock}.
|
|
|
|
\index{global interpreter lock}
|
|
\item[global interpreter lock]
|
|
The lock used by Python threads to assure that only one thread can be
|
|
run at a time. This simplifies Python by assuring that no two
|
|
processes can access the same memory at the same time. Locking the
|
|
entire interpreter makes it easier for the interpreter to be
|
|
multi-threaded, at the expense of some parallelism on multi-processor
|
|
machines. Efforts have been made in the past to create a
|
|
``free-threaded'' interpreter (one which locks shared data at a much
|
|
finer granularity), but performance suffered in the common
|
|
single-processor case.
|
|
|
|
\index{IDLE}
|
|
\item[IDLE]
|
|
An Integrated Development Environment for Python. IDLE is a
|
|
basic editor and interpreter environment that ships with the standard
|
|
distribution of Python. Good for beginners, it also serves as clear
|
|
example code for those wanting to implement a moderately
|
|
sophisticated, multi-platform GUI application.
|
|
|
|
\index{immutable}
|
|
\item[immutable]
|
|
An object with fixed value. Immutable objects are numbers, strings or
|
|
tuples (and more). Such an object cannot be altered. A new object
|
|
has to be created if a different value has to be stored. They play an
|
|
important role in places where a constant hash value is needed, for
|
|
example as a key in a dictionary.
|
|
|
|
\index{integer division}
|
|
\item[integer division]
|
|
Mathematical division discarding any remainder. For example, the
|
|
expression \code{11/4} currently evaluates to \code{2} in contrast
|
|
to the \code{2.75} returned by float division. Also called
|
|
{}\emph{floor division}. When dividing two integers the outcome will
|
|
always be another integer (having the floor function applied to it).
|
|
However, if one of the operands is another numeric type (such as a
|
|
{}\class{float}), the result will be coerced (see \emph{coercion}) to
|
|
a common type. For example, an integer divided by a float will result
|
|
in a float value, possibly with a decimal fraction. Integer division
|
|
can be forced by using the \code{//} operator instead of the \code{/}
|
|
operator. See also \emph{__future__}.
|
|
|
|
\index{interactive}
|
|
\item[interactive]
|
|
Python has an interactive interpreter which means that you can try out
|
|
things and immediately see their results. Just launch \code{python} with no
|
|
arguments (possibly by selecting it from your computer's main menu).
|
|
It is a very powerful way to test out new ideas or inspect modules and
|
|
packages (remember \code{help(x)}).
|
|
|
|
\index{interpreted}
|
|
\item[interpreted]
|
|
Python is an interpreted language, as opposed to a compiled one. This means
|
|
that the source files can be run directly without first creating an
|
|
executable which is then run. Interpreted languages typically have a
|
|
shorter development/debug cycle than compiled ones, though their programs
|
|
generally also run more slowly. See also {}\emph{interactive}.
|
|
|
|
\index{iterable}
|
|
\item[iterable]
|
|
A container object capable of returning its members one at a time.
|
|
Examples of iterables include all sequence types (such as \class{list},
|
|
{}\class{str}, and \class{tuple}) and some non-sequence types like
|
|
{}\class{dict} and \class{file} and objects of any classes you define
|
|
with an \method{__iter__()} or \method{__getitem__()} method. Iterables
|
|
can be used in a \keyword{for} loop and in many other places where a
|
|
sequence is needed (\function{zip()}, \function{map()}, ...). When an
|
|
iterable object is passed as an argument to the builtin function
|
|
{}\function{iter()}, it returns an iterator for the object. This
|
|
iterator is good for one pass over the set of values. When using
|
|
iterables, it is usually not necessary to call \function{iter()} or
|
|
deal with iterator objects yourself. The \code{for} statement does
|
|
that automatically for you, creating a temporary unnamed variable to
|
|
hold the iterator for the duration of the loop. See also
|
|
{}\emph{iterator}, \emph{sequence}, and \emph{generator}.
|
|
|
|
\index{iterator}
|
|
\item[iterator]
|
|
An object representing a stream of data. Repeated calls to the
|
|
iterator's \method{next()} method return successive items in the
|
|
stream. When no more data is available a \exception{StopIteration}
|
|
exception is raised instead. At this point, the iterator object is
|
|
exhausted and any further calls to its \method{next()} method just
|
|
raise \exception{StopIteration} again. Iterators are required to have
|
|
an \method{__iter__()} method that returns the iterator object
|
|
itself so every iterator is also iterable and may be used in most
|
|
places where other iterables are accepted. One notable exception is
|
|
code that attempts multiple iteration passes. A container object
|
|
(such as a \class{list}) produces a fresh new iterator each time you
|
|
pass it to the \function{iter()} function or use it in a
|
|
{}\keyword{for} loop. Attempting this with an iterator will just
|
|
return the same exhausted iterator object used in the previous iteration
|
|
pass, making it appear like an empty container.
|
|
|
|
\index{LBYL}
|
|
\item[LBYL]
|
|
Look before you leap. This coding style explicitly tests for
|
|
pre-conditions before making calls or lookups. This style contrasts
|
|
with the \emph{EAFP} approach and is characterized by the presence of
|
|
many \keyword{if} statements.
|
|
|
|
\index{list comprehension}
|
|
\item[list comprehension]
|
|
A compact way to process all or a subset of elements in a sequence and
|
|
return a list with the results. \code{result = ["0x\%02x"
|
|
\% x for x in range(256) if x \% 2 == 0]} generates a list of strings
|
|
containing hex numbers (0x..) that are even and in the range from 0 to 255.
|
|
The \keyword{if} clause is optional. If omitted, all elements in
|
|
{}\code{range(256)} are processed.
|
|
|
|
\index{mapping}
|
|
\item[mapping]
|
|
A container object (such as \class{dict}) that supports arbitrary key
|
|
lookups using the special method \method{__getitem__()}.
|
|
|
|
\index{metaclass}
|
|
\item[metaclass]
|
|
The class of a class. Class definitions create a class name, a class
|
|
dictionary, and a list of base classes. The metaclass is responsible
|
|
for taking those three arguments and creating the class. Most object
|
|
oriented programming languages provide a default implementation. What
|
|
makes Python special is that it is possible to create custom
|
|
metaclasses. Most users never need this tool, but when the need
|
|
arises, metaclasses can provide powerful, elegant solutions. They
|
|
have been used for logging attribute access, adding thread-safety,
|
|
tracking object creation, implementing singletons, and many other
|
|
tasks.
|
|
|
|
\index{mutable}
|
|
\item[mutable]
|
|
Mutable objects can change their value but keep their \function{id()}.
|
|
See also \emph{immutable}.
|
|
|
|
\index{namespace}
|
|
\item[namespace]
|
|
The place where a variable is stored. Namespaces are implemented as
|
|
dictionaries. There are the local, global and builtin namespaces
|
|
as well as nested namespaces in objects (in methods). Namespaces support
|
|
modularity by preventing naming conflicts. For instance, the
|
|
functions \function{__builtin__.open()} and \function{os.open()} are
|
|
distinguished by their namespaces. Namespaces also aid readability
|
|
and maintainability by making it clear which module implements a
|
|
function. For instance, writing \function{random.seed()} or
|
|
{}\function{itertools.izip()} makes it clear that those functions are
|
|
implemented by the \ulink{\module{random}}{../lib/module-random.html}
|
|
and \ulink{\module{itertools}}{../lib/module-itertools.html} modules
|
|
respectively.
|
|
|
|
\index{nested scope}
|
|
\item[nested scope]
|
|
The ability to refer to a variable in an enclosing definition. For
|
|
instance, a function defined inside another function can refer to
|
|
variables in the outer function. Note that nested scopes work only
|
|
for reference and not for assignment which will always write to the
|
|
innermost scope. In contrast, local variables both read and write in
|
|
the innermost scope. Likewise, global variables read and write to the
|
|
global namespace.
|
|
|
|
\index{new-style class}
|
|
\item[new-style class]
|
|
Any class that inherits from \class{object}. This includes all
|
|
built-in types like \class{list} and \class{dict}. Only new-style
|
|
classes can use Python's newer, versatile features like
|
|
{}\method{__slots__}, descriptors, properties,
|
|
\method{__getattribute__()}, class methods, and static methods.
|
|
|
|
\index{Python3000}
|
|
\item[Python3000]
|
|
A mythical python release, not required to be backward compatible, with
|
|
telepathic interface.
|
|
|
|
\index{__slots__}
|
|
\item[__slots__]
|
|
A declaration inside a \emph{new-style class} that saves memory by
|
|
pre-declaring space for instance attributes and eliminating instance
|
|
dictionaries. Though popular, the technique is somewhat tricky to get
|
|
right and is best reserved for rare cases where there are large
|
|
numbers of instances in a memory-critical application.
|
|
|
|
\index{sequence}
|
|
\item[sequence]
|
|
An \emph{iterable} which supports efficient element access using
|
|
integer indices via the \method{__getitem__()} and
|
|
{}\method{__len__()} special methods. Some built-in sequence types
|
|
are \class{list}, \class{str}, \class{tuple}, and \class{unicode}.
|
|
Note that \class{dict} also supports \method{__getitem__()} and
|
|
{}\method{__len__()}, but is considered a mapping rather than a
|
|
sequence because the lookups use arbitrary \emph{immutable} keys
|
|
rather than integers.
|
|
|
|
\index{Zen of Python}
|
|
\item[Zen of Python]
|
|
Listing of Python design principles and philosophies that are helpful
|
|
in understanding and using the language. The listing can be found by
|
|
typing ``\code{import this}'' at the interactive prompt.
|
|
|
|
\end{description}
|