Python 3编程完全指南

需积分: 9 48 浏览量更新于2024-07-18 1 收藏 3.15MB PDF 举报

"Programming in Python 3 - A Complete Introduction to the Python Language" 是一本由 Mark Summerfield 编著的第二版Python编程教程，旨在全面介绍Python 3编程语言的基础和高级概念。本书深入浅出地讲解了Python 3的核心概念，包括但不限于： 1. **基础语法**：从安装Python解释器开始，书中详细介绍了变量、数据类型（如整型、浮点型、字符串、布尔型）、列表、元组、字典和集合等基本数据结构。同时，还涉及了流程控制（如条件语句、循环语句）和函数的使用。 2. **面向对象编程**：Python是面向对象的语言，书中会讲解类与对象的概念，包括类的定义、对象的创建、继承、封装、多态等面向对象编程的基本原理。 3. **模块与包**：如何组织代码，使用import导入模块，以及如何创建和使用自定义的Python包。 4. **异常处理**：学习如何使用try/except语句来捕获和处理程序运行时可能出现的错误，以及finally和raise语句的使用。 5. **文件操作**：读写文件，包括文本文件和二进制文件的处理，以及文件I/O模式的了解。 6. **标准库和第三方库**：介绍Python标准库中的常用模块，如os、sys、math、datetime等，并简要提及如何通过pip安装和使用第三方库。 7. **高级特性**：包括生成器、上下文管理器、装饰器、闭包等Python的高级特性和编程技巧。 8. **函数式编程**：讲解Python中的函数式编程概念，如map、filter、reduce等高阶函数，以及lambda表达式。 9. **单元测试**：介绍如何编写和执行单元测试，使用unittest模块进行代码质量的保证。 10. **调试与性能优化**：涵盖如何使用Python内置的pdb调试器，以及如何分析和优化代码性能。 11. **并发编程**：介绍线程和进程，以及Python中的异步IO（如asyncio库），帮助读者理解并发执行的概念。 12. **网络编程**：讲解如何使用Python进行网络通信，包括HTTP协议、套接字编程等。 13. **Web开发**：基础的Web开发知识，可能包括使用Python的Web框架如Flask或Django搭建简单的Web应用。 14. **数据分析和科学计算**：简单介绍NumPy、Pandas和Matplotlib等库在数据处理和可视化方面的作用。 15. **数据库编程**：连接和操作SQL数据库，如SQLite、MySQL或PostgreSQL，使用Python的DB-API。本书不仅适合初学者，也适用于有一定经验的开发者，以巩固和扩展他们的Python知识。它通过丰富的示例和练习，帮助读者掌握Python编程，从而能够独立开发各种类型的软件项目。同时，对于企业级的批量购买或特殊销售，出版社提供了优惠折扣，可能包括电子版本和定制化内容，以适应不同的培训需求和市场定位。

ptg

Introduction 3

possible, small but complete programs and modules are used as examples to

provide realistic use cases. The examples, exercise solutions, and the book’s

errata are available online at

www.qtrac.eu/py3book.html

Two sets of examples are provided. The standard examples work with any

Python 3.x version—use these if you care about Python 3.0 compatibility. The

“eg31” examples work with Python 3.1 or later—use these if you don’t need to

support Python 3.0 because your programs’ users have Python 3.1 or later. All

of the examples have been tested on Windows, Linux, and Mac OS X.

While it is best to use the most recent version of Python 3, this is not always

possible if your users cannot or will not upgrade. Every example in this book

works with Python 3.0 except where stated, and those examples and features

that are speciﬁc to Python 3.1 are clearly indicated as such.

Although it is possible to use this book to develop software that uses only

Python 3.0, for those wanting to produce software that is expected to be in use

for many years and that is expected to be compatible with later Python 3.x re-

leases, it is best to use Python 3.1 as the oldest Python 3 version that you sup-

port. This is partly because Python 3.1 has some very nice new features, but

mostly because the Python developers strongly recommend using Python 3.1

(or later). The developers have decided that Python 3.0.1 will be the last

Python 3.0. y release, and that there will be no more Python 3.0.y releases even

if bugs or security problems are discovered. Instead, they want all Python 3

users to migrate to Python 3.1 (or to a later version), which will have the usu-

al bugﬁx and security maintenance releases that Python versions normal-

ly have.

The Structure of the Book

Chapter 1 presents eight key pieces of Python that are sufﬁcient for writing

complete programs. It also describes some of the Python programming

environmentsthat are available and presentstwo tiny example programs,both

built using the eight key pieces of Python covered earlier in the chapter.

Chapters 2 through 5 introduce Python’s procedural programming features,

including its basic data types and collection data types, and many useful built-

in functions and control structures, as well as very simple text ﬁle handling.

Chapter 5 shows how to create custom modules and packages and provides an

overview of Python’s standard library so that you will have a good idea of the

functionality that Python provides out of the box and can avoid reinventing

the wheel.

Chapter 6 provides a thorough introduction to object-oriented programming

with Python. All of the material on procedural programming that you learned

in earlier chapters is still applicable, since object-oriented programming is

From the Library of STEPHEN EISEMAN

ptg

4 Introduction

built on procedural foundations—for example, making use of the same data

types, collection data types, and control structures.

Chapter 7 covers writing and reading ﬁles. For binary ﬁles, the coverage in-

cludes compression and random access,and for text ﬁles,the coverage includes

parsing manually and with regular expressions. This chapter also shows how

to write and read XML ﬁles, including using element trees, DOM (Document

Object Model), and SAX (Simple API for XML).

Chapter 8revisits material covered in some earlier chapters,exploring many of

Python’s more advanced features in the areas of data types and collection data

types, control structures, functions, and object-oriented programming. This

chapter also introducesmany new functions,classes,and advanced techniques,

including functional-style programming and the use of coroutines—the mate-

rial it covers is both challenging and rewarding.

Chapter 9 is different from all the other chapters in that it discusses techniques

and libraries for debugging, testing, and proﬁling programs, rather than

introducing new Python features.

The remaining chapterscover variousadvanced topics. Chapter 10 shows tech-

niques for spreading a program’s workload over multiple processes and over

multiple threads. Chapter 11 shows how to write client/server applications

using Python’s standard networking support. Chapter 12 covers database pro-

gramming (both simple key–value “DBM” ﬁles and SQL databases).

Chapter 13 explains and illustratesPython’s regular expression mini-language

and coversthe regular expressionsmodule. Chapter 14 followson from the reg-

ular expressionschapterby showing basic parsing techniquesusing regular ex-

pressions, and also using two third-party modules,PyParsing and PLY. Finally,

Chapter 15 introduces GUI (Graphical User Interface) programming using the

tkinter

module that is part of Python’s standard library. In addition, the book

has a very brief epilogue, a selected bibliography, and of course, an index.

Most of the book’s chapters are quite long to keep all the related material

together in one place for ease of reference. However, the chapters are broken

down into sections, subsections, and sometimes subsubsections, so it is easy to

read at a pace that suits you; for example, by reading one section or subsection

at a time.

Obtaining and Installing Python 3

If you have a modern and up-to-date Mac or other Unix-like system you may

already have Python 3 installed. You can check by typing

python -V

(note the

capital V) in a console (Terminal.app on Mac OS X)—if the version is 3.x you’ve

already got Python 3 and don’t have to install it yourself. If Python wasn’t

found at all it may be that it has a name which includes a version number. Try

From the Library of STEPHEN EISEMAN

ptg

Introduction 5

typing

python3 -V

,and if that does not work try

python3.0 -V

,and failing that try

python3.1 -V

. If any of these work you now know that you already have Python

installed,what version it is,and what it is called. (In this book we use the name

python3

, but use whatever name worked for you, for example,

python3.1

.) If you

don’t have any version of Python 3 installed, read on.

For Windows and Mac OS X, easy-to-use graphical installer packages are pro-

vided that take you step-by-step through the installation process. These are

available from

www.python.org/download

. For Windows, download the “Windows

x86 MSI Installer”, unless you know for sure that your machine has a different

processor for which a separate installer is supplied—for example, if you have

an AMD64, get the “Windows AMD64 MSI Installer”. Once you’ve got the in-

staller, just run it and follow the on-screen instructions.

For Linux, BSD, and other Unixes (apart from Mac OS X for which a

.dmg

in-

stallation ﬁle is provided), the easiest way to install Python is to use your oper-

ating system’spackage management system. In most cases Python is provided

in several separate packages. For example, in Ubuntu (from version 8), there

python3.0

for Python,

idle-python3.0

for IDLE (a simple development envi-

ronment), and

python3.0-doc

for the documentation—as well as many other

packages that provide add-ons for even more functionality than that provided

by the standard library. (Naturally, the package names will start with

python-

3.1

for the Python 3.1 versions, and so on.)

If no Python 3 packages are available for your operating system you will

need to download the source from

www.python.org/download

and build Python

from scratch. Get either of the source tarballs and unpack it using

tar xvfz

Python-3.1.tgz

if you got the gzipped tarball or

tar xvfj Python-3.1.tar.bz2

you got the bzip2 tarball. (The version numbers may be different, for example,

Python-3.1.1.tgz

Python-3.1.2.tar.bz2

, in which case simply replace

3.1

with

your actual version number throughout.) The conﬁguration and building are

standard. First, change into the newly created

Python-3.1

directory and run

./configure

. (You can use the

--prefix

option if you want to do a local install.)

Next, run

make

It is possible that you may get some messages at the end saying that not all

modules could be built. This normally means that you don’t have some of the

required libraries or headers on your machine. For example, if the

readline

module could not be built, use the package management system to install the

corresponding development library; for example,

readline-devel

on Fedora-

based systems and

readline-dev

on Debian-based systems such as Ubuntu.

Another module that may not build straight away is the

tkinter

module—this

depends on both the Tcl and Tk development libraries,

tcl-devel

and

tk-devel

on Fedora-based systems, and

tcl8.5-dev

and

tk8.5-dev

on Debian-based sys-

tems (and where the minor version may not be 5). Unfortunately, the relevant

package names are not always so obvious, so you might need to ask for help on

From the Library of STEPHEN EISEMAN

ptg

6 Introduction

Python’smailing list. Once the missing packagesare installed,run

./configure

and

make

again.

After successfully making, you could run

make test

to see that everything is

okay, although this is not necessary and can take many minutes to complete.

If you used

--prefix

to do a local installation, just run

make install

.For

Python 3.1, if you installed into, say,

~/local/python31

, then by adding the

~/lo-

cal/python31/bin

directory to your

PATH

, you will be able to run Python using

python3

and IDLE using

idle3

.Alternatively,if you already have a local directo-

ry for executables that is already in your

PATH

(such as

~/bin

), you might prefer

to add soft links instead of changing the

PATH

. For example, if you keep exe-

cutables in

~/bin

and you installed Python in

~/local/python31

,you could create

suitable links by executing

ln -s ~/local/python31/bin/python3 ~/bin/python3

and

~/local/python31/bin/idle3 ~/bin/idle3

. For this book we did a local install

and added soft links on Linux and Mac OS X exactly as described here—and

on Windows we used the binary installer.

If you did not use

--prefix

and have root access, log in as root and do

make in-

stall

. On sudo-based systems like Ubuntu, do

sudo make install

. If Python 2 is

on the system,

/usr/bin/python

won’t be changed, and Python 3 will be avail-

able as

python3.0

(or

python3.1

depending on the version installed) and from

Python 3.1, in addition, as

python3

. Python 3.0’s IDLE is installed as

idle

so if access to Python 2’s IDLE is still required the old IDLE will need to be

renamed—for example, to

/usr/bin/idle2

—before doing the install. Python 3.1

installs IDLE as

idle3

and so does not conﬂict with Python 2’s IDLE.

Acknowledgments

I would ﬁrst like to acknowledge with thanks the feedback I have received

from readers of the ﬁrst edition, who gave corrections, or made suggestions,

or both.

My next acknowledgments are of the book’s technical reviewers, starting

with Jasmin Blanchette, a computer scientist, programmer, and writer with

whom I have cowritten two C

/Qt books. Jasmin’s involvement with chapter

planning and his suggestionsand criticisms regarding all the examples,as well

as his careful reading, have immensely improved the quality of this book.

Georg Brandl is a leading Python developer and documentor responsible for

creating Python’s new documentation tool chain. Georg spotted many sub-

tle mistakes and very patiently and persistently explained them until they

were understood and corrected. He also made many improvements to the ex-

amples.

From the Library of STEPHEN EISEMAN

ptg

Introduction 7

Phil Thompson is a Python expert and the creator of PyQt, probably the best

Python GUI library available. Phil’s sharp-eyed and sometimes challenging

feedback led to many clariﬁcations and corrections.

Trenton Schulz is a senior software engineer at Nokia’s Qt Software (formerly

Trolltech) who has been a valuable reviewer of all my previous books, and has

once again come to my aid. Trenton’s careful reading and the numerous sug-

gestions that he made helped clarify many issues and have led to considerable

improvements to the text.

In addition to the aforementioned reviewers, all of whom read the whole

book, David Boddie, a senior technical writer at Nokia’s Qt Software and an

experienced Python practitioner and open source developer,has read and given

valuable feedback on portions of it.

For this second edition, I would also like to thank Paul McGuire (author of the

PyParsing module), who was kind enough to review the PyParsing examples

that appear in the new chapter on parsing,and who gave me a lot of thoughtful

and useful advice. And for the same chapter, David Beazley (author of the

PLY module) reviewed the PLY examples and provided valuable feedback. In

addition, Jasmin, Trenton, Georg, and Phil read most of this second edition’s

new material, and provided very valuable feedback.

Thanks are also due to Guido van Rossum, creator of Python, as well as to the

wider Python community who have contributed so much to make Python, and

especially its libraries, so useful and enjoyable to use.

As always, thanks to Jeff Kingston, creator of the Lout typesetting language

that I have used for more than a decade.

Special thanks to my editor, Debra Williams Cauley, for her support, and for

once again making the entire process as smooth as possible. Thanks also to

Anna Popick, who managed the production process so well, and to the proof-

reader, Audrey Doyle, who did such ﬁne work once again. And for this second

edition I also want to thank Jennifer Lindner for helping me keep the new ma-

terial understandable,and the ﬁrst edition’sJapanese translator Takahiro Na-

gao , for spotting some subtle mistakes which I’ve been able to correct

in this edition.

Last but not least, I want to thank my wife, Andrea, both for putting up with

the 4 a.m. wake-ups when book ideas and code corrections often arrived and

insisted upon being noted or tested there and then, and for her love, loyalty,

and support.

From the Library of STEPHEN EISEMAN

剩余643页未读，继续阅读

rcliu_

粉丝: 0
资源: 1

Python 3编程完全指南

Programming in Python 3 A Complete Introduction to the Python Language

Programming in Python 3 - A Complete Introduction to the Python Language 2nd

an introduction to interactive programming in python

python语言程序设计 [introduction to programming using python] pdf

Write simples state machine on c++ programming language

def __init__(self, master):

how to extract the words from a pdf paper in python programming

导入stdio模块，用stdio.writeln（函数 输出"Introduction to Program- ming in Python : An Interdisciplinary Approac h"

最新资源

def init(self, master):

导入stdio模块，用stdio.writeln（函数输出"Introduction to Program- ming in Python : An Interdisciplinary Approac h"