[Python-checkins] python/dist/src/Doc/tut glossary.tex,1.1,1.2

Sat Sep 27 01:42:16 EDT 2003

Update of /cvsroot/python/python/dist/src/Doc/tut
In directory sc8-pr-cvs1:/tmp/cvs-serv30134
Modified Files:
	glossary.tex 
Log Message:
Fix spelling and add markup.
Index: glossary.tex
===================================================================
RCS file: /cvsroot/python/python/dist/src/Doc/tut/glossary.tex,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** glossary.tex	24 Sep 2003 16:51:23 -0000	1.1
--- glossary.tex	27 Sep 2003 05:42:14 -0000	1.2
***************
*** 2,5 ****
--- 2,6 ----

 %%% keep the entries sorted and include at least one \index{} item for each
+ %%% cross-references are marked with \emph{entry}

 \begin{description}
***************
*** 14,18 ****

 \index{__slots__}
! \item[__slots__]{A declaration inside a 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
--- 15,19 ----

 \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
***************
*** 25,29 ****

 \index{byte code}
! \item[byte code]{The internal represenatation of a Python program in the
 interpreter. The byte code is also cached in the \code{.pyc} and
 {}\code{.pyo} files so that executing the same file is faster the second
--- 26,30 ----

 \index{byte code}
! \item[byte code]{The internal representation of a Python program in the
 interpreter. The byte code is also cached in the \code{.pyc} and
 {}\code{.pyo} files so that executing the same file is faster the second
***************
*** 38,70 ****
 \index{coercion}
 \item[coercion]{Converting data from one type to another. For example,
! int(3.15) coerces the floating point number to the integer, 3. Most
! mathematical operations have rules for coercing their arguments to a common
! type. For instance, adding 3 + 4.5, causes the integer 3 to be coerced to
! be a float (3.0) before adding to 4.5 resulting in the float 7.5.}

 \index{descriptor}
! \item[descriptor]{Any object that defines the methods __get__(), __set__(),
! or __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 `dict` much resembles that for `list`, but the keys can
! be any object with a `__hash__` function, not just integers starting from
! zero. Called a hash in Perl.}

 \index{EAFP}
 \item[EAFP]{Easier to ask for forgiveness than permission. This common
! Python coding style assumes the existance 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 `try` and `except` statments.
! The technique contrasts with the '''LBYL''' style that is common in many
! other languages such as C.}

 \index{__future__}
--- 39,72 ----
 \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}.}

 \index{descriptor}
! \item[descriptor]{Any 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 \function{__hash__} function, not just
! integers starting from zero. Called a hash in Perl.}

 \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__}
***************
*** 72,77 ****
 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 ``true division`` by
! executing}

 \begin{verbatim}
--- 74,79 ----
 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}
***************
*** 80,86 ****

 the expression \code{11 / 4} would evaluate to \code{2.75}. By actually
! importing the __future__ module and evaluating its variables, you can see
! when a new feature was first added to the language and when it will becode
! the default:

 \begin{verbatim}
--- 82,88 ----

 the expression \code{11 / 4} would evaluate to \code{2.75}. By actually
! importing the \module{__future__} 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}
***************
*** 100,104 ****

 \index{GIL}
! \item[GIL]{See \em{global interpreter lock}.}

 \index{global interpreter lock}
--- 102,106 ----

 \index{GIL}
! \item[GIL]{See \emph{global interpreter lock}.}

 \index{global interpreter lock}
***************
*** 114,120 ****
 \index{IDLE}
 \item[IDLE]{an Integrated Development Environment for Python. IDLE is a
! basic editor and intepreter environment that ships with the standard
! distribution of Python. Good for beginners and those on a budget, it also
! serves as clear example code for those wanting to implement a moderately
 sophisticated, multi-platform GUI application.}

--- 116,122 ----
 \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.}

***************
*** 128,140 ****
 \index{integer division}
 \item[integer division]{Mathematical division discarding any remainder. For
! example, the expression \code{11 / 4} currently evaluates to 2 in contrast
! to the 2.75 returned by float division. Also called "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 float), the result will be coerced (see coercion) to
! a common type. For example, a 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, __future__.}

 \index{interactive}
--- 130,143 ----
 \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, a 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}
***************
*** 148,161 ****
 \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 typicaly have
 a shorter development/debug cycle than compiled ones. See also
! {}\em{interactive}.}

 \index{iterable}
 \item[iterable]{A container object capable of returning its members one at a
! time. Examples of iterables include all sequence types (\class{list},
! {}\class{str}, \class{tuple}, etc.) and some non-sequence types like
 {}\class{dict} and \class{file} and objects of any classes you define with
! an \function{__iter__} or \function{__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
--- 151,164 ----
 \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}.}

 \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 \function{__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
***************
*** 166,170 ****
 statement does that automatically for you, creating a temporary unnamed
 variable to hold the iterator for the duration of the loop. See also
! iterator, sequence and generator.}

 \index{iterator}
--- 169,173 ----
 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}
***************
*** 172,176 ****
 the iterator's \function{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 \function{next()} method just raise
 {}\exception{StopIteration} again. Iterators are required to have an
--- 175,179 ----
 the iterator's \function{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 \function{next()} method just raise
 {}\exception{StopIteration} again. Iterators are required to have an
***************
*** 178,186 ****
 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 list) produces a
! fresh new iterator each time you pass it to the \function{iter()} function
! or use it in a \function{for} loop. Attempting this with an iterator will
! just return the same exhausted iterator object from the second iteration
! pass and on, making it appear like an empty container.}

 \index{list comprehension}
--- 181,189 ----
 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 \function{for} loop. Attempting this with an iterator
! will just return the same exhausted iterator object from the second iteration
! pass, making it appear like an empty container.}

 \index{list comprehension}
***************
*** 210,215 ****
 \item[LBYL]{Look before you leap. This coding style explicitly tests for
 pre-conditions before making calls or lookups. This style contrasts with
! the EAFP approach and is characterized the presence of many \keyword{if}
! statements.}

 \index{mutable}
--- 213,218 ----
 \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 the presence of many
! {}\keyword{if} statements.}

 \index{mutable}
***************
*** 224,228 ****
 functions \function{__builtins__.open()} and \function{os.open()} are
 distinguished by their namespaces. Namespaces also aid readability and
! maintainabilty by making it clear which modules implement a function. For
 instance, writing \function{random.seed()} or \function{itertools.izip()}
 makes it clear that those functions are implemented by the \module{random}
--- 227,231 ----
 functions \function{__builtins__.open()} and \function{os.open()} are
 distinguished by their namespaces. Namespaces also aid readability and
! maintainability by making it clear which modules implement a function. For
 instance, writing \function{random.seed()} or \function{itertools.izip()}
 makes it clear that those functions are implemented by the \module{random}
***************
*** 240,245 ****
 \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
 {}\var{__slots__}, descriptors, properties, \var{__getattribute__}, class
 methods, and static methods.}
--- 243,248 ----
 \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
 {}\var{__slots__}, descriptors, properties, \var{__getattribute__}, class
 methods, and static methods.}
***************
*** 250,259 ****

 \index{sequence}
! \item[sequence]{An iterable which supports efficient element access using
 integer indices via the \function{__getitem__} and \function{__len()__}
 special methods. Some builtin sequence types are \class{list}, \class{str},
 {}\class{tuple}, and \class{unicode}. Note that \class{dict} also supports
 {}\function{__getitem__} and \function{__len__}, but is considered a mapping
! rather than a sequence because the lookups use arbitrary immutable keys
 rather than integers.}

--- 253,262 ----

 \index{sequence}
! \item[sequence]{An \emph{iterable} which supports efficient element access using
 integer indices via the \function{__getitem__} and \function{__len()__}
 special methods. Some builtin sequence types are \class{list}, \class{str},
 {}\class{tuple}, and \class{unicode}. Note that \class{dict} also supports
 {}\function{__getitem__} and \function{__len__}, but is considered a mapping
! rather than a sequence because the lookups use arbitrary \emph{immutable} keys
 rather than integers.}

***************
*** 261,265 ****
 \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 "import this" at the interactive prompt.}

 \end{description}
--- 264,268 ----
 \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}