Python pocket reference 5ed. Edition Mark Lutz

Python pocket reference 5ed. Edition Mark Lutz
pdf download
https://ebookgate.com/product/python-pocket-reference-5ed-
edition-mark-lutz/
Get Instant Ebook Downloads – Browse at https://ebookgate.com

Get Your Digital Files Instantly: PDF, ePub, MOBI and More
Quick Digital Downloads: PDF, ePub, MOBI and Other Formats
Programming Python 3rd ed Edition Mark Lutz
https://ebookgate.com/product/programming-python-3rd-ed-edition-
mark-lutz/
Learning Python 2nd ed Edition Mark Lutz
https://ebookgate.com/product/learning-python-2nd-ed-edition-
mark-lutz/
grep Pocket Reference A Quick Pocket Reference for a
Utility Every Unix User Needs Pocket Reference O Reilly
1st Edition Bambenek
https://ebookgate.com/product/grep-pocket-reference-a-quick-
pocket-reference-for-a-utility-every-unix-user-needs-pocket-
reference-o-reilly-1st-edition-bambenek/
JavaScript Pocket Reference 2nd Edition Flanagan
https://ebookgate.com/product/javascript-pocket-reference-2nd-
edition-flanagan/

Engineers Precision Data Pocket Reference Heather
https://ebookgate.com/product/engineers-precision-data-pocket-
reference-heather/
Python Essential Reference 3rd Edition Beazley
https://ebookgate.com/product/python-essential-reference-3rd-
edition-beazley/
C Pocket Reference 1st Edition Peter Prinz
https://ebookgate.com/product/c-pocket-reference-1st-edition-
peter-prinz/
Windows PowerShell pocket reference 2nd Edition Lee
Holmes
https://ebookgate.com/product/windows-powershell-pocket-
reference-2nd-edition-lee-holmes/
CSS Pocket Reference 5th Edition Eric A. Meyer
https://ebookgate.com/product/css-pocket-reference-5th-edition-
eric-a-meyer/

Mark Lutz
FIFTH EDITION
Python Pocket Reference

Python Pocket Reference, Fifth Edition
by Mark Lutz
Copyright © 2014 Mark Lutz. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebasto‐
pol, CA 95472.
O’Reillybooksmaybepurchasedforeducational,business,orsalespromotional
use. Online editions are also available for most titles (http://my.safaribookson
line.com). For more information, contact our corporate/institutional sales de‐
partment: 800-998-9938 or corporate@oreilly.com.
Editor: Rachel Roumeliotis
Production Editor: Kristen Brown
Copyeditor: Richard Carey
Proofreader: Amanda Kersey
Indexer: Lucie Haskins
Cover Designer: Randy Comer
Interior Designer: David Futato
October 1998: First Edition
January 2002: Second Edition
February 2005: Third Edition
October 2009: Fourth Edition
February 2014: Fifth Edition
Revision History for the Fifth Edition:
2014-01-17: First release
See http://oreilly.com/catalog/errata.csp?isbn=9781449357016 for release de‐
tails.
Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are
registered trademarks of O’Reilly Media, Inc. Python Pocket Reference, the im‐
age of a rock python, and related trade dress are trademarks of O’Reilly Media,
Inc.
Many of the designations used by manufacturers and sellers to distinguish their
products are claimed as trademarks. Where those designations appear in this
book, and O’Reilly Media, Inc. was aware of a trademark claim, the designations
have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the
publisher and authors assume no responsibility for errors or omissions, or for
damages resulting from the use of the information contained herein.
ISBN: 978-1-449-35701-6
[M]

Table of Contents
Introduction 1
Book Conventions 2
Python Command-Line Usage 3
Python Command Options 4
Command-Line Program Specification 5
Python 2.X Command Options 7
Python Environment Variables 7
Operational Variables 8
Python Command Option Variables 9
Python Windows Launcher Usage 10
Launcher File Directives 10
Launcher Command Lines 11
Launcher Environment Variables 11
Built-in Types and Operators 12
Operators and Precedence 12
Operator Usage Notes 14
Operations by Category 16
Sequence Operation Notes 20
Specific Built-in Types 21
Numbers 22
iii

Strings 24
Unicode Strings 42
Lists 46
Dictionaries 53
Tuples 57
Files 58
Sets 63
Other Types and Conversions 65
Statements and Syntax 67
Syntax Rules 67
Name Rules 69
Specific Statements 71
The Assignment Statement 72
The Expression Statement 76
The print Statement 77
The if Statement 80
The while Statement 80
The for Statement 80
The pass Statement 81
The break Statement 81
The continue Statement 81
The del Statement 81
The def Statement 82
The return Statement 86
The yield Statement 87
The global Statement 88
The nonlocal Statement 89
The import Statement 89
The from Statement 93
The class Statement 95
The try Statement 97
The raise Statement 99
iv | Table of Contents

The assert Statement 101
The with Statement 102
Python 2.X Statements 104
Namespace and Scope Rules 105
Qualified Names: Object Namespaces 105
Unqualified Names: Lexical Scopes 105
Nested Scopes and Closures 107
Object-Oriented Programming 108
Classes and Instances 109
Pseudoprivate Attributes 110
New-Style Classes 111
Formal Inheritance Rules 112
Operator Overloading Methods 117
Methods for All Types 118
Methods for Collections (Sequences, Mappings) 123
Methods for Numbers (Binary Operators) 125
Methods for Numbers (Other Operations) 128
Methods for Descriptors 129
Methods for Context Managers 130
Python 2.X Operator Overloading Methods 131
Built-in Functions 134
Python 2.X Built-in Functions 155
Built-in Exceptions 161
Superclasses: Categories 162
Specific Exceptions 163
Specific OSError Exceptions 167
Warning Category Exceptions 169
Warnings Framework 170
Python 3.2 Built-in Exceptions 171
Python 2.X Built-in Exceptions 172
Built-in Attributes 172
Standard Library Modules 173
Table of Contents | v

The sys Module 174
The string Module 182
Functions and Classes 182
Constants 183
The os System Module 184
Administrative Tools 185
Portability Constants 186
Shell Commands 187
Environment Tools 189
File Descriptor Tools 190
File Pathname Tools 193
Process Control 197
The os.path Module 200
The re Pattern-Matching Module 202
Module Functions 202
Regular Expression Objects 205
Match Objects 205
Pattern Syntax 207
Object Persistence Modules 210
The shelve and dbm Modules 211
The pickle Module 213
The tkinter GUI Module and Tools 216
tkinter Example 216
tkinter Core Widgets 217
Common Dialog Calls 218
Additional tkinter Classes and Tools 219
Tcl/Tk-to-Python/tkinter Mappings 220
Internet Modules and Tools 221
Other Standard Library Modules 224
The math Module 224
The time Module 225
The timeit Module 226
vi | Table of Contents

The datetime Module 227
The random Module 228
The json Module 228
The subprocess Module 229
The enum Module 229
The struct Module 230
Threading Modules 231
Python SQL Database API 232
API Usage Example 233
Module Interface 234
Connection Objects 234
Cursor Objects 235
Type Objects and Constructors 236
More Hints and Idioms 236
Core Language Hints 237
Environment Hints 238
Usage Hints 240
Assorted Hints 242
Index 243
Table of Contents | vii

Python Pocket Reference
Introduction
Python is a general-purpose, multiparadigm, open source com‐
puter programming language, with support for object-oriented,
functional, and procedural coding structures. It is commonly
used both for standalone programs and for scripting applications
in a wide variety of domains, and is generally considered to be
one of the most widely used programming languages in the
world.
AmongPython’sfeaturesareanemphasisoncodereadabilityand
library functionality, and a design that optimizes developer pro‐
ductivity, software quality, program portability, and component
integration.Pythonprogramsrunonmostplatformsincommon
use, including Unix and Linux, Windows and Macintosh, Java
and .NET, Android and iOS, and more.
This pocket reference summarizes Python types and statements,
special method names, built-in functions and exceptions, com‐
monly used standard library modules, and other prominent
Python tools. It is intended to serve as a concise reference tool
for developers and is designed to be a companion to other books
that provide tutorials, code examples, and other learning
materials.
This fifth edition covers both Python 3.X and 2.X. It focuses pri‐
marily on 3.X, but also documents differences in 2.X along the
1

way. Specifically, this edition has been updated to be current with
Python versions 3.3 and 2.7 as well as prominent enhancements
in the imminent 3.4 release, although most of its content also
appliesbothtoearlierandtolaterreleasesinthe3.Xand2.Xlines.
This edition also applies to all major implementations of Python
—including CPython, PyPy, Jython, IronPython, and Stackless
—and has been updated and expanded for recent changes in lan‐
guage, libraries, and practice. Its changes include new coverage
of the MRO and super(); formal algorithms of inheritance, im‐
ports, context managers, and block indentation; and commonly
used library modules and tools, including json, timeit, random,
subprocess, enum, and the new Windows launcher.
Book Conventions
The following notational conventions are used in this book:
[]
In syntax formats, items in brackets are optional; brackets
are also used literally in some parts of Python’s syntax as
noted where applicable (e.g., lists).
*
In syntax formats, items followed by an asterisk can be re‐
peated zero or more times; star is also used literally in some
parts of Python’s syntax (e.g., multiplication).
a | b
In syntax formats, items separated by a bar are alternatives;
barisalsousedliterallyinsomepartsofPython’ssyntax(e.g.,
union).
Italic
Used for filenames and URLs, and to highlight new or im‐
portant terms.
Constant width
Used for code, commands, and command-line options, and
toindicatethenamesofmodules,functions,attributes,vari‐
ables, and methods.
2 | Python Pocket Reference

Constant width italic
Used for replaceable parameter names in the syntax of com‐
mand lines, expressions, functions, and methods.
Function()
Except where noted, callable functions and methods are de‐
noted by trailing parentheses, to distinguish them from oth‐
er types of attributes.
See “Section Header Name”
Referencestoothersectionsinthisbookaregivenbysection
header text in double quotes.
NOTE
In this book, “3.X” and “2.X” mean that a topic applies to
all commonly used releases in a Python line. More specific
release numbers are used for topics of more limited scope
(e.g., “2.7” means 2.7 only). Because future Python changes
can invalidate applicability to future releases, also see
Python’s “What’s New” documents, currently maintained at
http://docs.python.org/3/whatsnew/index.html for Pythons
released after this book.
Python Command-Line Usage
Command lines used to launch Python programs from a system
shell have the following format:
python [option*]
[ scriptfile | -c command | -m module | - ] [arg*]
In this format, python denotes the Python interpreter executable
with either a full directory path, or the word python that is re‐
solved by the system shell (e.g., via PATH settings). Command-line
options intended for Python itself appear before the specification
of the program code to be run (option). Arguments intended for
the code to be run appear after the program specification (arg).
Python Command-Line Usage | 3

Python Command Options
The option items in Python command lines are used by Python
itself, and can be any of the following in Python 3.X (see “Python
2.X Command Options” ahead for 2.X differences):
-b
Issue warnings for calling str() with a bytes or bytearray
object and no encoding argument, and comparing a bytes
or bytearray with a str. Option -bb issues errors instead.
-B
Do not write .pyc or .pyo byte-code files on imports.
-d
Turn on parser debugging output (for developers of the
Python core).
-E
IgnorePythonenvironmentvariablesdescribedahead(such
as PYTHONPATH).
-h
Print help message and exit.
-i
Enter interactive mode after executing a script. Hint: useful
for postmortem debugging; see also pdb.pm(), described in
Python’s library manuals.
-O
Optimizegeneratedbytecode(createanduse.pyobyte-code
files). Currently yields a minor performance improvement.
-OO
Operates like -O, the previous option, but also removes
docstrings from byte code.
-q
Do not print version and copyright message on interactive
startup (as of Python 3.2).

-s
Do not add the user site directory to the sys.path module
search path.
-S
Do not imply “import site” on initialization.
-u
Force stdout and stderr to be unbuffered and binary.
-v
Print a message each time a module is initialized, showing
the place from which it is loaded; repeat this flag for more
verbose output.
-V
Print Python version number and exit (also available as
--version).
-W arg
Warnings control: arg takes the form action:message:
category:module:lineno. See also “Warnings Framework”
and “Warning Category Exceptions” ahead, and the warn
ings module documentation in the Python Library Refer‐
ence manual (available at http://www.python.org/doc/).
-x
Skip first line of source, allowing use of non-Unix forms of
#!cmd.
-X option
Set implementation-specific option (as of Python 3.2); see
implementation documentation for supported option
values.
Command-Line Program Specification
Code to be run and command-line arguments to send to it are
specified in the following ways in Python command lines:
Python Command-Line Usage | 5

scriptfile
Denotes the name of a Python script file to run as the main,
topmostfileofaprogram(e.g.,python main.py runsthecode
in main.py). The script’s name may be an absolute or relative
(to “.”) filename path, and is made available in sys.argv[0].
On some platforms, command lines may also omit the
python component if they begin with a script file name and
have no options for Python itself.
-c command
Specifies Python code (as a string) to run (e.g., python -c
"print('spam' * 8)" runs a Python print operation).
sys.argv[0] is set to '-c'.
-m module
Runs a module as a script: searches for module on sys.path
and runs it as a top-level file (e.g., python -m pdb s.py runs
the Python debugger module pdb located in a standard li‐
brary directory, with argument s.py). module may also name
a package (e.g., idlelib.idle). sys.argv[0] is set to the
module’s full path name.
−
Reads Python commands from the standard input stream,
stdin (the default); enters interactive mode if stdin is a “tty”
(interactive device). sys.argv[0] is set to '−'.
arg*
Indicates that anything else on the command line is passed
to the script file or command, and appears in the built-in list
of strings sys.argv[1:].
If no scriptfile, command, or module is given, Python enters in‐
teractive mode, reading commands from stdin (and using GNU
readline for input, if installed), and setting sys.argv[0] to '' (the
empty string) unless invoked with option – in the preceding list.
Besides using traditional command lines at a system shell
prompt, you can also generally start Python programs by clicking
their filenames in a file explorer GUI; by calling functions in the

Python standard library (e.g., os.popen()); by using program-
launch menu options in IDEs such as IDLE, Komodo, Eclipse,
and NetBeans; and so on.
Python 2.X Command Options
Python 2.X supports the same command-line format, but does
not support the -b option, which is related to Python 3.X’s string
typechanges,northerecent–qand–Xadditionsin3.X.Itsupports
additional options in 2.6 and 2.7 (some may be present earlier):
-t and -tt
Issues warnings for inconsistent mixtures of tabs and spaces
in indentation. Option -tt issues errors instead. Python 3.X
alwaystreatssuchmixturesassyntaxerrors(seealso“Syntax
Rules”).
-Q
Division-related options: -Qold (the default), -Qwarn,
-Qwarnall, and –Qnew. These are subsumed by the new true
division behavior of Python 3.X (see also “Operator Usage
Notes”).
-3
Issues warnings about any Python 3.X incompatibilities in
code that the Python standard installation’s 2to3 tool cannot
trivially fix.
-R
Enables a pseudorandom salt to make hash values of various
types be unpredictable between separate invocations of the
interpreter, as a defense against denial-of-service attacks.
New in Python 2.6.8. This switch is also present in 3.X as of
3.2.3 for compatibility, but this hash randomization is en‐
abled by default as of 3.3.
Python Environment Variables
Environment (a.k.a. shell) variables are systemwide settings that
span programs and are used for global configuration.
Python Environment Variables | 7

Operational Variables
The following are major user-configurable environment vari‐
ables related to script behavior:
PYTHONPATH
Augments the default search path for imported module files.
The format of this variable’s value is the same as the shell’s
PATH setting: directory pathnames separated by colons
(semicolons on Windows). If set, module imports search for
imported files or directories in each directory listed in
PYTHONPATH, from left to right. Merged into sys.path—the
fullmodulesearchpathforleftmostcomponentsinabsolute
imports—after the script’s directory, and before standard li‐
brary directories. See also sys.path in “The sys Module”,
and “The import Statement”.
PYTHONSTARTUP
If set to the name of a readable file, the Python commands
in that file are executed before the first prompt is displayed
in interactive mode (useful to define often-used tools).
PYTHONHOME
If set, the value is used as an alternate prefix directory for
library modules (or sys.prefix, sys.exec_prefix). The de‐
fault module search path uses sys.prefix/lib.
PYTHONCASEOK
If set, filename case is ignored in import statements (cur‐
rently only on Windows and OS X).
PYTHONIOENCODING
Assign to string encodingname[:errorhandler] to override
the default Unicode encoding (and optional error handler)
used for text transfers made to the stdin, stdout, and stderr
streams. This setting may be required for non-ASCII text in
some shells (e.g., try setting this to utf8 or other if prints
fail).

PYTHONHASHSEED
If set to “random”, a random value is used to seed the hashes
of str, bytes, and datetime objects; may also be set to an
integerintherangeguatda.com/cmx.p0...4,294,967,295 togethashvalueswith
a predictable seed (as of Python 3.2.3 and 2.6.8).
PYTHONFAULTHANDLER
If set, Python registers handlers at startup to dump a trace‐
back on fatal signal errors (as of Python 3.3, and equivalent
to -X faulthandler).
Python Command Option Variables
The following environment variables are synonymous with some
of Python’s command-line options (see “Python Command Op‐
tions”):
PYTHONDEBUG
If nonempty, same as -d option.
PYTHONDONTWRITEBYTECODE
If nonempty, same as -B option.
PYTHONINSPECT
If nonempty, same as -i option.
PYTHONNOUSERSITE
If nonempty, same as -s option.
PYTHONOPTIMIZE
If nonempty, same as -O option.
PYTHONUNBUFFERED
If nonempty, same as -u option.
PYTHONVERBOSE
If nonempty, same as -v option.
PYTHONWARNINGS
If nonempty, same as -W option, with same value. Also ac‐
cepts a comma-separated string as equivalent to multiple -W
options. (As of Python 3.2 and 2.7.)
Python Environment Variables | 9

Python Windows Launcher Usage
OnWindows(only),Python3.3andlaterinstallascriptlauncher,
also available separately for earlier versions. This launcher con‐
sists of the executables py.exe (console) and pyw.exe (noncon‐
sole), which can be invoked without PATH settings; are registered
to run Python files via filename associations; and allow Python
versions to be selected in three ways—with “#!” Unix-like direc‐
tives at the top of scripts, with command-line arguments, and
with configurable defaults.
Launcher File Directives
The launcher recognizes “#!” lines at the top of script files that
name Python versions in one of the following forms, in which *
is either: empty to use the default version (currently 2 if installed
and similar to omitting a “#!” line); a major version number (e.g.,
3) to launch the latest version in that line installed; or a com‐
plete major.minor specification, optionally suffixed by −32 to pre‐
fer a 32-bit install (e.g., 3.1–32):
#!/usr/bin/env python*
#!/usr/bin/python*
#!/usr/local/bin/python*
#!python*
Any Python (python.exe) arguments may be given at the end of
the line, and Python 3.4 and later may consult PATH for “#!” lines
that give just python with no explicit version number.

Launcher Command Lines
The launcher may also be invoked from a system shell with com‐
mand lines of the following form:
py [pyarg] [pythonarg*] script.py [scriptarg*]
More generally, anything that may appear in a python command
after its python component may also appear after the optional
pyarg in a py command, and is passed on to the spawned Python
verbatim. This includes the -m, -c, and - program specification
forms; see “Python Command-Line Usage”.
The launcher accepts the following argument forms for its op‐
tional pyarg, which mirror the * part at the end of a file’s “#!” line:
−2 Launch latest 2.X version installed
-3 Launch latest 3.X version installed
-X.Y Launch specified version (X is 2 or 3)
-X.Y−32 Launch the specified 32-bit version
If both are present, command-line arguments have precedence
over values given in “#!” lines. As installed, “#!” lines may be
applied in more contexts (e.g., icon clicks).
Launcher Environment Variables
The launcher also recognizes optional environment variable set‐
tings,whichmaybeusedtocustomizeversionselectionindefault
or partial cases (e.g., missing or major-only “#!” or py command
argument):
PY_PYTHON Version to use in default cases (else 2)
PY_PYTHON3 Version to use in 3 partials (e.g., 3.2)
PY_PYTHON2 Version to use in 2 partials (e.g., 2.6)
These settings are used only by launcher executables, not when
python is invoked directly.
Python Windows Launcher Usage | 11

Built-in Types and Operators
Operators and Precedence
Table1listsPython’sexpressionoperators.Operatorsinthelower
cells of this table have higher precedence (i.e., bind tighter) when
used in mixed-operator expressions without parentheses.
Atomic terms and dynamic typing
In Table 1, the replaceable expression items X, Y, Z, i, j, and k may
be:
• Variable names, replaced with their most recently assigned
value
• Literal expressions, defined in “Specific Built-in Types”
• Nested expressions, taken from any row in this table, pos‐
sibly in parentheses
Python variables follow a dynamic typing model—they are not
declared, and are created by being assigned; have object refer‐
ences as values, and may reference any type of object; and must
be assigned before appearing in expressions, as they have no de‐
fault value. Case is always significant in variable names (see
“Name Rules”). Objects referenced by variables are automatically
created, and automatically reclaimed when no longer in use by
Python’s garbage collector, which uses reference counters in
CPython.
Also in Table 1, replaceable attr must be the literal (unquoted)
name of an attribute; args1 is a formal arguments list as defined
in“ThedefStatement”;args2isaninputargumentslistasdefined
in “The Expression Statement”; and a literal ... qualifies as an
atomic expression in 3.X (only).

The syntax of comprehensions and data structure literals (tuple,
list, dictionary, and set) given abstractly in the last three rows of
Table 1 is defined in “Specific Built-in Types”.
Table 1. Python 3.X expression operators and precedence
Operator Description
yield X Generatorfunctionresult(returnssend() value)
lambda args1: X Anonymous function maker (returns X when
called)
X if Y else Z Ternary selection (X is evaluated only if Y is true)
X or Y Logical OR: Y is evaluated only if X is false
X and Y Logical AND: Y is evaluated only if X is true
not X Logical negation
X in Y, X not in Y Membership: iterables, sets
X is Y, X is not Y Object identity tests
X < Y, X <= Y, X > Y, X >= Y Magnitude comparisons, set subset and superset
X == Y, X != Y Equality operators
X | Y Bitwise OR, set union
X ^ Y Bitwise exclusive OR, set symmetric difference
X & Y Bitwise AND, set intersection
X << Y, X >> Y Shift X left, right by Y bits
X + Y, X − Y Addition/concatenation, subtraction/set
difference
X * Y, X % Y,
X / Y, X // Y
Multiplication/repetition, remainder/format,
division, floor division
-X, +X Unary negation, identity
˜X Bitwise NOT complement (inversion)
X ** Y Power (exponentiation)
X[i] Indexing (sequence, mapping, others)
X[i:j:k] Slicing (all three bounds optional)
X(args2) Call (function, method, class, other callable)
Built-in Types and Operators | 13

X.attr Attribute reference
(....) Tuple, expression, generator expression
[....] List, list comprehension
{....} Dictionary, set, dictionary and set comprehension
Operator Usage Notes
• InPython2.Xonly,valueinequalitycanbewrittenaseither
X != Y or X <> Y. In Python 3.X, the latter of these options is
removed because it is redundant.
• In Python 2.X only, a backquotes expression `X` works the
same as repr(X), and converts objects to display strings. In
Python 3.X, use the more readable str() and repr() built-
in functions instead.
• In both Python 3.X and 2.X, the X // Y floor division ex‐
pression always truncates fractional remainders, and re‐
turns an integer result for integers.
• The X / Y expression performs true division in 3.X (always
retaining remainders in a floating-point result), and classic
division in 2.X (truncating remainders for integers) unless
3.X’s true division is enabled in 2.X with from __future__
import division or Python option -Qnew.
• The syntax [....] is used for both list literals and list com‐
prehension expressions. The latter of these performs an
implied loop and collects expression results in a new list.
• The syntax (....) is used for tuples and expressions, as
well as generator expressions—a form of list comprehen‐
sion that produces results on demand, instead of building
a result list. Parentheses may sometimes be omitted in all
three constructs.

• The syntax {....} is used for dictionary literals. In Python
3.X and 2.7, it is also used for set literals, and both dictio‐
nary and set comprehensions; use set() and looping state‐
ments in 2.6 and earlier.
• The yield and ternary if/else selection expressions are
availableinPython2.5andlater.Theformerreturnssend()
arguments in generators; the latter is a shorthand for a
multiline if statement. yield requires parentheses if not
alone on the right side of an assignment statement.
• Comparison operators may be chained: X < Y < Z produces
the same result as X < Y and Y < Z, but Y is evaluated only
once in the chained form.
• The slice expression X[i:j:k] is equivalent to indexing
with a slice object: X[slice(i, j, k)].
• In Python 2.X, magnitude comparisons of mixed types are
allowed—converting numbers to a common type, and or‐
dering other mixed types according to the type name. In
Python 3.X, nonnumeric mixed-type magnitude compar‐
isons are not allowed and raise exceptions; this includes
sorts by proxy.
• Magnitude comparisons for dictionaries are also no longer
supported in Python 3.X (although equality tests are);
comparingsorted(adict.items()) isonepossiblereplace‐
ment in 3.X.
• Call expressions allow for positional and keyword argu‐
ments, and arbitrarily large numbers of both; see “The Ex‐
pression Statement” and “The def Statement” for call
syntax.
• Python 3.X allows ellipsis (literally, ..., and known by
built-in name Ellipsis) to be used as an atomic expression
anywhereinsourcecode.Thismaybeusedasanalternative
topass orNone insomecontexts(e.g.,stubbed-outfunction
bodies, type-independent variable initialization).

• Although uncertain at this writing, Python 3.5 or later may
generalize the *X and **X star syntax to appear in data
structureliteralsandcomprehensions,whereitwillunpack
collections into individual items, much as it currently does
infunctioncalls.See“TheAssignmentStatement”formore
details.
Operations by Category
In this section, trailing parentheses are omitted from __X__
method names for brevity. In general, all built-in types support
the comparisons and Boolean operations listed in Table 2 (al‐
though Python 3.X does not support magnitude comparisons for
dictionaries or mixed nonnumeric types).
Boolean true means any nonzero number or any nonempty col‐
lectionobject(list,dictionary,etc.),andallobjectshaveaBoolean
value. The built-in names True and False are preassigned to true
and false values and behave like integers 1 and 0 with custom
display formats. The special object None is false and appears in
various Python contexts.
Comparisons return True or False and are automatically applied
recursively in compound objects as needed to determine a result.
Boolean and and or operators stop (short-circuit) as soon as a
result is known and return one of the two operand objects—the
value on the left or the right of the operator—whose Boolean
value gives the result.
Table 2. Comparisons and Boolean operations
X < Y Strictly less thana
X <= Y Less than or equal to
X > Y Strictly greater than
X >= Y Greater than or equal to
X == Y Equal to (same value)

X != Y Not equal to (same as X<>Y in Python 2.X
only)b
X is Y Same object
X is not Y Negated object identity
X < Y < Z Chained comparisons
not X If X is false then True; else, False
X or Y If X is false then Y; else, X
X and Y If X is false then X; else, Y
aToimplementcomparisonexpressions,seeboththerichcomparison(e.g.,__lt__
for<)classmethodsin3.Xand2.X,andgeneral__cmp__methodin2.X,described
in “Operator Overloading Methods”.
b != and <> both mean not equal by value in 2.X, but != is the preferred syntax
in 2.X and the only supported option in 3.X. is performs an identity test; ==
performs value comparison, and so is much more generally useful.
Tables 3 through 6 define operations common to types in the
three major type categories—sequence (positionally ordered),
mapping (access-by-key), and number (all numeric types)—as
well as operations available for mutable (changeable) types in
Python. Most types also export additional type-specific opera‐
tions (e.g., methods), as described in “Specific Built-in Types”.
Table 3. Sequence operations (strings, lists, tuples, bytes, bytearray)
Operation Description Class method
X in S
X not in S
Membership tests __contains__,
__iter__,
__getitem__a
S1 + S2 Concatenation __add__
S * N, N * S Repetition __mul__
S[i] Index by offset __getitem__

S[i:j], S[i:j:k] Slicing: items in S from
offset i through j−1 by
optional stride k
__getitem__b
len(S) Length __len__
min(S), max(S) Minimum, maximum item __iter__,
__getitem__
iter(S) Iteration protocol __iter__
for X in S:,
[expr for X in S],
map(func, S), etc.
Iteration (all contexts) __iter__,
__getitem__
a See also “The iteration protocol” for more on these methods and their interplay.
If defined, __contains__ is preferred over __iter__, and __iter__ is
preferred over __getitem__.
b In Python 2.X, you may also define __getslice__, __setslice__, and
__delslice__ to handle slicing operations. In 3.X, these are removed in favor
ofpassingsliceobjectstotheiritem-basedindexingcounterparts.Sliceobjectsmay
be used explicitly in indexing expressions in place of i:j:k bounds.
Table 4. Mutable sequence operations (lists, bytearray)
S[i] = X Index assignment: change item at existing
offset i to reference X
__setitem__
S[i:j] = I,
S[i:j:k] = I
Slice assignment: S from i through j−1
with optional stride k (possibly empty) is
replaced by all items in iterable I
__setitem__
del S[i] Index deletion __delitem__
del S[i:j],
del S[i:j:k]
Slice deletion __delitem__

Table 5. Mapping operations (dictionaries)
D[k] Index by key __getitem__
D[k] = X Key assignment: change or
create entry for key k to
reference X
__setitem__
del D[k] Delete item by key __delitem__
len(D) Length (number of keys) __len__
k in D Key membership testa Same as in Table 3
k not in D Converse of k in D Same as in Table 3
iter(D) Iterator object for D’s keys Same as in Table 3
for k in D:, etc. Iterate through keys in D (all
iteration contexts)
Same as in Table 3
a In Python 2.X, key membership may also be coded as D.has_key(k). This
method is removed in Python 3.X in favor of the in expression, which is also
generally preferred in 2.X. See “Dictionaries”.
Table 6. Numeric operations (all number types)
X + Y, X − Y Add, subtract __add__, __sub__
X * Y, X / Y,
X // Y, X % Y
Multiply, divide, floor
divide, remainder
__mul__, __truediv__a,
__floordiv__, __mod__
−X, +X Negative, identity __neg__, __pos__
X | Y, X & Y,
X ^ Y
Bitwise OR, AND,
exclusive OR (integers)
__or__, __and__, __xor__
X << N, X >> N Bitwiseleft-shift,right-
shift (integers)
__lshift__, __rshift__
˜X Bitwise invert
(integers)
__invert__
X ** Y X to the power Y __pow__
abs(X) Absolute value __abs__

int(X) Convert to integerb __int__
float(X) Convert to float __float__
complex(X),
complex(re,im)
Make a complex value __complex__
divmod(X, Y) Tuple: (X / Y, X % Y) __divmod__
pow(X, Y [,Z]) Raise to a power __pow__
a The / operator invokes __truediv__ in Python 3.X, but __div__ in Python 2.X
unless true division is enabled. See “Operator Usage Notes” for division semantics.
b In Python 2.X, the long() built-in function invokes the __long__ class method.
In Python 3.X, the int type subsumes long, which is removed.
Sequence Operation Notes
Examples and notes on selected sequence operations in Table 3
and Table 4:
Indexing: S[i]
• Fetches components at offsets (first item is at offset 0).
• Negative indexes count backward from the end (last item
is at offset −1).
• S[0] fetches the first item; S[1] fetches the second item.
• S[−2] fetches the second-to-last item (same as S[len(S)
− 2]).
Slicing: S[i:j]
• Extracts contiguous sections of a sequence, from i through
j−1.
• Slice boundaries i and j default to 0 and sequence length
len(S).
• S[1:3] fetches from offsets 1 up to, but not including, 3.
• S[1:] fetches from offsets 1 through the end (len(S)-1).

• S[:−1] fetches from offsets 0 up to, but not including, the
last item.
• S[:] makes a top-level (shallow) copy of sequence object S.
Extended slicing: S[i:j:k]
• The third item k is a stride (default 1), added to the offset
of each item extracted.
• S[::2] is every other item in entire sequence S.
• S[::−1] is sequence S reversed.
• S[4:1:−1] fetches from offsets 4 up to, but not including,
1, reversed.
Slice assignment: S[i:j:k] = I
• Slice assignment is similar to deleting and then inserting
where deleted.
• Iterables assigned to basic slices S[i:j] need not match in
size.
• Iterables assigned to extended slices S[i:j:k] must match
in size.
Other
• Concatenation, repetition, and slicing return new objects
(though not always for tuples).
Specific Built-in Types
This section covers numbers, strings, lists, dictionaries, tuples,
files,sets,andothercorebuilt-intypes.Itssubsectionsgivedetails
common to both Python 3.X and 2.X. In general, all the
compound datatypes covered here (e.g., lists, dictionaries, and
tuples) can nest inside each other arbitrarily and as deeply as
Specific Built-in Types | 21

1. InPython2.X,thereisadistincttypenamedlongforunlimited-precision
integers; int is for normal integers with precision that is usually limited
to 32 bits. Long objects may be coded with a trailing “L” (e.g., 99999L),
although integers are automatically promoted to longs if they require the
extra precision. In 3.X, the int type provides unlimited precision and so
subsumes both the 2.X int and long types; the “L” literal syntax is re‐
moved in 3.X.
2. In Python 2.X, octal literals may also be written with just a leading zero
—0777and0o777areequivalent.In3.X,onlythelatterformissupported
for octal.
required. Sets may participate in nesting as well, but may contain
only immutable objects.
Numbers
Numbers are immutable (unchangeable) values, supporting nu‐
meric operations. This section covers basic number types (inte‐
gers, floating-point), as well as more advanced types (complex,
decimals, and fractions).
Literals and creation
Numbers are written in a variety of numeric literal forms, and
created by some built-in operations:
1234, −24, +42, 0
Integers (unlimited precision).1
1.23, 3.14e-10, 4E210, 4.0e+210, 1., .1
Floating-point (normally implemented as C doubles in
CPython).
0o177, 0x9ff, 0b1111
Octal, hex, and binary literals for integers.2
3+4j, 3.0+4.0j, 3J
Complex numbers.

decimal.Decimal('1.33'), fractions.Fraction(4, 3)
Module-based types: decimal, fraction.
int(9.1), int('-9'), int('1111', 2), int('0b1111', 0),
float(9), float('1e2'), float('-.1'), complex(3, 4.0)
Create numbers from other objects, or from strings with
possible base conversion. Conversely, hex(N), oct(N), and
bin(N) createdigitstringsforintegers,andstringformatting
makes general strings for numbers. See also “String format‐
ting”, “Type Conversions”, and “Built-in Functions”.
Operations
Number types support all number operations (see Table 6 on page
19). In mixed-type expressions, Python converts operands up to
thetypeofthe“highest”type,whereintegerislowerthanfloating-
point, which is lower than complex. As of Python 3.0 and 2.6,
integer and floating-point objects also have a handful of type-
specific methods and other attributes; see Python’s Library Ref‐
erence manual for details:
>>> (2.5).as_integer_ratio() # float attrs
(5, 2)
>>> (2.5).is_integer()
False
>>> (2).numerator, (2).denominator # int attrs
(2, 1)
>>> (255).bit_length(), bin(255) # 3.1+ method
(8, '0b11111111')
Decimal and fraction
Python provides two additional numeric types in standard li‐
brary modules—decimal is a fixed-precision, floating-point
number, and fraction is a rational type that keeps numerator and
denominatorexplicitly.Bothmaybeusedtoaddressinaccuracies
of floating-point arithmetic:
>>> 0.1 - 0.3
-0.19999999999999998

>>> from decimal import Decimal
>>> Decimal('0.1') - Decimal('0.3')
Decimal('-0.2')
>>> from fractions import Fraction
>>> Fraction(1, 10) - Fraction(3, 10)
Fraction(-1, 5)
>>> Fraction(1, 3) + Fraction(7, 6)
Fraction(3, 2)
Fractions automatically simplify results. By fixing precision and
supporting various truncation and rounding protocols, decimals
are useful for monetary applications. See the Python Library Ref‐
erence for details.
Other numeric types
Python also includes a set type (described in “Sets”). Additional
numeric types such as optimized vectors and matrixes are avail‐
able as third-party open source extensions (e.g., see the NumPy
package at http://www.numpy.org). The third-party domain also
includes support for visualization, statistical tools, extended pre‐
cision floating-point math, and more (see the Web).
Strings
The normal str string object is an immutable (unchangeable)
sequence of characters accessed by offset (position). Its charac‐
ters are code point ordinals in the underlying character set, and
individual characters are string objects of length 1.
The full string object model varies across lines.
Python 3.X has three string types with similar interfaces:
str
An immutable sequence of characters, used for all text—
both ASCII and richer Unicode.

bytes
An immutable sequence of short integers, used for the byte
values of binary data.
bytearray
A mutable variant of bytes.
Python 2.X instead has two string types with similar interfaces:
str
An immutable sequence of characters, used for both byte
oriented (8-bit) text and binary data.
unicode
An immutable sequence of characters, used for possibly-
richer Unicode text.
Python 2.X (as of 2.6) also has the Python 3.X bytearray type as
aback-portfrom3.X,butitdoesnotimposeassharpadistinction
between text and binary data. (It may be mixed with text strings
freely in 2.X.)
For Unicode support in both 3.X and 2.X, see “Unicode
Strings”. Most of the remainder of this section pertains to all
string types, but see “String methods”, “Unicode Strings”, and
“Built-in Functions” for more on bytes and bytearray.
Literals and creation
String literals are written as a series of characters in quotes, op‐
tionally preceded with a designator character, and in all string
literal forms an empty string is coded as adjacent quotes. Various
built-in operations also return new strings:
'Python"s', "Python's"
Single and double quotes work the same, and each can em‐
bed unescaped quotes of the other kind.
"""This is a multiline block"""
Triple-quoted blocks collect multiple lines of text into a sin‐
gle string, with end-of-line markers (n) inserted between
the original quoted lines.

'Python'sn'
Backslash escape code sequences (see Table 7) are replaced
with the special-character code point values they represent
(e.g., 'n' is an ASCII character with decimal code-point
value 10).
"This" "is" "concatenated"
Adjacent string constants are concatenated. Hint: this form
may span lines if parenthesized.
r'a rawstring', R'anotherone'
Raw strings: backslashes are retained literally (except at the
endofastring).UsefulforregularexpressionsandWindows
(DOS) directory paths: e.g., r'c:dir1file'.
hex(), oct(), bin()
Create hex/octal/binary digit strings from integer numbers.
See “Numbers” and “Built-in Functions”.
The following literal forms and calls make specialized strings de‐
scribed in “Unicode Strings”:
b'...'
bytes string literal in Python 3.X: sequence of 8-bit byte
values representing raw binary data. For 3.X compatibility,
this form is also available in Python 2.6 and 2.7, where it
simply creates a normal str string. See “String methods”,
“Unicode Strings”, and “Built-in Functions”.
bytearray(...)
bytearray string construction: a mutable variant of bytes.
Available in Python 3.X, and in Python 2.X as of 2.6. See
“String methods”, “Unicode Strings”, and “Built-in Func‐
tions”.
u'...'
Unicode string literal in Python 2.X: a sequence of Unicode
code points. For 2.X compatibility, this form is also available
in Python 3.X as of 3.3, where it simply creates a normal str
string (but normal string literals and str strings support
Unicode text in Python 3.X). See “Unicode Strings”.

str(), bytes(), bytearray() (and unicode() in 2.X only)
Create strings from objects, with possible Unicode encod‐
ing/decoding in Python 3.X. See “Built-in Functions”.
String literals may contain escape sequences taken from Table 7
to represent special characters.
Table 7. String constant escape codes
Escape Meaning Escape Meaning
newline Ignored
continuation
t Horizontal tab
Backslash () v Vertical tab
' Single quote (‘) N{id} Unicode dbase id
" Double quote (“) uhhhh Unicode 16-bit hex
a Bell Uhhhhhhhh Unicode 32-bit hexa
b Backspace xhh Hex (at most 2 digits)
f Formfeed ooo Octal (up to 3 digits)
n Line feed 0 Null (not end of string)
r Carriage return other Not an escape
a Uhhhhhhhh takes exactly eight hexadecimal digits (h); both u and U can
be used only in Unicode string literals.
Operations
All string types support all sequence operations (see Table 3), plus
string-specific methods (described in “String methods”). In ad‐
dition, the str type supports string formatting % expressions and
template substitution (discussed next), and the bytearray type
supportsmutable sequence operations(Table4,plusextralist-like
methods). Also see the re string pattern-matching module in
“The re Pattern-Matching Module”, and string-related, built-in
functions in “Built-in Functions”.

String formatting
In both Python 3.X and 2.X (as of 3.0 and 2.6), normal str strings
support two different flavors of string formatting—operations
that format objects according to format description strings:
• The original expression (all Python versions), coded with
the % operator: fmt % (values)
• The newer method (3.0, 2.6, and later), coded with call
syntax: fmt.format(values)
Both produce new strings based on possibly type-specific sub‐
stitution codes. Their results may be displayed, or assigned to
variables for later use:
>>> '%s, %s, %.2f' % (42, 'spam', 1 / 3.0)
'42, spam, 0.33'
>>> '{0}, {1}, {2:.2f}'.format(42, 'spam', 1 / 3.0)
'42, spam, 0.33'
Although the method call seems to have evolved more rapidly in
recent years, the expression is used extensively in existing code,
and both forms are still fully supported. Moreover, although
some view the method form as marginally more mnemonic and
consistent, the expression is often simpler and more concise. As
these two forms are largely just minor variations on a theme of
equivalent functionality and complexity, there is today no com‐
pelling reason to recommend one over the other.
String formatting expression
String formatting expressions replace % targets in the string on the
left of the % operator, with values on the right (similar to C’s
sprintf). If more than one value is to be replaced, they must be
coded as a tuple to the right of the % operator. If just one item is
to be replaced, it can be coded as a single value or one-item tuple
on the right (nest tuples to format a tuple itself). If key names are
used on the left, a dictionary must be supplied on the right, and
* allows width and precision to be passed in dynamically:

>>> 'The knights who say %s!' % 'Ni'
'The knights who say Ni!'
>>> '%d %s, %d you' % (1, 'spam', 4.0)
'1 spam, 4 you'
>>> '%(n)d named %(x)s' % {'n': 1, 'x': "spam"}
'1 named spam'
>>> '%(n).0E => [%(x)-6s]' % dict(n=100, x='spam')
'1E+02 => [spam ]'
>>> '%f, %.2f, %+.*f' % (1/3.0, 1/3.0, 4, 1/3.0)
'0.333333, 0.33, +0.3333'
Formatting expression syntax
In the format string on the left of the % operator, substitution
targets have the following general format, all but the last com‐
ponentofwhichisoptional(textoutsidesuchsubstitutiontargets
is retained verbatim):
%[(keyname)][flags][width][.prec]typecode
In this substitution target syntax:
keyname
References an item in the expected dictionary, in
parentheses.
flags
Can be − (left-justify), + (numeric sign), a space (use a blank
before positive numbers and a − for negatives ), and 0 (zero
fill).
width
The total minimum field width (use * to fetch from values).
prec
Gives the number of digits (i.e., precision) to include af‐
ter . (use * to fetch from values).
typecode
A character from Table 8.

Both width and prec can be coded as a * to force their values to
be taken from the next item in the values to the right of the %
operator when sizes are not known until runtime. Hint: %s ge‐
nerically converts any object type to its print representation
string.
Table 8. % string formatting type codes
Code Meaning Code Meaning
s String (or any object, uses str()) X x with uppercase
r s, but uses repr(), not str() e Floating-point exponent
c Character (int or str) E e with uppercase
d Decimal (base 10 integer) f Floating-point decimal
i Integer F f with uppercase
u Same as d (obsolete) g Floating-point e or f
o Octal (base 8 integer) G Floating-point E or F
x Hex (base 16 integer) % Literal ‘%’ (coded as %%)
String formatting method
The formatting method call works similar to the prior section’s
expression, but is invoked with normal method-call syntax on
theformatstringobject,whichidentifiessubstitutiontargetswith
{} syntax instead of %.
Substitution targets in the format string may name method-call
arguments by position or keyword name; may further reference
argument attributes, keys, and offsets; may accept default for‐
mattingorprovideexplicittypecodes;andmaynesttargetsyntax
to pull values from the arguments list:
>>> 'The knights who say {0}!'.format('Ni')
'The knights who say Ni!'
>>> '{0} {1}, {2:.0f} you'.format(1, 'spam', 4.0)
'1 spam, 4 you'
>>> '{n} named {x:s}'.format(n=1, x="spam")
'1 named spam'
>>> '{n:.0E} => [{x:<6s}]'.format(
**dict(n=100, x='spam'))

'1E+02 => [spam ]'
>>> '{:f}, {:.2f}, {:+.{}f}'.format(
1/3.0, 1/3.0, 1/3.0, 4)
'0.333333, 0.33, +0.3333'
Most format method applications have equivalents in % expres‐
sion usage patterns as shown in the preceding section (e.g., dic‐
tionary key and * value references), although the method allows
some operations to be coded inside the format string itself:
>>> import sys # Method vs expr: attr, key, index
>>> fmt = '{0.platform} {1[x]} {2[0]}'
>>> fmt.format(sys, dict(x='ham'), 'AB')
'win32 ham A'
>>> fmt = '%s %s %s'
>>> fmt % (sys.platform, dict(x='ham')['x'], 'AB'[0])
'win32 ham A'
As of Python 3.1 and 2.7, a , (comma) preceding an integer or
floating-point designation in typecode, formally described in
“Formatting method syntax”, inserts thousands-separator com‐
mas, and a typecode of % formats a percentage (tools not present
in the formatting expression itself, but straightforward to code
as reusable functions):
>>> '{0:,d}'.format(1000000)
'1,000,000'
>>> '{0:13,.2f}'.format(1000000)
' 1,000,000.00'
>>> '{0:%} {1:,.2%}'.format(1.23, 1234)
'123.000000% 123,400.00%'
Also as of Python 3.1 and 2.7, field numbers are automatically
numbered sequentially if omitted from the fieldname also de‐
scribed in “Formatting method syntax”—the following three
have the same effect, although auto-numbered fields may be less
readable if many fields are present:
>>> '{0}/{1}/{2}'.format('usr', 'home', 'bob')
'usr/home/bob'
>>> '{}/{}/{}'.format('usr', 'home', 'bob') # Auto

'usr/home/bob'
>>> '%s/%s/%s' % ('usr', 'home', 'bob') # Expr
'usr/home/bob'
A single object may also be formatted with the format(object,
formatspec) built-in function (see “Built-in Functions”), which
is employed by the string format method, and whose behavior
may be implemented with the __format__ operator-overloading
method in classes (see “Operator Overloading Methods”).
Formatting method syntax
Substitution targets in strings used for format method calls take
the following general form, all four parts of which are optional,
and must appear without intervening spaces (used here for clari‐
ty):
{fieldname component !conversionflag :formatspec}
In this substitution target syntax:
fieldname
An optional number or keyword identifying an argument,
which may be omitted to use relative argument numbering
in 2.7, 3.1, and later.
component
A string of zero or more .name or [index] references used
to fetch attributes and indexed values of the argument,
which may be omitted to use the whole argument value.
conversionflag
Introduced by a ! if present, which is followed by r, s, or a
to call repr(), str(), or ascii() built-in functions on the
value, respectively.
formatspec
Introducedbya: ifpresent,andconsistsoftextthatspecifies
how the value should be presented, including details such
as field width, alignment, padding, decimal precision, and
so on, and ending with an optional datatype code.

The nested formatspec component after the colon character has
a syntax of its own, formally described as follows (brackets in this
denote optional components and are not coded literally):
[[fill]align][sign][#][0][width][,][.prec][typecode]
In this formatspec nested syntax:
fill
Can be any fill character other than { or }.
align
May be <, >, =, or ^, for left alignment, right alignment,
padding after a sign character, or centered alignment,
respectively.
sign
May be +, −, or space.
, (comma)
Requests a comma for a thousands separator as of Python
3.1 and 2.7.
width and prec
Much as in the % expression, and the formatspec may also
contain nested {} format strings having a fieldname only, to
take values from the arguments list dynamically (much like
the * in formatting expressions). A 0 preceding width ena‐
bles sign-aware zero padding (similar to fill), and a # en‐
ables an alternative conversion (if available).
typecode
Largely the same as in % expressions and listed in Table 8,
but the format method has an extra b type code used to give
integers in binary format (much like using the bin built-in);
has an extra % type code to format percentages as of Python
3.1 and 2.7; and uses only d for base-10 integers (i or u are
not used).
Note that unlike the expression’s generic %s, the method’s s type
code requires a string object argument; omit the type code to
accept any type generically in the method.

Template string substitution
As of Python 2.4, another form of string substitution is provided
as an alternative to the string formatting expression and method
described in the prior sections. In full formatting, substitution is
achieved with the % operator or str.format() method (all four of
the following return '2: PR5E'):
'%(page)i: %(book)s' % {'page': 2, 'book': 'PR5E'}
'%(page)i: %(book)s' % dict(page=2, book='PR5E')
'{page}: {book}'.format(**dict(page=2, book='PR5E'))
'{page}: {book}'.format(page=2, book='PR5E')
For simpler substitution tasks, a Template class in string uses $
to indicate a substitution:
>>> import string
>>> t = string.Template('$page: $book')
>>> t.substitute({'page': 2, 'book': 'PR5E'})
'2: PR5E'
Substitution values can be provided as keyword arguments or
dictionary keys:
>>> s = string.Template('$who likes $what')
>>> s.substitute(who='bob', what=3.14)
'bob likes 3.14'
>>> s.substitute(dict(who='bob', what='pie'))
'bob likes pie'
A safe_substitute method ignores missing keys rather than
raising an exception:
>>> t = string.Template('$page: $book')
>>> t.safe_substitute({'page': 3})
'3: $book'
String methods
In addition to the format() method described earlier, string
method calls provide higher-level text processing tools beyond
string expressions. Table 9 lists available string method calls; in
this table, S is any string object (technically, a 3.X str). String

methods that modify text always return a new string and never
modify the object in-place (strings are immutable).
For more details on methods in the table, see the functional area
description sections ahead, or run a help(str.method) interac‐
tively. Hint: this list can vary across Python releases; to see yours,
try:
sorted(x for x in dir(str) if not x.startswith('__'))
See also the re module in “The re Pattern-Matching Module” for
pattern-based equivalents to some string type methods.
Table 9. Python 3.X string method calls
S.capitalize()
S.casefold() (as of Python 3.3)
S.center(width, [, fill])
S.count(sub [, start [, end]])
S.encode([encoding [, errors]])
S.endswith(suffix [, start [, end]])
S.expandtabs([tabsize])
S.find(sub [, start [, end]])
S.format(*args, **kwargs)
S.format_map(mapping) (as of Python 3.2)
S.index(sub [, start [, end]])
S.isalnum()
S.isalpha()
S.isdecimal()
S.isdigit()
S.isidentifier()
S.islower()
S.isnumeric()
S.isprintable()

Discovering Diverse Content Through
Random Scribd Documents

Je ressentis alors une émotion des plus rares, une émotion cependant que
connaissent trop bien les pauvres animaux sur lesquels s’étend notre
domination. J’eus l’impression qu’aurait un lapin qui, à la place de son
terrier, trouverait tout à coup une douzaine de terrassiers creusant les
fondations d’une maison. Un premier indice qui se précisa bientôt
m’oppressa pendant de nombreux jours, et j’eus la révélation de mon
détrônement, la conviction que je n’étais plus un maître, mais un animal
parmi les animaux sous le talon des Marsiens. Il en serait de nous comme il
en est d’eux; il nous faudrait sans cesse être aux aguets, fuir et nous cacher;
la crainte et le règne de l’homme n’étaient plus.
Mais dès que je l’eus clairement envisagée, cette idée étrange disparut,
chassée par l’impérieuse faim qui me tenaillait après mon long et horrible
jeûne. De l’autre côté de la fosse, derrière un mur recouvert de végétations
rouges, j’aperçus un coin de jardin non envahi encore. Cette vue me
suggéra ce que je devais faire et je m’avançai à travers l’Herbe Rouge,
enfoncé jusqu’au genou et parfois jusqu’au cou. L’épaisseur de ces herbes
m’offrait, en cas de besoin, une cachette sûre. Le mur avait six pieds de
haut, et, lorsque j’essayai de l’escalader, je sentis qu’il m’était impossible
de me soulever. Je dus donc le contourner et j’arrivai ainsi à une sorte
d’encoignure rocailleuse où je pus plus facilement me hisser au faîte du mur
et me laisser dégringoler dans le jardin que je convoitais. J’y trouvai
quelques oignons, des bulbes de glaïeuls et une certaine quantité de carottes
à peine mûres; je récoltai le tout et, franchissant un pan de muraille écroulé,
je continuai mon chemin vers Kew entre des arbres écarlates et cramoisis—
on eût dit une promenade dans une avenue de gigantesques gouttes de sang.
J’avais deux idées bien nettes: trouver une nourriture plus substantielle, et,
autant que mes forces le permettraient, fuir bien loin de cette région
maudite et qui n’avait plus rien de terrestre.
Un peu plus loin, dans un endroit où persistait du gazon, je découvris
quelques champignons que je dévorai aussitôt, mais ces bribes de nourriture
ne réussirent guère qu’à exciter un peu plus ma faim. Tout à coup, alors que
je croyais toujours être dans les prairies, je rencontrai une nappe d’eau peu
profonde et boueuse qu’un faible courant entraînait. Je fus d’abord très
surpris de trouver, au plus fort d’un été très chaud et très sec, des prés
inondés, mais je me rendis compte bientôt que cela était dû à l’exubérance
tropicale de l’Herbe Rouge. Dès que ces extraordinaires végétaux
rencontraient un cours d’eau, ils prenaient immédiatement des proportions

gigantesques et devenaient d’une fécondité incomparable. Les graines
tombaient en quantité dans les eaux de la Wey et de la Tamise, où elles
germaient, et leurs pousses titaniques, croissant avec une incroyable
rapidité, avaient bientôt engorgé le cours de ces rivières qui avaient
débordé.
A Putney, comme je le vis peu après, le pont disparaissait presque
entièrement sous un colossal enchevêtrement de ces plantes, et, à
Richmond, les eaux de la Tamise s’étaient aussi répandues en une nappe
immense et peu profonde à travers les prairies de Hampton et de
Twickenham. A mesure que les eaux débordaient, l’Herbe les suivait, de
sorte que les villas en ruines de la vallée de la Tamise furent un certain
temps submergées dans le rouge marécage dont j’explorais les bords et qui
dissimulait ainsi beaucoup de la désolation qu’avaient causée les Marsiens.
Finalement, l’Herbe Rouge succomba presque aussi rapidement qu’elle
avait crû. Bientôt une sorte de maladie infectieuse, due, croit-on, à l’action
de certaines bactéries, s’empara de ces végétations. Par suite des principes
de la sélection naturelle,
Les maisons avaient toutes été
saccagées, mais aucune n’avait été
brûlée; parfois leurs murs s’élevaient
encore jusqu’au second étage, avec
des fenêtres arrachées et des portes
brisées. L’Herbe Rouge croissait en
tumulte dans leurs chambres sans
toits.
(CHAPITRE XXII)

toutes les plantes terrestres ont maintenant acquis une force de résistance
contre les maladies causées par les microbes;—elles ne succombent jamais
sans une longue lutte. Mais l’Herbe Rouge tomba en putréfaction comme
une chose déjà morte. Les tiges blanchirent, se flétrirent et devinrent très
cassantes. Au moindre contact, elles se rompaient et les eaux, qui avaient
favorisé et stimulé leur développement, emportèrent jusqu’à la mer leurs
derniers vestiges.
Mon premier soin fut naturellement d’étancher ma soif. J’absorbai ainsi
une grande quantité d’eau, et, mû par une impulsion soudaine, je mâchonnai
quelques fragments d’Herbe Rouge. Mais les tiges étaient pleines d’eau

et elles avaient un goût métallique nauséeux. L’eau était assez peu profonde
pour me permettre d’avancer sans danger bien que l’Herbe Rouge retardât
quelque peu ma marche; mais la profondeur du flot s’accrut évidemment à
mesure que j’approchais du fleuve, et, retournant sur mes pas, je repris le
chemin de Mortlake. Je parvins à suivre la route en m’aidant des villas en
ruines, des clôtures et des réverbères que je rencontrais; bientôt je fus hors
de cette inondation et ayant monté la colline de Roehampton, je débouchai
dans les communaux de Putney.
Ici le paysage changeait; ce n’était plus l’étrange et l’extraordinaire,
mais le simple bouleversement du familier. Certains coins semblaient avoir
été dévastés par un cyclone et, une centaine de mètres plus loin, je
traversais un espace absolument paisible et sans la moindre trace de trouble;
je rencontrais des maisons dont les jalousies étaient baissées et les portes
fermées, comme si leurs habitants dormaient à l’intérieur ou étaient absents
pour un jour ou deux. L’Herbe Rouge était moins abondante. Les troncs des
grands arbres qui poussaient au long de la route n’étaient pas envahis par la
variété grimpante. Je cherchai dans les branches quelque fruit à manger,
sans en trouver; j’explorai aussi une ou deux maisons silencieuses, mais
elles avaient déjà été cambriolées et pillées. J’achevai le reste de la journée
en me reposant dans un bouquet d’arbustes, me sentant, dans l’état de
faiblesse où j’étais, trop fatigué pour continuer ma route.

Pendant tout ce temps, je n’avais vu aucun être humain, non plus que le
moindre signe de la présence des Marsiens. Je rencontrai deux chiens
affamés, mais malgré les avances que je leur fis, ils s’enfuirent en faisant un
grand détour. Près de Roehampton, j’avais aperçu deux squelettes humains
—non pas des cadavres, mais des squelettes entièrement décharnés; dans le
petit bois, auprès de l’endroit où j’étais, je trouvai les os brisés et épars de
plusieurs chats et de plusieurs lapins et ceux d’une tête de mouton. Bien
qu’il ne restât rien après, j’essayai d’en ronger quelques-uns.
Après le coucher du soleil, je continuai péniblement à avancer au long de
la route qui mène à Putney, où le Rayon Ardent avait dû, pour une raison
quelconque, faire son œuvre. Au delà de Roehampton, je recueillis, dans un
jardin, des pommes de terre à peine mûres, en quantité suffisante pour
apaiser ma faim. De ce jardin, la vue s’étendait sur Putney et sur le fleuve.
Sous le crépuscule, l’aspect du paysage était singulièrement désolé: des
arbres carbonisés, des ruines lamentables et noircies par les flammes, et, au
bas de la colline, le fleuve débordé et les grandes nappes d’eau teintées de
rouge par l’herbe extraordinaire. Sur tout cela, le silence s’étendait et,
pensant combien rapidement s’était produite cette désolante transformation,
je me sentis envahi par une indescriptible terreur.
Pendant un instant, je crus que l’humanité avait été entièrement détruite
et que j’étais maintenant, debout dans ce jardin, le seul être humain qui ait
survécu. Au sommet de la colline de Putney, je passai non loin d’un autre
squelette dont les bras étaient disloqués et se trouvaient à quelques mètres
du corps. A mesure que j’avançais, j’étais de plus en plus convaincu que,
dans ce coin du monde et à part quelques traînards comme moi,
l’extermination de l’humanité était un fait accompli. Les Marsiens, pensais-
je, avaient continué leur route, abandonnant la contrée désolée et cherchant
ailleurs leur nourriture. Peut-être même étaient-ils maintenant en train de
détruire Berlin ou Paris, ou bien, il pouvait se faire aussi qu’ils aient avancé
vers le Nord...

Je passai la nuit dans l’auberge située au sommet de la côte de Putney,
où, pour la première fois depuis que j’avais quitté Leatherhead, je dormis

dans des draps. Je ne m’attarderai pas à raconter quelle peine j’eus à
pénétrer par une fenêtre dans cette maison, peine inutile puisque je
m’aperçus ensuite que la porte d’entrée n’était fermée qu’au loquet, ni
comment je fouillai dans toutes les chambres, espérant y trouver de la
nourriture, jusqu’à ce que, au moment même où je perdais tout espoir, je
découvris, dans une pièce qui me parut être une chambre de domestiques,
une croûte de pain rongée par les rats et deux boîtes d’ananas conservés. La
maison avait été déjà explorée et vidée. Dans le bar, je finis par mettre la
main sur des biscuits et des sandwiches qui avaient été oubliés. Les
sandwiches n’étaient plus mangeables, mais avec les biscuits j’apaisai ma
faim et je garnis mes poches. Je n’allumai aucune lumière, de peur d’attirer
l’attention de quelque Marsien en quête de nourriture et explorant, pendant
la nuit, cette partie de Londres. Avant de me mettre au lit, j’eus un moment
de grande agitation et d’inquiétude, rôdant de fenêtre en fenêtre et
cherchant à apercevoir dans l’obscurité quelque indice des monstres. Je
dormis peu. Une fois au lit, je pus réfléchir et mettre quelque suite dans mes
idées—chose que je ne me rappelais pas avoir faite depuis ma dernière
discussion avec le vicaire. Depuis lors, mon activité mentale n’avait été
qu’une succession précipitée de vagues états émotionnels ou bien une sorte
de stupide réceptivité. Mais pendant la nuit, mon cerveau, fortifié sans
doute par la nourriture que j’avais prise, redevint clair et je pus réfléchir.
Trois pensées surtout s’imposèrent tour à tour à mon esprit: le meurtre
du vicaire, les faits et gestes des Marsiens et le sort possible de ma femme.
La première de ces préoccupations ne me laissait aucun sentiment d’horreur
ni de remords; je me voyais alors, comme je me vois encore maintenant,
amené fatalement et pas à pas à lui asséner ce coup irréfléchi, victime, en
somme, d’une succession d’incidents et de circonstances qui entraînèrent
inévitablement ce résultat. Je ne me condamnais aucunement et cependant
ce souvenir, sans s’exagérer, me hanta. Dans le silence de la nuit, avec cette
sensation d’une présence divine qui s’empare de nous parfois dans le calme
et les ténèbres, je supportai victorieusement cet examen de conscience, la
seule expiation qu’il me fallût subir pour un moment de rage et
d’affolement. Je me retraçai d’un bout à l’autre la suite de nos relations
depuis l’instant où je l’avais trouvé accroupi auprès de moi, ne faisant
aucune attention à ma soif et m’indiquant du doigt les flammes et la fumée
qui s’élevaient des ruines de Weybridge. Nous avions été incapables de
nous entendre et de nous aider mutuellement—le hasard sinistre ne se

soucie guère de cela. Si j’avais pu le prévoir, je l’aurais abandonné à
Halliford. Mais je n’avais rien deviné—et le crime consiste à prévoir et à
agir. Je raconte ces choses, comme tout le reste de cette histoire, telles
qu’elles se passèrent. Elles n’eurent pas de témoin j’aurais pu les garder
secrètes, mais je les ai narrées afin que le lecteur pût se former un jugement
à son gré.
Puis lorsque j’eus à grand’peine chassé l’image de ce cadavre gisant la
face contre terre, j’en vins au problème des Marsiens et du sort de ma
femme. En ce qui concernait les Marsiens, je n’avais aucune donnée et ne
pouvais que m’imaginer mille choses; je ne pouvais guère mieux faire non
plus quant à ma femme. Cette veillée bientôt devint épouvantable; je me
dressai sur mon lit, mes yeux scrutant les ténèbres et je me mis à prier,
demandant que, si elle avait dû mourir, le Rayon Ardent ait pu la frapper
brusquement et la tuer sans souffrance. Depuis la nuit de mon retour de
Leatherhead je n’avais pas prié. En certaines extrémités désespérées, j’avais
murmuré des supplications, des invocations fétichistes, formulant
...les eaux de la Tamise s’étaient
aussi répandues en une nappe
immense et peu profonde.
(CHAPITRE XXIII)

mes prières comme les païens murmurent des charmes conjurateurs. Mais
cette fois je priais réellement, implorant avec ferveur la Divinité, face à face
avec les ténèbres. Nuit étrange, et plus étrange encore en ceci, que aussitôt
que parut l’aurore, moi, qui m’étais entretenu avec la Divinité, je me glissai
hors de la maison comme un rat quitte son trou—créature à peine plus
grande, animal inférieur qui, selon le caprice passager de nos maîtres,
pouvais être traqué et tué. Les Marsiens, eux aussi, invoquaient peut-être
Dieu avec confiance. A coup sûr, si nous ne retenons rien autre de cette
guerre, elle nous aura cependant appris la pitié—la pitié pour ces âmes
dépourvues de raison qui subissent notre domination.
L’aube était resplendissante et claire; à l’orient, le ciel, que sillonnaient
de petits nuages dorés, s’animait de reflets roses. Sur la route qui va du haut

de la colline de Putney jusqu’à Wimbledon, traînaient un certain nombre de
vestiges pitoyables, restes de la déroute qui, dans la soirée du dimanche où
commença la dévastation, dut pousser vers Londres tous les habitants de la
contrée. Il y avait là une petite voiture à deux roues sur laquelle était peint
le nom de Thomas Lobbe, fruitier à New Malden; une des roues était brisée
et une caisse de métal gisait auprès, abandonnée; il y avait aussi un chapeau
de paille piétiné dans la boue, maintenant séchée, et au sommet de la côte
de West Hill je trouvai un tas de verre écrasé et taché de sang, auprès de
l’abreuvoir en pierre qu’on avait renversé et brisé. Mes plans étaient de plus
en plus vagues et mes mouvements de plus en plus incertains; j’avais
toujours l’idée d’aller à Leatherhead, et pourtant j’étais convaincu que,
selon toutes probabilités, ma femme ne pouvait s’y trouver. Car, à moins
que la mort ne les ait surpris à l’improviste, mes cousins et elle avaient dû
fuir dès les premières menaces de danger. Mais je m’imaginais que je
pourrais, tout au moins, apprendre là de quel côté s’étaient enfuis les
habitants du Surrey. Je savais que je voulais retrouver ma femme, que mon
cœur souffrait de son absence et du manque de toute société, mais je n’avais
aucune idée bien claire quant aux moyens de la retrouver, et je sentais avec
une intensité croissante mon entier isolement. Je parvins alors, après avoir
traversé un taillis d’arbres et de buissons, à la lisière des communaux de
Wimbledon, dont les haies, les arbres et les prés s’étendaient au loin sous
mes yeux.
Cet espace encore sombre s’éclairait, par endroits, d’ajoncs et de genêts
jaunes. Je ne vis nulle part d’Herbe Rouge, et tandis que je rôdais entre les
arbustes, hésitant à m’aventurer à découvert, le soleil se leva, inondant tout
de lumière et de vie. Dans un pli de terrain marécageux, entre les arbres, je
tombai au milieu d’une multitude de petites grenouilles. Je m’arrêtai à les
observer, tirant de leur obstination à vivre une leçon pour moi-même.
Soudain, j’eus la sensation bizarre que quelqu’un m’épiait et, me retournant
brusquement, j’aperçus dans un fourré quelque chose qui s’y blottissait.
Pour mieux voir, je fis un pas en avant. La chose se dressa: c’était un
homme armé d’un coutelas. Je m’approchai lentement de lui et il me
regarda venir, silencieux et immobile.
Quand je fus près de lui, je remarquai que ses vêtements étaient aussi
déguenillés et aussi sales que les miens. On eût dit, vraiment, qu’il avait été
traîné dans des égouts. De plus près, je distinguai la vase verdâtre des
fossés, des plaques pâles de terre glaise séchée et des reflets de poussière de

charbon. Ses cheveux, très bruns et longs, retombaient en avant sur ses
yeux; sa figure était noire et sale, et il avait les traits tirés, de sorte qu’au
premier abord je ne le reconnus pas. De plus, une balafre récente lui coupait
le bas du visage.
—Halte! cria-t-il, quand je fus à dix mètres de lui.
Je m’arrêtai. Sa voix était rauque.
—D’où venez-vous? demanda-t-il.
Je réfléchis un instant, l’examinant avec attention.
—Je viens de Mortlake, répondis-je. Je me suis trouvé enterré auprès de
la fosse que les Marsiens ont creusée autour de leur cylindre, et j’ai fini par
m’échapper.
—Il n’y a rien à manger par ici, dit-il. Ce coin m’appartient, toute la
colline jusqu’à la rivière, et là-bas jusqu’à Clapham, et ici jusqu’à l’entrée
des communaux. Il n’y a de nourriture que pour un seul. De quel côté allez-
vous?
Je répondis lentement.
—Je ne sais pas... Je suis resté sous les ruines d’une maison pendant
treize ou quatorze jours, et je ne sais rien de ce qui est arrivé pendant ce
temps-là.
Il m’écoutait avec un air de doute; tout à coup, il eut un sursaut et son
expression changea.
—Je n’ai pas envie de m’attarder ici, dis-je. Je pense aller à Leatherhead
pour tâcher d’y retrouver ma femme.
—C’est bien vous, dit-il alors en étendant le bras vers moi. C’est vous
qui habitiez à Woking. Vous n’avez pas été tué à Weybridge?
—Je le reconnus au même moment.
—Vous êtes l’artilleur qui se cachait dans mon jardin...
—En voilà une chance! dit-il. C’est tout de même drôle que ce soit vous.
Il me tendit sa main et je la pris.
—Moi, continua-t-il, je m’étais glissé dans un fossé d’écoulement. Mais
ils ne tuaient pas tout le monde. Quand ils furent partis, je m’en allai à
travers champs jusqu’à Walton. Mais... il y a quinze jours à peine... et vous
avez les cheveux tout gris.
Il jeta soudain un brusque regard en arrière.

—Ce n’est qu’une corneille, dit-il. Par le temps qui court, on apprend à
connaître que les oiseaux ont une ombre. Nous sommes un peu à découvert.
Installons-nous sous ces arbustes et causons.
—Avez-vous vu les Marsiens? demandai-je. Depuis que j’ai quitté mon
trou, je...
—Ils sont partis à l’autre bout de Londres, dit-il. Je pense qu’ils ont
établi leur quartier général par là. La nuit, du côté d’Hampstead, tout le ciel
est plein des reflets de leurs lumières. On dirait la lueur d’une grande cité,
et on les voit aller et venir dans cette clarté. De jour, on ne peut pas. Mais je
ne les ai pas vus de plus près depuis...—Il compta sur ses doigts—... cinq
jours. Oui. J’en ai vu deux qui traversaient Hammersmith en portant
quelque chose d’énorme. Et l’avant-dernière nuit, ajouta-t-il d’un ton
étrangement sérieux, dans le pêle-mêle des reflets, j’ai vu quelque chose qui
montait très haut dans l’air. Je crois qu’ils ont construit une machine volante
et qu’ils sont en train d’apprendre à voler.
Je m’arrêtai, surpris, sans achever de m’asseoir sous les buissons.
—A voler!
—Oui, dit-il, à voler!
Je trouvai une position confortable et je m’installai.
—C’en est fait de l’humanité, dis-je. S’ils réussissent à voler, ils feront
tout simplement le tour du monde, en tous sens...
—Mais oui, approuva-t-il en hochant la tête. Mais... ça nous soulagera
d’autant par ici, et d’ailleurs, fit-il en se tournant vers moi, quel mal voyez-
vous à ce que ça en soit fini de l’humanité? Moi, j’en suis bien content.
Nous sommes écrasés, nous sommes battus.
Je le regardai, ahuri. Si étrange que cela fût, je ne m’étais pas encore
rendu compte de toute l’étendue de la catastrophe—et cela m’apparut
comme parfaitement évident dès qu’il eut parlé. J’avais conservé jusque-là
un vague espoir, ou, plutôt, c’était une vieille habitude d’esprit qui
persistait. Il répéta ces mots qui exprimaient une conviction absolue:
—Nous sommes battus.
—C’est bien fini, continua-t-il. Ils n’en ont perdu qu’ «un» rien qu’
«un». Ils se sont installés dans de bonnes conditions, et ils ne s’inquiètent
nullement des armes les plus puissantes du monde. Ils nous ont piétinés. La
mort de celui qu’ils ont perdu à Weybridge n’a été qu’un accident, et il n’y

a que l’avant-garde d’arrivée. Ils continuent à venir; ces étoiles vertes—je
n’en ai pas vu depuis cinq ou six jours—je suis sûr qu’il en tombe une
quelque part toutes les nuits. Il n’y a rien à faire. Nous avons le dessous,
nous sommes battus.
Je ne lui répondis rien. Je restais assis le regard fixe et vague, cherchant
en vain à lui opposer quelque argument fallacieux et contradictoire.
—Ça n’est pas une guerre, dit l’artilleur. Ça n’a jamais été une guerre,
pas plus qu’il n’y a de guerre entre les hommes et les fourmis.
Tout à coup, me revinrent à l’esprit les détails de la nuit que j’avais
passée dans l’observatoire.
—Après le dixième coup, ils n’ont plus tiré—du moins jusqu’à l’arrivée
du premier cylindre.
Je lui donnai des explications et il se mit à réfléchir.
—Quelque chose de dérangé dans leur canon, dit-il. Mais qu’est-ce que
ça peut faire? Ils sauront bien le réparer, et quand bien même il y aurait un
retard quelconque, est-ce que ça pourrait changer la fin? C’est comme les
hommes avec les fourmis. A un endroit, les fourmis installent leurs cités et
leurs galeries; elles y vivent, elles font des guerres et des révolutions,
jusqu’au moment où les hommes les trouvent sur leur chemin, et ils en
débarrassent le passage. C’est ce qui se produit maintenant—nous ne
sommes que des fourmis. Seulement...
—Eh bien?
—Eh bien! nous sommes des fourmis comestibles.
Nous restâmes un instant là, assis, sans rien nous dire.
—Et que vont-ils faire de nous? questionnai-je.
—C’est ce que je me demande, dit-il; c’est bien ce que je me demande.
Après l’affaire de Weybridge, je m’en allai vers le sud, tout perplexe. Je vis
ce qui se passait. Tout le monde s’agitait et braillait ferme. Moi, je n’ai
guère de goût pour le remue-ménage. J’ai vu la mort de près une fois ou
deux; ma foi, je ne suis pas un soldat de parade, et, au pire et au mieux—la
mort, c’est la mort. Il n’y a que celui qui garde son sang-froid qui s’en tire.
Je vis que tout le monde s’en allait vers le sud, et je me dis: De ce côté-là,
on ne mangera plus avant qu’il soit longtemps, et je fis carrément volte-
face. Je suivis les Marsiens comme le moineau suit l’homme. Par là-bas,

dit-il en agitant sa main vers l’horizon, ils crèvent de faim par tas en se
battant et en se trépignant...
Il vit l’expression d’angoisse de ma figure, et il s’arrêta, embarrassé.
—Sans doute, poursuivit-il, ceux qui avaient de l’argent ont pu passer en
France. Il parut hésiter et vouloir s’excuser, mais rencontrant mes yeux, il
continua:
—Ici, il y a des provisions partout. Des tas de choses dans les boutiques,
des vins, des alcools, des eaux minérales. Les tuyaux et les conduites d’eau
sont vides. Mais je vous racontais mes réflexions: nous avons affaire à des
êtres intelligents, me dis-je, et ils semblent compter sur nous pour se
nourrir. D’abord, ils vont fracasser tout—les navires, les machines, les
canons, les villes, tout ce qui est régulier et organisé. Tout cela aura une fin.
Si nous avions la taille des fourmis, nous pourrions nous tirer d’affaire; ça
n’est pas le cas et on ne peut arrêter des masses pareilles. C’est là un fait
bien certain, n’est-ce pas?
Je donnai mon assentiment.
—Bien! c’est une affaire entendue—passons à autre chose, alors.
Maintenant, ils nous attrapent comme ils veulent. Un Marsien n’a que
quelques milles à faire pour trouver une multitude en fuite. Un jour, j’en ai
vu un près de Wandsworth qui saccageait les maisons et massacrait le
monde. Mais ils ne continueront pas de cette façon-là. Aussitôt qu’ils auront
fait taire nos canons, détruit nos chemins de fer et nos navires, terminé tout
ce qu’ils sont en train de manigancer par là-bas, ils se mettront à nous
attraper systématiquement, choisissant les meilleurs et les mettant en
réserve dans des cages et des enclos aménagés dans ce but. C’est là ce
qu’ils vont entreprendre avant longtemps. Car, comprenez-vous? ils n’ont
encore rien commencé, en somme.
Il nous faudra mener une vie
souterraine, comprenez-vous? J’ai
pensé aux égouts. Naturellement ceux
qui ne les connaissent pas se figurent
des endroits horribles; mais sous le
sol de Londres, il y en a pendant des
milles et des milles de longueur, des
centaines de milles; quelques jours de

pluie sur Londres abandonné en
feront des logis agréables et propres.
(CHAPITRE XXIV)
—Rien commencé? m’écriai-je.
—Non, rien! Tout ce qui est arrivé jusqu’ici, c’est parce que nous
n’avons pas eu l’esprit de nous tenir tranquilles, au lieu de les tracasser avec
nos canons et autres sottises; c’est parce qu’on a perdu la tête et qu’on a fui
en masse, alors qu’il n’était pas plus dangereux de rester où l’on était. Ils ne
veulent pas encore s’occuper de nous. Ils fabriquent leurs choses, toutes les
choses qu’ils n’ont pu apporter avec eux, et ils préparent tout pour ceux qui
vont bientôt venir. C’est probablement à cause de cela qu’il ne tombe plus

de cylindres pour le moment, et de peur d’atteindre ceux qui sont déjà ici.
Au lieu de courir partout à l’aveuglette, en hurlant, et d’essayer vainement
de les faire sauter à la dynamite, nous devons tâcher de nous accommoder
du nouvel état de choses. C’est là l’idée que j’en ai. Ça n’est pas
absolument conforme à ce que l’homme peut ambitionner pour son espèce,
mais ça peut s’accorder avec les faits, et c’est le principe d’après lequel
j’agis. Les villes, les nations, la civilisation, le progrès—tout ça, c’est fini.
La farce est jouée. Nous sommes battus.
—Mais s’il en est ainsi, à quoi sert-il de vivre?
L’artilleur me considéra un moment.
—C’est évident, dit-il. Pendant un million d’années ou deux, il n’y aura
plus ni concerts, ni salons de peinture, ni parties fines au restaurant. Si c’est
de l’amusement qu’il vous faut, je crains bien que vous n’en manquiez. Si
vous avez des manières distinguées, s’il vous répugne de manger des petits
pois avec un couteau ou de ne pas prononcer correctement les mots, vous
ferez aussi bien de laisser tout cela de côté, ça ne vous sera plus guère utile.
—Alors vous voulez dire que...
—Je veux dire que les hommes comme moi réussiront à vivre, pour la
conservation de l’espèce. Je vous assure que je suis absolument décidé à
vivre, et si je ne me trompe, vous serez bien forcé, vous aussi, de montrer ce
que vous avez dans le ventre, avant qu’il soit longtemps. Nous ne serons
pas tous exterminés, et je n’ai pas l’intention, non plus, de me laisser
prendre pour être apprivoisé, nourri et engraissé comme un bœuf gras.
Hein! voyez-vous la joie d’être mangé par ces sales reptiles.
—Mais vous ne prétendez pas que...
—Mais si, mais si! Je continue: mes plans sont faits, j’ai résolu la
difficulté. L’humanité est battue. Nous ne savions rien, et nous avons tout à
apprendre maintenant. Pendant ce temps, il faut vivre et rester
indépendants, vous comprenez? Voilà ce qu’il y aura à faire.
Je le regardais, étonné et profondément remué par ses paroles
énergiques.
—Sapristi! vous êtes un homme, vous! m’écriai-je, en lui serrant
vigoureusement la main.
—Eh bien! dit-il, les yeux brillants de fierté, est-ce pensé, cela, hein?
—Continuez, lui dis-je.

—Donc, ceux qui ont envie d’échapper à un tel sort doivent se préparer.
Moi, je me prépare. Comprenez bien ceci: nous ne sommes pas tous faits
pour être des bêtes sauvages, et c’est ce qui va arriver. C’est pour cela que
je vous ai guetté. J’avais des doutes: vous êtes maigre et élancé. Je ne savais
pas que c’était vous et j’ignorais que vous aviez été enterré. Tous les gens
qui habitaient ces maisons et tous ces maudits petits employés qui vivaient
dans ces banlieues—tous ceux-là ne sont bons à rien. Ils n’ont ni vigueur, ni
courage,—ni belles idées, ni grands désirs; et Seigneur! un homme qui n’a
pas tout cela peut-il faire autre chose que trembler et se cacher? Tous les
matins, ils se trimballaient vers leur ouvrage,—je les ai vus, par centaines,
—emportant leur déjeuner, s’essoufflant à courir, pour prendre les trains
d’abonnés, avec la peur d’être renvoyés s’ils arrivaient en retard; ils
peinaient sur des ouvrages qu’ils ne prenaient pas même la peine de
comprendre; le soir, du même train-train, ils retournaient chez eux avec la
crainte d’être en retard pour dîner; n’osant pas sortir, après leur repas, par
peur des rues désertes; dormant avec des femmes qu’ils épousaient, non pas
parce qu’ils avaient besoin d’elles, mais parce qu’elles avaient un peu
d’argent qui leur garantissait une misérable petite existence à travers le
monde; ils assuraient leurs vies, et mettaient quelques sous de côté par peur
de la maladie ou des accidents; et le dimanche—c’était la peur de l’au-delà,
comme si l’enfer était pour les lapins! Pour ces gens-là, les Marsiens seront
une bénédiction: de jolies cages spacieuses, de la nourriture à discrétion; un
élevage soigné et pas de soucis. Après une semaine ou deux de
vagabondage à travers champs, le ventre vide, ils reviendront et se
laisseront prendre volontiers. Au bout de peu de temps, ils seront
entièrement satisfaits. Ils se demanderont ce que les gens pouvaient bien
faire avant qu’il y ait eu des Marsiens pour prendre soin d’eux. Et les
traîneurs de bars, les tripoteurs, les chanteurs—je les vois d’ici, ah! oui, je
les vois d’ici! s’exclama-t-il avec une sorte de sombre contentement. C’est
là qu’il y aura du sentiment et de la religion; mais il y a mille choses que
j’avais toujours vues de mes yeux et que je ne commence à comprendre
clairement que depuis ces derniers jours. Il y a des tas de gens, gras et
stupides, qui prendront les choses comme elles sont, et des tas d’autres
aussi se tourmenteront à l’idée que le monde ne va plus et qu’il faudrait y
faire quelque chose. Or, chaque fois que les choses sont telles qu’un tas de
gens éprouvent le besoin de s’en mêler, les faibles, et ceux qui le deviennent
à force de trop réfléchir, aboutissent toujours à une religion du Rien-Faire,

très pieuse et très élevée, et finissent par se soumettre à la persécution et à
la volonté du Seigneur. Vous avez déjà dû remarquer cela aussi. C’est de
l’énergie à l’envers dans une rafale de terreur. Les cages de ceux-là seront
pleines de psaumes, de cantiques et de piété, et ceux qui sont d’une espèce
moins simple se tourneront sans doute vers—comment appelez-vous cela?
—l’érotisme.
Il s’arrêta un moment, puis il reprit.
—Très probablement, les Marsiens auront des favoris parmi tous ces
gens; ils leur enseigneront à faire des tours et, qui sait? feront du sentiment
sur le sort d’un pauvre enfant gâté qu’il faudra tuer. Ils en dresseront, peut-
être aussi, à nous chasser.
—Non, m’écriai-je, c’est impossible. Aucun être humain...
—A quoi bon répéter toujours de pareilles balivernes? dit l’artilleur. Il y
en a beaucoup qui le feraient volontiers. Quelle blague de prétendre le
contraire!
Et je cédai à sa conviction.
—S’ils s’en prennent à moi, dit-il, bon Dieu! s’ils s’en prennent à moi!...
et il s’enfonça dans une sombre méditation.
Je réfléchissais aussi à toutes ces choses, sans rien trouver pour réfuter
les raisonnements de cet homme. Avant l’invasion, personne n’eût mis en
doute ma supériorité intellectuelle, et cependant cet homme venait de
résumer une situation que je commençais à peine à comprendre.
—Qu’allez-vous faire? lui demandai-je brusquement. Quels sont vos
plans?
Il hésita.
—Eh bien! voici! dit-il. Qu’avons-nous à faire? Il nous faut trouver un
genre de vie qui permette à l’homme d’exister et de se reproduire, et d’être
suffisamment en sécurité pour élever sa progéniture. Oui—attendez, et je
vais vous dire clairement ce qu’il faut faire à mon avis. Ceux que les
Marsiens domestiqueront deviendront bientôt comme tous les animaux
domestiques. D’ici à quelques générations, ils seront beaux et gros, ils
auront le sang riche et le cerveau stupide—bref, rien de bon. Le danger que
courent ceux qui resteront en liberté est de redevenir sauvages, de dégénérer
en une sorte de gros rat sauvage... Il nous faudra mener une vie souterraine,
comprenez-vous? J’ai pensé aux égouts. Naturellement ceux qui ne les

connaissent pas se figurent des endroits horribles; mais sous le sol de
Londres, il y en a pendant des milles et des milles de longueur, des
centaines de milles; quelques jours de pluie sur Londres abandonné en
feront des logis agréables et propres. Les canaux principaux sont assez
grands et assez aérés pour les plus difficiles. Puis, il y a les caves, les voûtes
et les magasins souterrains qu’on pourrait joindre aux égouts par des
passages faciles à intercepter; il y a aussi les tunnels et les voies
souterraines de chemin de fer. Hein? Vous commencez à y voir clair? Et
nous formons une troupe d’hommes vigoureux et intelligents, sans nous
embarrasser de tous les incapables qui nous viendront. Au large, les faibles!
—C’est pour cela que vous me chassiez tout à l’heure.
—Mais... non... c’était pour entamer la conversation.
—Ce n’est pas la peine de nous quereller là-dessus. Continuez.
—Ceux qu’on admettra devront obéir. Il nous faut aussi des femmes
vigoureuses et intelligentes,—des mères et des éducatrices. Pas de belles
dames minaudières et sentimentales—pas d’yeux langoureux. Il ne nous
faut ni incapables, ni imbéciles. La vie est redevenue réelle, et les inutiles,
les encombrants, les malfaisants succomberont. Ils devraient mourir, oui, ils
devraient mourir de bonne volonté. Après tout, il y a une sorte de déloyauté
à s’obstiner à vivre pour gâter la race, d’autant plus qu’ils ne pourraient pas
être heureux. D’ailleurs, mourir n’est pas si terrible, c’est la peur qui rend la
chose redoutable. Et puis nous nous rassemblerons dans tous ces endroits.
Londres sera notre district. Même, on pourrait organiser une surveillance
afin de pouvoir s’ébattre en plein air, quand les Marsiens n’y seraient pas—
jouer au cricket, par exemple. C’est comme cela qu’on sauvera la race.

N’est-ce pas? Tout cela est possible? Mais sauver la race n’est rien;
comme je l’ai dit, ça consiste à devenir des rats. Le principal, c’est de
conserver notre savoir et de l’augmenter encore. Alors, c’est là que des gens
comme vous deviennent utiles. Il y a des livres, il y a des modèles. On
aménagerait des locaux spéciaux, en lieu sûr, très profonds, et on y réunirait
tous les livres qu’on trouverait; pas de sottises, ni romans, ni poésie, rien
que des livres d’idées et de science. On pourrait s’introduire dans le British
Muséum et y prendre tous les livres de ce genre. Ils nous faudrait
spécialement maintenir nos connaissances scientifiques—les étendre
encore. On observerait ces Marsiens. Quelques-uns d’entre nous pourraient
aller les espionner, quand ils auraient tout organisé; j’irai peut-être moi-
même. Il
... où se pressa bientôt une multitude
d’ivrognes en haillons, hommes et
femmes, qui dansèrent et hurlèrent
jusqu’à l’aurore. Quand le jour parut,
ils aperçurent une machine de combat
marsienne qui, toute droite dans
l’ombre, les observait avec curiosité.

(CHAPITRE XXIV)
faudrait se laisser attraper, pour mieux les approcher je veux dire. Mais le
grand point, c’est de laisser les Marsiens tranquilles; ne jamais rien leur
voler même. Si on se trouve sur leur passage, on leur fait place. Il faut
montrer que nous n’avons pas de mauvaises intentions. Oui, je sais bien;
mais ce sont des êtres intelligents, et s’ils ont tout ce qu’il leur faut, ils ne
nous réduiront pas aux abois et se contenteront de nous considérer comme
une vermine inoffensive.
L’artilleur s’arrêta et posa sa main bronzée sur mon bras.
—Après tout, continua-t-il, il ne nous reste peut-être pas tellement à
apprendre avant de... Imaginez-vous ceci: quatre ou cinq de leurs machines

de combat qui se mettent en mouvement tout à coup—les Rayons Ardents
dardés en tous sens—et sans que les Marsiens soient dedans. Pas de
Marsiens dedans, mais des hommes—des hommes qui auraient appris à les
conduire. Ça pourrait être de mon temps, même—ces hommes! Figurez-
vous pouvoir manœuvrer l’un de ces charmants objets avec son Rayon
Ardent, libre et bien manié, et se promener avec! Qu’importerait de se
briser en mille morceaux, au bout du compte, après un exploit comme celui-
là? Je réponds bien que les Marsiens en ouvriraient de grands yeux. Les
voyez-vous, hein? Les voyez-vous courir, se précipiter, haleter, s’essouffler
et hurler, en s’installant dans leurs autres mécaniques? On aurait tout
désengrené à l’avance et pif, paf, pan, uitt, uitt, au moment où ils veulent
s’installer dedans, le Rayon Ardent passe et l’homme a repris sa place.
L’imagination hardie de l’artilleur et le ton d’assurance et de courage
avec lequel il s’exprimait dominèrent complètement mon esprit pendant un
certain temps. J’admettais sans hésitation, à la fois ses prévisions quant à la
destinée de la race humaine et la possibilité de réaliser ses plans
surprenants. Le lecteur qui suit l’exposé de ces faits, l’esprit tranquille et
attentif, voudra bien, avant de m’accuser de sottise et de naïveté, considérer
que j’étais craintivement blotti dans les buissons, l’esprit plein d’anxiété et
d’appréhension. Nous conversâmes de cette façon pendant une bonne partie
de la matinée, puis, après nous être glissés hors de notre cachette et avoir
scruté l’horizon pour voir si les Marsiens ne revenaient pas dans les
environs, nous nous rendîmes, en toute hâte, à la maison de Putney Hill
dont il avait fait sa retraite. Il s’était installé dans une des caves à charbon et
quand je vis l’ouvrage qu’il avait fait en une semaine—un trou à peine long
de dix mètres par lequel il voulait aller rejoindre une importante galerie
d’égout—j’eus mon premier indice du gouffre qu’il y avait entre ses rêves
et son courage. J’aurais pu en faire autant en une journée, mais j’avais en
lui une foi suffisante pour l’aider, toute la matinée et assez tard dans
l’après-midi, à creuser son passage souterrain. Nous avions une brouette et
nous entassions la terre contre le fourneau de la cuisine. Nous réparâmes
nos forces en absorbant le contenu d’une boîte de tête de veau à la tortue et
une bouteille de vin. Après la démoralisante étrangeté des événements,
j’éprouvais à travailler ainsi un grand soulagement. J’examinais son projet
et bientôt des objections et des doutes m’assaillirent, mais je n’en
continuais pas moins mon labeur, heureux d’avoir un but vers lequel
exercer mon activité. Peu à peu, je commençai à spéculer sur la distance qui

nous séparait encore de l’égout et sur les chances que nous avions de ne pas
l’atteindre. Ma perplexité actuelle était de savoir pourquoi nous creusions
ce long tunnel, alors qu’on pouvait s’introduire facilement dans les égouts
par un regard quelconque, et de là, creuser une galerie pour revenir jusqu’à
cette maison. Il me semblait aussi que cette retraite était assez mal choisie
et qu’il faudrait, pour y revenir, une inutile longueur de tunnel. Au moment
même où tout cela m’apparaissait clairement, l’artilleur s’appuya sur sa
bêche et me dit:
—Nous faisons là du bon ouvrage. Si nous nous reposions un moment?
D’ailleurs, je crois qu’il serait temps d’aller faire une reconnaissance sur le
toit de la maison.
J’étais d’avis de continuer notre travail et, après quelque hésitation, il
reprit son outil. Alors, une idée soudaine me frappa. Je m’arrêtai, et il
s’arrêta aussi immédiatement.
—Pourquoi vous promeniez-vous dans les communaux, ce matin, au lieu
d’être ici? demandai-je.
—Je prenais l’air, répondit-il, et je rentrais. On est plus en sécurité, la
nuit.
—Mais, votre ouvrage?...
—Oh! on ne peut pas toujours travailler, dit-il.
A cette réponse j’avais jugé mon homme. Il hésita, toujours appuyé sur
sa bêche.
—Nous devrions maintenant aller faire une reconnaissance, dit-il, parce
que si quelqu’un s’approchait, on entendrait le bruit de nos bêches et on
nous surprendrait.
Je n’avais plus envie de discuter. Nous montâmes ensemble et, de
l’échelle qui donnait accès sur le toit, nous explorâmes les environs. Nulle
part on n’apercevait de Marsiens, et nous nous aventurâmes sur les tuiles,
nous laissant glisser jusqu’au parapet qui nous abritait.
De là, un bouquet d’arbres nous cachait la plus grande partie de Putney,
mais nous pouvions voir, plus bas, le fleuve, le bouillonnement confus de
l’Herbe Rouge et les parties basses de Lambeth inondées. La variété
grimpante de l’Herbe Rouge avait envahi les arbres qui entourent le vieux
palais, et leurs branches s’étendaient mortes et décharnées, garnies parfois
encore de feuilles sèches, parmi tout cet enchevêtrement. Il était étrange de

constater combien ces deux espèces de végétaux avaient besoin d’eau
courante pour se propager. Autour de nous, on n’en voyait pas trace. Des
cytises, des épines roses, des boules de neige montaient verts et brillants au
milieu de massifs de lauriers et d’hortensias ensoleillés. Au delà de
Kensington, une fumée épaisse s’élevait, qui, avec une brune bleuâtre,
empêchait d’apercevoir les collines septentrionales.
L’artilleur se mit à parler de l’espèce de monde qui était restée dans
Londres.
—Une nuit de la semaine dernière, dit-il, quelques imbéciles réussirent à
rétablir la lumière électrique dans Regent Street et Piccadilly, où se pressa
bientôt une multitude d’ivrognes en haillons, hommes et femmes, qui
dansèrent et hurlèrent jusqu’à l’aurore. Quelqu’un qui s’y trouvait m’a
conté la chose. Quand le jour parut, ils aperçurent une machine de combat
marsienne qui, toute droite dans l’ombre, les observait avec curiosité. Sans
doute elle était là depuis fort longtemps. Elle s’avança alors au milieu d’eux
et en captura une centaine trop ivres ou trop effrayés pour s’enfuir.
Incidents burlesques et tragiques d’une époque troublée qu’aucun
historien ne pourra relater fidèlement!
Par une suite de questions, je le ramenai à ses plans grandioses. Son
enthousiasme le reprit. Il exposa, avec tant d’éloquence, la possibilité de

capturer une machine de combat que cette fois encore je le crus à moitié.
Mais je commençais à connaître la qualité de son courage, et je comprenais
maintenant pourquoi il attachait tant d’importance à ne rien faire
précipitamment. D’ailleurs, il n’était plus du tout question qu’il dût
s’emparer personnellement de la grande machine et s’en servir lui-même
pour combattre les Marsiens.
Bientôt, nous redescendîmes dans la cave. Nous ne paraissions disposés
ni l’un ni l’autre à reprendre notre travail et, quand il proposa de faire la
collation, j’acceptai sans hésiter. Il devint soudain très généreux; puis, le
repas terminé, il sortit et revint quelques moments après avec d’excellents
cigares. Nous en allumâmes chacun un et son optimisme devint éblouissant.
Il inclinait à considérer ma venue comme une merveilleuse bonne fortune.
—Il y a du champagne dans la
cave voisine, dit-il.
—Nous travaillerons mieux
avec ce bourgogne, répondis-je.
—Non, non, vous êtes mon
hôte, aujourd’hui. Bon Dieu! nous
avons assez de besogne devant
nous. Prenons un peu de repos,
pour rassembler nos forces,
pendant que c’est possible.
Regardez-moi toutes ces ampoules!
Poursuivant son idée de
s’accorder un peu de répit, il insista
pour que nous fissions une partie de cartes. Il m’enseigna divers jeux et,
après nous être partagé Londres, lui s’attribuant la rive droite, et moi
gardant la rive gauche, nous prîmes chaque paroisse comme enjeu. Si
bêtement ridicule que cela paraisse au lecteur de sens rassis, le fait est
absolument exact, et, chose plus surprenante encore, c’est que je trouvai ce
jeu, et plusieurs autres que nous jouâmes aussi, extrêmement intéressants.
Quel étrange esprit que celui de l’homme! L’espèce entière était
menacée d’extermination ou d’une épouvantable dégradation, nous
n’avions devant nous d’autre claire perspective que celle d’une mort
horrible, et nous pouvions, tranquillement assis à fumer et à boire, nous
intéresser aux chances que représentaient ces bouts de carton peint, et

plaisanter avec un réel plaisir. Ensuite il m’enseigna le poker et je lui gagnai
tenacement trois longues parties d’échecs. Quand la nuit vint, nous étions si
acharnés que nous nous risquâmes d’un commun accord à allumer une
lampe.
Après une interminable série de parties, nous soupâmes et l’artilleur
acheva le champagne. Nous ne cessions de fumer des cigares, mais rien ne
restait de l’énergique régénérateur de la race humaine que j’avais écouté le
matin de ce même jour. Il était encore optimiste, mais son optimisme était
plus calme et plus réfléchi. Je me souviens qu’il proposa, dans un discours
incohérent et peu varié, de boire à ma santé. Je pris un cigare et montai aux
étages supérieurs, pour tâcher d’apercevoir les lueurs verdâtres dont il avait
parlé.
Tout d’abord, mes regards errèrent à travers la vallée de Londres. Les
collines du nord étaient enveloppées de ténèbres; les flammes qui montaient
de Kensington rougeoyaient et, de temps à autre, une langue de flamme
jaunâtre s’élançait et s’évanouissait dans la profonde nuit bleue. Tout le
reste de l’immense ville était obscur. Alors, plus près de moi, j’aperçus une
étrange clarté, une sorte de fluorescence, d’un pâle violet pourpre, que la
brise nocturne faisait frissonner. Pendant un
Londres mort.
(CHAPITRE XXV)

Welcome to Our Bookstore - The Ultimate Destination for Book Lovers
Are you passionate about books and eager to explore new worlds of
knowledge? At our website, we offer a vast collection of books that
cater to every interest and age group. From classic literature to
specialized publications, self-help books, and children’s stories, we
have it all! Each book is a gateway to new adventures, helping you
expand your knowledge and nourish your soul
Experience Convenient and Enjoyable Book Shopping Our website is more
than just an online bookstore—it’s a bridge connecting readers to the
timeless values of culture and wisdom. With a sleek and user-friendly
interface and a smart search system, you can find your favorite books
quickly and easily. Enjoy special promotions, fast home delivery, and
a seamless shopping experience that saves you time and enhances your
love for reading.
Let us accompany you on the journey of exploring knowledge and
personal growth!
ebookgate.com

Python pocket reference 5ed. Edition Mark Lutz

Contenu connexe

Similaire à Python pocket reference 5ed. Edition Mark Lutz (10)

Dernier (20)

Python pocket reference 5ed. Edition Mark Lutz