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{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
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
+important role in places where a constant hash value is needed, for
example as a key in a dictionary.
\index{integer division}
\index{interactive}
\item[interactive]
Python has an interactive interpreter which means that you can try out
-things and directly see its result. Just launch \code{python} with no
+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)}).
(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 from the second iteration
+return the same exhausted iterator object used in the previous iteration
pass, making it appear like an empty container.
\index{list comprehension}
\% 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 in that case.
+{}\code{range(256)} are processed.
+
+
+\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{mapping}
\item[mapping]
tracking object creation, implementing singletons, and many other
tasks.
-\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 the presence of
-many \keyword{if} statements.
-
\index{mutable}
\item[mutable]
Mutable objects can change their value but keep their \function{id()}.
\index{namespace}
\item[namespace]
The place where a variable is stored. Namespaces are implemented as
-dictionary. There is the local, global and builtins namespace and the
-nested namespaces in objects (in methods). Namespaces support
+dictionaries. There are the local, global and builtin namespaces
+as well asnested 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
\index{Python3000}
\item[Python3000]
-A mythical python release, allowed not to be backward compatible, with
+A mythical python release, not required be backward compatible, with
telepathic interface.
\index{__slots__}
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.
+numbers of instances in a memory-critical application.
\index{sequence}
\item[sequence]
\begin{verbatim}
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
->>> dict([(x, x**2) for x in (2, 4, 6)) # use a list comprehension
+>>> dict([(x, x**2) for x in (2, 4, 6)]) # use a list comprehension
{2: 4, 4: 16, 6: 36}
\end{verbatim}
variables'' or data attributes used by the common base class), it is
not clear that these semantics are in any way useful.
+%% XXX Add rules for new-style MRO?
\section{Private Variables \label{private}}
leading underscores, at most one trailing underscore) is textually
replaced with \code{_classname__spam}, where \code{classname} is the
current class name with leading underscore(s) stripped. This mangling
-is done without regard of the syntactic position of the identifier, so
+is done without regard to the syntactic position of the identifier, so
it can be used to define class-private instance and class variables,
-methods, as well as globals, and even to store instance variables
+methods, variables stored in globals, and even variables stored in instances.
private to this class on instances of \emph{other} classes. Truncation
may occur when the mangled name would be longer than 255 characters.
Outside classes, or when the class name consists of only underscores,
\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
+``record'' or C ``struct'', bundling together a few named data
items. An empty class definition will do nicely:
\begin{verbatim}
can often be passed a class that emulates the methods of that data
type instead. For instance, if you have a function that formats some
data from a file object, you can define a class with methods
-\method{read()} and \method{readline()} that gets the data from a string
+\method{read()} and \method{readline()} that get the data from a string
buffer instead, and pass it as an argument.% (Unfortunately, this
%technique has its limitations: a class can't define operations that
%are accessed by special syntax such as sequence subscripting or
Instance method objects have attributes, too: \code{m.im_self} is the
-object of which the method is an instance, and \code{m.im_func} is the
+instance object with the method \method{m}, and \code{m.im_func} is the
function object corresponding to the method.
\section{Command Line Arguments\label{command-line-arguments}}
-Common utility scripts often invoke processing command line arguments.
+Common utility scripts often need to process command line arguments.
These arguments are stored in the
\ulink{\module{sys}}{../lib/module-sys.html}\ module's \var{argv}
attribute as a list. For instance the following output results from
messages to make them visible even when \var{stdout} has been redirected:
\begin{verbatim}
->>> sys.stderr.write('Warning, log file not found starting a new one')
+>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one
\end{verbatim}
>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jceasar@example.org',
-"""To: jceasar@example.org
+"""To: jcaesar@example.org
From: soothsayer@example.org
Beware the Ides of March.
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
->>> now.strftime("%m-%d-%y or %d%b %Y is a %A on the %d day of %B")
-'12-02-03 or 02Dec 2003 is a Tuesday on the 02 day of December'
+>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
+'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'
# dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
37
>>> zlib.decompress(t)
'witch which has which witches wrist watch'
->>> zlib.crc32(t)
--1438085031
+>>> zlib.crc32(s)
+226805979
\end{verbatim}
\chapter{What Now? \label{whatNow}}
Reading this tutorial has probably reinforced your interest in using
-Python --- you should be eager to apply Python to solve your
+Python --- you should be eager to apply Python to solving your
real-world problems. Now what should you do?
You should read, or at least page through, the
this deletes the names it creates once they are no longer needed; this
is done since the startup file is executed in the same namespace as
the interactive commands, and removing the names avoids creating side
-effects in the interactive environments. You may find it convenient
+effects in the interactive environment. You may find it convenient
to keep some of the imported modules, such as
\ulink{\module{os}}{../lib/module-os.html}, which turn
out to be needed in most sessions with the interpreter.
and so on. No matter how many digits you're willing to write down, the
result will never be exactly 1/3, but will be an increasingly better
-approximation to 1/3.
+approximation of 1/3.
In the same way, no matter how many base 2 digits you're willing to
use, the decimal value 0.1 cannot be represented exactly as a base 2
\var{x}, but rounding to 16 digits is not enough to make that true.
Note that this is in the very nature of binary floating-point: this is
-not a bug in Python, it is not a bug in your code either, and you'll
+not a bug in Python, it is not a bug in your code either. You'll
see the same kind of thing in all languages that support your
hardware's floating-point arithmetic (although some languages may
not \emph{display} the difference by default, or in all output modes).
\code{< 2**53}), the best value for \var{N} is 56:
\begin{verbatim}
->>> 2L**52
+>>> 2**52
4503599627370496L
>>> 2L**53
9007199254740992L
projects / python / commitdiff