Fix up a few style nits -- avoid "e.g." and "i.e." -- these make

freddrake · freddrake · commit ed514946666b · 2001-07-06T17:28:39.000Z
translation more difficult, as well as reading the English more
difficult for non-native speakers.
diff --git a/Doc/tut/tut.tex b/Doc/tut/tut.tex
@@ -242,7 +242,7 @@ \subsection{Interactive Mode \label{interactive}}
 (\samp{>\code{>}>~}); for continuation lines it prompts with the
 \emph{secondary prompt}, by default three dots (\samp{...~}).
 The interpreter prints a welcome message stating its version number
-and a copyright notice before printing the first prompt, e.g.:
+and a copyright notice before printing the first prompt:
 
 \begin{verbatim}
 python
@@ -325,8 +325,8 @@ \subsection{The Interactive Startup File \label{startup}}
 this file.
 
 If you want to read an additional start-up file from the current
-directory, you can program this in the global start-up file,
-e.g.\ \samp{if os.path.isfile('.pythonrc.py'):
+directory, you can program this in the global start-up file using code
+like \samp{if os.path.isfile('.pythonrc.py'):
 execfile('.pythonrc.py')}.  If you want to use the startup file in a
 script, you must do this explicitly in the script:
 
@@ -527,7 +527,7 @@ \subsection{Strings \label{strings}}
 \end{verbatim}
 
 String literals can span multiple lines in several ways.  Newlines can
-be escaped with backslashes, e.g.:
+be escaped with backslashes:
 
 \begin{verbatim}
 hello = "This is a rather long string containing\n\
@@ -728,7 +728,7 @@ \subsection{Strings \label{strings}}
 the edges labeled \var{i} and \var{j}, respectively.
 
 For non-negative indices, the length of a slice is the difference of
-the indices, if both are within bounds, e.g., the length of
+the indices, if both are within bounds.  For example, the length of
 \code{word[1:3]} is 2.
 
 The built-in function \function{len()} returns the length of a string:
@@ -799,8 +799,8 @@ \subsection{Unicode Strings \label{unicodeStrings}}
 u'Hello\\\\u0020World !'
 \end{verbatim}
 
-The raw mode is most useful when you have to enter lots of backslashes
-e.g. in regular expressions.
+The raw mode is most useful when you have to enter lots of
+backslashes, as can be necessary in regular expressions.
 
 Apart from these standard encodings, Python provides a whole set of
 other ways of creating Unicode strings on the basis of a known
@@ -1073,7 +1073,7 @@ \section{\keyword{for} Statements \label{for}}
 or giving the user the ability to define both the iteration step and
 halting condition (as C), Python's
 \keyword{for}\stindex{for} statement iterates over the items of any
-sequence (e.g., a list or a string), in the order that they appear in
+sequence (a list or a string), in the order that they appear in
 the sequence.  For example (no pun intended):
 % One suggestion was to give a real C example here, but that may only
 % serve to confuse non-C programmers.
@@ -1090,10 +1090,10 @@ \section{\keyword{for} Statements \label{for}}
 \end{verbatim}
 
 It is not safe to modify the sequence being iterated over in the loop
-(this can only happen for mutable sequence types, i.e., lists).  If
-you need to modify the list you are iterating over, e.g., duplicate
-selected items, you must iterate over a copy.  The slice notation
-makes this particularly convenient:
+(this can only happen for mutable sequence types, such as lists).  If
+you need to modify the list you are iterating over (for example, to
+duplicate selected items) you must iterate over a copy.  The slice
+notation makes this particularly convenient:
 
 \begin{verbatim}
 >>> for x in a[:]: # make a slice copy of the entire list
@@ -1108,7 +1108,7 @@ \section{The \function{range()} Function \label{range}}
 
 If you do need to iterate over a sequence of numbers, the built-in
 function \function{range()} comes in handy.  It generates lists
-containing arithmetic progressions, e.g.:
+containing arithmetic progressions:
 
 \begin{verbatim}
 >>> range(10)
@@ -1245,7 +1245,7 @@ \section{Defining Functions \label{functions}}
 the object).\footnote{
          Actually, \emph{call by object reference} would be a better
          description, since if a mutable object is passed, the caller
-         will see any changes the callee makes to it (e.g., items
+         will see any changes the callee makes to it (items
          inserted into a list).
 } When a function calls another function, a new local symbol table is
 created for that call.
@@ -1331,7 +1331,7 @@ \subsection{Default Argument Values \label{defaultArgs}}
 
 The most useful form is to specify a default value for one or more
 arguments.  This creates a function that can be called with fewer
-arguments than it is defined, e.g.
+arguments than it is defined
 
 \begin{verbatim}
 def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
@@ -1349,7 +1349,7 @@ \subsection{Default Argument Values \label{defaultArgs}}
 \code{ask_ok('OK to overwrite the file?', 2)}.
 
 The default values are evaluated at the point of function definition
-in the \emph{defining} scope, so that e.g.
+in the \emph{defining} scope, so that
 
 \begin{verbatim}
 i = 5
@@ -1509,7 +1509,7 @@ \subsection{Lambda Forms \label{lambda}}
 expression.  Semantically, they are just syntactic sugar for a normal
 function definition.  Like nested function definitions, lambda forms
 cannot reference variables from the containing scope, but this can be
-overcome through the judicious use of default argument values, e.g.
+overcome through the judicious use of default argument values:
 
 \begin{verbatim}
 >>> def make_incrementor(n):
@@ -1853,7 +1853,7 @@ \section{The \keyword{del} statement \label{del}}
 
 \section{Tuples and Sequences \label{tuples}}
 
-We saw that lists and strings have many common properties, e.g.,
+We saw that lists and strings have many common properties, such as
 indexing and slicing operations.  They are two examples of
 \emph{sequence} data types.  Since Python is an evolving language,
 other sequence data types may be added.  There is also another
@@ -1879,9 +1879,9 @@ \section{Tuples and Sequences \label{tuples}}
 or without surrounding parentheses, although often parentheses are
 necessary anyway (if the tuple is part of a larger expression).
 
-Tuples have many uses, e.g., (x, y) coordinate pairs, employee records
-from a database, etc.  Tuples, like strings, are immutable: it is not
-possible to assign to the individual items of a tuple (you can
+Tuples have many uses.  For example: (x, y) coordinate pairs, employee
+records from a database, etc.  Tuples, like strings, are immutable: it
+is not possible to assign to the individual items of a tuple (you can
 simulate much of the same effect with slicing and concatenation,
 though).  It is also possible to create tuples which contain mutable
 objects, such as lists.
@@ -1907,7 +1907,7 @@ \section{Tuples and Sequences \label{tuples}}
 The statement \code{t = 12345, 54321, 'hello!'} is an example of
 \emph{tuple packing}: the values \code{12345}, \code{54321} and
 \code{'hello!'} are packed together in a tuple.  The reverse operation
-is also possible, e.g.:
+is also possible:
 
 \begin{verbatim}
 >>> x, y, z = t
@@ -1992,8 +1992,9 @@ \section{More on Conditions \label{conditions}}
 have the same priority, which is lower than that of all numerical
 operators.
 
-Comparisons can be chained: e.g., \code{a < b == c} tests whether
-\code{a} is less than \code{b} and moreover \code{b} equals \code{c}.
+Comparisons can be chained.  For example, \code{a < b == c} tests
+whether \code{a} is less than \code{b} and moreover \code{b} equals
+\code{c}.
 
 Comparisons may be combined by the Boolean operators \code{and} and
 \code{or}, and the outcome of a comparison (or of any other Boolean
@@ -2198,7 +2199,7 @@ \subsection{The Module Search Path \label{searchPath}}
 for a file named \file{spam.py} in the current directory,
 and then in the list of directories specified by
 the environment variable \envvar{PYTHONPATH}.  This has the same syntax as
-the shell variable \envvar{PATH}, i.e., a list of
+the shell variable \envvar{PATH}, that is, a list of
 directory names.  When \envvar{PYTHONPATH} is not set, or when the file
 is not found there, the search continues in an installation-dependent
 default path; on \UNIX{}, this is usually \file{.:/usr/local/lib/python}.
@@ -2289,7 +2290,8 @@ \section{Standard Modules \label{standardModules}}
 interpreter; these provide access to operations that are not part of
 the core of the language but are nevertheless built in, either for
 efficiency or to provide access to operating system primitives such as
-system calls. The set of such modules is a configuration option; e.g.,
+system calls.  The set of such modules is a configuration option which
+also dependson the underlying platform  For example,
 the \module{amoeba} module is only provided on systems that somehow
 support Amoeba primitives.  One particular module deserves some
 attention: \module{sys}\refstmodindex{sys}, which is built into every
@@ -2316,7 +2318,7 @@ \section{Standard Modules \label{standardModules}}
 interpreter's search path for modules. It is initialized to a default
 path taken from the environment variable \envvar{PYTHONPATH}, or from
 a built-in default if \envvar{PYTHONPATH} is not set.  You can modify
-it using standard list operations, e.g.: 
+it using standard list operations: 
 
 \begin{verbatim}
 >>> import sys
@@ -2384,15 +2386,15 @@ \section{Packages \label{packages}}
 Suppose you want to design a collection of modules (a ``package'') for
 the uniform handling of sound files and sound data.  There are many
 different sound file formats (usually recognized by their extension,
-e.g. \file{.wav}, \file{.aiff}, \file{.au}), so you may need to create
-and maintain a growing collection of modules for the conversion
-between the various file formats.  There are also many different
-operations you might want to perform on sound data (e.g. mixing,
-adding echo, applying an equalizer function, creating an artificial
-stereo effect), so in addition you will be writing a never-ending
-stream of modules to perform these operations.  Here's a possible
-structure for your package (expressed in terms of a hierarchical
-filesystem):
+for example: \file{.wav}, \file{.aiff}, \file{.au}), so you may need
+to create and maintain a growing collection of modules for the
+conversion between the various file formats.  There are also many
+different operations you might want to perform on sound data (such as
+mixing, adding echo, applying an equalizer function, creating an
+artificial stereo effect), so in addition you will be writing a
+never-ending stream of modules to perform these operations.  Here's a
+possible structure for your package (expressed in terms of a
+hierarchical filesystem):
 
 \begin{verbatim}
 Sound/                          Top-level package
@@ -2436,7 +2438,7 @@ \section{Packages \label{packages}}
 \end{verbatim}
 
 This loads the submodule \module{Sound.Effects.echo}.  It must be referenced
-with its full name, e.g.
+with its full name.
 
 \begin{verbatim}
 Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)
@@ -2523,7 +2525,7 @@ \subsection{Importing * From a Package \label{pkg-import-star}}
 defined in the package.  This includes any names defined (and
 submodules explicitly loaded) by \file{__init__.py}.  It also includes any
 submodules of the package that were explicitly loaded by previous
-import statements, e.g.
+import statements.  Consider this code:
 
 \begin{verbatim}
 import Sound.Effects.echo
@@ -2703,8 +2705,8 @@ \section{Fancier Output Formatting \label{formatting}}
 The value of PI is approximately 3.142.
 \end{verbatim}
 
-If there is more than one format in the string you pass a tuple as
-right operand, e.g.
+If there is more than one format in the string, you need to pass a
+tuple as right operand, as in this example:
 
 \begin{verbatim}
 >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
@@ -2727,7 +2729,7 @@ \section{Fancier Output Formatting \label{formatting}}
 If you have a really long format string that you don't want to split
 up, it would be nice if you could reference the variables to be
 formatted by name instead of by position.  This can be done by using
-an extension of C formats using the form \code{\%(name)format}, e.g.
+form \code{\%(name)format}, as shown here:
 
 \begin{verbatim}
 >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
@@ -3042,8 +3044,8 @@ \section{Handling Exceptions \label{handling}}
 specify handlers for different exceptions.  At most one handler will
 be executed.  Handlers only handle exceptions that occur in the
 corresponding try clause, not in other handlers of the same
-\keyword{try} statement. An except clause may name multiple exceptions
-as a parenthesized list, e.g.:
+\keyword{try} statement.  An except clause may name multiple exceptions
+as a parenthesized list, for example:
 
 \begin{verbatim}
 ... except (RuntimeError, TypeError, NameError):
@@ -3310,8 +3312,9 @@ \section{Python Scopes and Name Spaces \label{scopes}}
 Attributes may be read-only or writable.  In the latter case,
 assignment to attributes is possible.  Module attributes are writable:
 you can write \samp{modname.the_answer = 42}.  Writable attributes may
-also be deleted with the \keyword{del} statement, e.g.
-\samp{del modname.the_answer}.
+also be deleted with the \keyword{del} statement.  For example,
+\samp{del modname.the_answer} will remove the attribute
+\member{the_answer} from the object named by \code{modname}.
 
 Name spaces are created at different moments and have different
 lifetimes.  The namespace containing the built-in names is created
@@ -3338,7 +3341,7 @@ \section{Python Scopes and Name Spaces \label{scopes}}
 
 Although scopes are determined statically, they are used dynamically.
 At any time during execution, exactly three nested scopes are in use
-(i.e., exactly three namespaces are directly accessible): the
+(exactly three namespaces are directly accessible): the
 innermost scope, which is searched first, contains the local names,
 the middle scope, searched next, contains the current module's global
 names, and the outermost scope (searched last) is the namespace
@@ -3512,7 +3515,7 @@ \subsection{Instance Objects \label{instanceObjects}}
 The second kind of attribute references understood by instance objects
 are \emph{methods}.  A method is a function that ``belongs to'' an
 object.  (In Python, the term method is not unique to class instances:
-other object types can have methods as well, e.g., list objects have
+other object types can have methods as well.  For example, list objects have
 methods called append, insert, remove, sort, and so on.  However,
 below, we'll use the term method exclusively to mean methods of class
 instance objects, unless explicitly stated otherwise.)
@@ -3529,7 +3532,7 @@ \subsection{Instance Objects \label{instanceObjects}}
 
 \subsection{Method Objects \label{methodObjects}}
 
-Usually, a method is called immediately, e.g.:
+Usually, a method is called immediately:
 
 \begin{verbatim}
 x.f()
@@ -3583,9 +3586,10 @@ \section{Random Remarks \label{remarks}}
 Data attributes override method attributes with the same name; to
 avoid accidental name conflicts, which may cause hard-to-find bugs in
 large programs, it is wise to use some kind of convention that
-minimizes the chance of conflicts, e.g., capitalize method names,
-prefix data attribute names with a small unique string (perhaps just
-an underscore), or use verbs for methods and nouns for data attributes.
+minimizes the chance of conflicts.  Possible conventions include
+capitalizing method names, prefixing data attribute names with a small
+unique string (perhaps just an underscore), or using verbs for methods
+and nouns for data attributes.
 
 
 Data attributes may be referenced by methods as well as by ordinary
@@ -3647,7 +3651,7 @@ \section{Random Remarks \label{remarks}}
 
 
 Methods may call other methods by using method attributes of the
-\code{self} argument, e.g.:
+\code{self} argument:
 
 \begin{verbatim}
 class Bag:
@@ -3690,7 +3694,7 @@ \section{Inheritance \label{inheritance}}
 The name \class{BaseClassName} must be defined in a scope containing
 the derived class definition.  Instead of a base class name, an
 expression is also allowed.  This is useful when the base class is
-defined in another module, e.g.,
+defined in another module,
 
 \begin{verbatim}
 class DerivedClassName(modname.BaseClassName):
@@ -3785,10 +3789,10 @@ \section{Private Variables \label{private}}
 instance variables by code outside the class.  Note that the mangling
 rules are designed mostly to avoid accidents; it still is possible for
 a determined soul to access or modify a variable that is considered
-private.  This can even be useful, e.g. for the debugger, and that's
-one reason why this loophole is not closed.  (Buglet: derivation of a
-class with the same name as the base class makes use of private
-variables of the base class possible.)
+private.  This can even be useful in special circumstances, such as in
+the debugger, and that's one reason why this loophole is not closed.
+(Buglet: derivation of a class with the same name as the base class
+makes use of private variables of the base class possible.)
 
 Notice that code passed to \code{exec}, \code{eval()} or
 \code{evalfile()} does not consider the classname of the invoking 
@@ -3824,7 +3828,7 @@ \section{Odds and Ends \label{odds}}
 
 Sometimes it is useful to have a data type similar to the Pascal
 ``record'' or C ``struct'', bundling together a couple of named data
-items.  An empty class definition will do nicely, e.g.:
+items.  An empty class definition will do nicely:
 
 \begin{verbatim}
 class Employee:
