summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Doc/tut/glossary.tex64
1 files changed, 42 insertions, 22 deletions
diff --git a/Doc/tut/glossary.tex b/Doc/tut/glossary.tex
index 4702d67..8cf0949 100644
--- a/Doc/tut/glossary.tex
+++ b/Doc/tut/glossary.tex
@@ -37,13 +37,33 @@ Any class which does not inherit from \class{object}. See
\index{coercion}
\item[coercion]
-Converting data from one type to another. For example,
-{}\code{int(3.15)} coerces the floating point number to the integer,
-{}\code{3}. Most mathematical operations have rules for coercing
-their arguments to a common type. For instance, adding \code{3+4.5},
-causes the integer \code{3} to be coerced to be a float
-{}\code{3.0} before adding to \code{4.5} resulting in the float
-{}\code{7.5}.
+
+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
+fairy advanced mathematical feature. If you're not aware of a need for it's
+almost certain you can safely ignore them.
\index{descriptor}
\item[descriptor]
@@ -99,14 +119,14 @@ _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
\index{generator}
\item[generator]
-A function that returns an iterator. It looks like a normal function
-except that the \keyword{yield} keyword is used instead of
-{}\keyword{return}. 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.
+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{GIL}
\item[GIL]
@@ -134,7 +154,7 @@ sophisticated, multi-platform GUI application.
\index{immutable}
\item[immutable]
-A object with fixed value. Immutable objects are numbers, strings or
+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
@@ -149,7 +169,7 @@ to the \code{2.75} returned by float division. Also called
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, a integer divided by a float will result
+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__}.
@@ -164,11 +184,11 @@ packages (remember \code{help(x)}).
\index{interpreted}
\item[interpreted]
-Python is an interpreted language, opposed to a compiled one. This
-means that the source files can be run right away without first making
-an executable which is then run. Interpreted languages typically have
-a shorter development/debug cycle than compiled ones. See also
-{}\emph{interactive}.
+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]