Python快速参考手册：语言基础、标准库和第三方模块

python

需积分: 10 168 浏览量更新于2024-07-19 收藏 3.63MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

opment and maintenance, particularly in large projects, where many developers

cooperate and often maintain code originally written by others.

Python is simple, but not simplistic. It adheres to the idea that, if a language behaves

a certain way in some contexts, it should ideally work similarly in all contexts.

Python also follows the principle that a language should not have “convenient”

shortcuts, special cases, ad hoc exceptions, overly subtle distinctions, or mysterious

and tricky under-the-covers optimizations. A good language, like any other well-

designed artifact, must balance such general principles with taste, common sense,

and a high degree of practicality.

Python is a general-purpose programming language: Python’s traits are useful in

just about any area of software development. There is no area where Python cannot

be part of a great solution. “Part” is an important word here; while many developers

find that Python fills all of their needs, it does not have to stand alone: Python pro‐

grams can cooperate with a variety of other software components, making it an

ideal language for gluing together components written in other languages. One of

the language’s design goals was that it should “play well with others.”

Python is a very high-level language (VHLL). This means that Python uses a higher

level of abstraction, conceptually further from the underlying machine, than do

classic compiled languages such as C, C++, and Fortran, which are traditionally

called “high-level languages.” Python is simpler, faster to process (both for human

brains and for programmatic tools), and more regular than classic high-level lan‐

guages. This enables high programmer productivity and makes Python an attractive

development tool. Good compilers for classic compiled languages can generate

binary machine code that runs faster than Python code. However, in most cases, the

performance of Python-coded applications is sufficient. When it isn’t, apply the

optimization techniques covered in “Optimization” on page 477 to improve your

program’s performance while keeping the benefit of high productivity.

Somewhat newer languages such as Java and C# are slightly higher-level than classic

ones such as C and Fortran, and share some characteristics of classic languages

(such as the need to use declarations) as well as some of VHLLs like Python (such as

the use of portable bytecode as the compilation target in typical implementations,

and garbage collection to relieve programmers from the need to manage memory).

If you find you are more productive with Java or C# than with C or Fortran, try

Python (possibly in the Jython or IronPython implementations, covered in “Python

Implementations” on page 5) to become even more productive.

In terms of language level, Python is comparable to other powerful VHLLs like

JavaScript, Ruby, and Perl. The advantages of simplicity and regularity, however,

remain on Python’s side.

Python is an object-oriented programming language, but lets you develop code

using both object-oriented and procedural styles, and a touch of functional pro‐

gramming, too, mixing and matching as your application requires. Python’s object-

oriented features are conceptually similar to those of C++, but simpler to use.

4 | Chapter 1: Introduction to Python

The Python Standard Library and Extension Modules

There is more to Python programming than just the Python language: the standard

library and other extension modules are nearly as important for effective Python

use as the language itself. The Python standard library supplies many well-designed,

solid, 100 percent pure Python modules for convenient reuse. It includes modules

for such tasks as representing data, processing text, interacting with the operating

system and filesystem, and web programming. Because these modules are written in

Python, they work on all platforms supported by Python.

Extension modules, from the standard library or from elsewhere, let Python code

access functionality supplied by the underlying operating system or other software

components, such as graphical user interfaces (GUIs), databases, and networks.

Extensions also afford maximal speed in computationally intensive tasks such as

XML parsing and numeric array computations. Extension modules that are not

coded in Python, however, do not necessarily enjoy the same automatic cross-

platform portability as pure Python code.

You can write special-purpose extension modules in lower-level languages to ach‐

ieve maximum performance for small, computationally intensive parts that you

originally prototyped in Python. You can also use tools such as Cython and CFFI to

wrap existing C/C++ libraries into Python extension modules, as covered in

“Extending Python Without Python’s C API” on page 677. Last but not least, you

can embed Python in applications coded in other languages, exposing existing

application functionality to Python scripts via app-specific Python extension

modules.

This book documents many modules, both from the standard library and from

other sources, in areas such as client- and server-side network programming, data‐

bases, manipulation of text and binary files, and interaction with the operating

system.

Python Implementations

Python currently has four production-quality implementations (CPython, Jython,

IronPython, PyPy) and a new high-performance implementation in early develop‐

ment, Pyston, which we do not cover further. We also mention a number of other,

more experimental, implementations in a following section.

This book primarily addresses CPython, the most widely used implementation,

which we usually refer to as just “Python” for simplicity. However, the distinction

between a language and its implementations is an important one.

CPython

Classic Python (AKA CPython, often just called Python) is the most up-to-date,

solid, and complete production-quality implementation of Python. It can be consid‐

ered the “reference implementation” of the language. CPython is a compiler, inter‐

preter, and set of built-in and optional extension modules, all coded in standard C.

Intro to

Python

The Python Standard Library and Extension Modules | 5

CPython can be used on any platform where the C compiler complies with the

ISO/IEC 9899:1990 standard (i.e., all modern, popular platforms). In “Installation”

on page 17, we explain how to download and install CPython. All of this book,

except a few sections explicitly marked otherwise, applies to CPython. CPython

supports both v3 (version 3.5 or better) and v2 (version 2.7).

Jython

Jython is a Python implementation for any Java Virtual Machine (JVM) compliant

with Java 7 or better. Such JVMs are available for all popular, modern platforms. As

of this writing, Jython supports v2, but not yet v3. With Jython, you can use all Java

libraries and frameworks. For optimal use of Jython, you need some familiarity with

fundamental Java classes. You do not have to code in Java, but documentation and

examples for Java libraries are couched in Java terms, so you need a nodding

acquaintance with Java to read and understand them. You also need to use Java-

supporting tools for tasks such as manipulating

.jar

files and signing applets. This

book deals with Python, not with Java. To use Jython, you should complement this

book with Jython Essentials, by Noel Rappin and Samuele Pedroni (O’Reilly), Java in

a Nutshell

, by David Flanagan (O’Reilly), and/or

e Denitive Guide to Jython

(Open Source Version) by Josh Juneau, Jim Baker, et al. (Apress, available on O’Reil‐

ly’s Safari and on Jython.org), as well as some of the many other Java resources

available.

IronPython

IronPython is a Python implementation (as of this writing, only v2, not yet v3) for

the Microsoft-designed Common Language Runtime (CLR), most commonly

known as .NET, which is now open source and ported to Linux and macOS. With

IronPython, you can use all CLR libraries and frameworks. In addition to Micro‐

soft’s own implementation, a cross-platform implementation of the CLR known as

Mono works with other, non-Microsoft operating systems, as well as with Windows.

For optimal use of IronPython, you need some familiarity with fundamental CLR

libraries. You do not have to code in C#, but documentation and examples for exist‐

ing CLR libraries are often couched in C# terms, so you need a nodding acquaint‐

ance with C# to read and understand them. You also need to use CLR supporting

tools for tasks such as making CLR assemblies. This book deals with Python, not

with the CLR. For IronPython usage, you should complement this book with Iron‐

Python’s own online documentation, and, if needed, some of the many other resour‐

ces available about .NET, the CLR, C#, Mono, and so on.

PyPy

PyPy is a fast and flexible implementation of Python, coded in a subset of Python

itself, able to target several lower-level languages and virtual machines using

advanced techniques such as type inferencing. PyPy’s greatest strength is its ability

to generate native machine code “just in time” as it runs your Python program.

PyPy implements v2 and, at this writing, Python 3.5 support is being released in

6 | Chapter 1: Introduction to Python

1 Throughout this book, we’ll mention some highlights of Python 3.6, just barely released as we

write—while 3.6 may not yet be mature enough for you to use in production releases, knowing

what’s coming as 3.6 does mature can’t fail to be helpful to your technical choices.

alpha. PyPy has substantial advantages in speed and memory management, and is

seeing production-level use.

Choosing Between CPython, Jython, IronPython, and PyPy

If your platform, as most are, is able to run all of CPython, Jython, IronPython, and

PyPy, how do you choose among them? First of all, don’t choose prematurely:

download and install them all. They coexist without problems, and they’re all free.

Having them all on your development machine costs only some download time and

a little extra disk space, and lets you compare them directly.

The primary difference between the implementations is the environment in which

they run and the libraries and frameworks they can use. If you need a JVM environ‐

ment, then Jython is your best choice. If you need a CLR (AKA “.NET”) environ‐

ment, take advantage of IronPython. If you need a custom version of Python, or

need high performance for long-running programs, consider PyPy.

If you’re mainly working in a traditional environment, CPython is an excellent fit. If

you don’t have a strong preference for one or the other, start with the standard CPy‐

thon reference implementation, which is most widely supported by third-party add-

ons and extensions, and offers the highly preferable v3 (in full 3.5 glory).

In other words, when you’re experimenting, learning, and trying things out, use

CPython, most widely supported and mature. To develop and deploy, your best

choice depends on the extension modules you want to use and how you want to dis‐

tribute your programs. CPython applications are often faster than Jython or IronPy‐

thon, particularly if you use extension modules such as NumPy (covered in “Array

Processing” on page 444); however, PyPy can often be even faster, thanks to just-in-

time compilation to machine code. It may be worthwhile to benchmark your CPy‐

thon code against PyPy.

CPython is most mature: it has been around longer, while Jython, IronPython, and

PyPy are newer and less proven in the field. The development of CPython versions

tends to proceed ahead of that of Jython, IronPython, and PyPy: at the time of writ‐

ing, for example, the language level supported is, for v2, 2.7 for all of them; for v3,

3.5 and 3.6 are now available in CPython, and PyPy has 3.5 in alpha.

However, Jython can use any Java class as an extension module, whether the class

comes from a standard Java library, a third-party library, or a library you develop

yourself. Similarly, IronPython can use any CLR class, whether from the standard

CLR libraries, or coded in C#, Visual Basic .NET, or other CLR-compliant

languages. PyPy is drop-in compatible with most standard CPython libraries, and

Intro to

Python

Python Implementations | 7

with C-coded extensions using Cython, covered in “Cython” on page 678, and CFFI,

mentioned in “Extending Python Without Python’s C API” on page 677.

A Jython-coded application is a 100 percent pure Java application, with all of Java’s

deployment advantages and issues, and runs on any target machine having a suit‐

able JVM. Packaging opportunities are also identical to Java’s. Similarly, an

IronPython-coded application is entirely compliant with .NET’s specifications.

Jython, IronPython, PyPy, and CPython are all good, faithful implementations of

Python, reasonably close to each other in terms of usability and performance. Since

each of the JVM and CLR platforms carries a lot of baggage, but also supplies large

amounts of useful libraries, frameworks, and tools, any of the implementations may

enjoy decisive practical advantages in a specific deployment scenario. It is wise to

become familiar with the strengths and weaknesses of each, and then choose opti‐

mally for each development task.

Other Developments, Implementations, and Distributions

Python has become popular enough that there are a number of other groups and

individuals who have taken an interest in its development and provided features

and implementations outside the core development team’s focus.

Programmers new to Python used to often find it troublesome to install. Nowadays

almost all Unix-based systems include a v2 implementation, and recent releases of

Ubuntu include v3 as the “system Python.” If you are serious about software devel‐

opment in Python, the first thing you should do is leave your system-installed Python

alone! Quite apart from anything else, Python is increasingly used by the operating

system itself, so tweaking the Python installation could lead to trouble.

Therefore, consider installing one or more Python implementations that you can

freely use for your development convenience, sure in the knowledge that nothing

you do affects the operating system. We also recommend the use of virtual environ‐

ments (see “Python Environments” on page 186) to isolate projects from each other,

allowing them to make use of what might otherwise be conflicting dependencies

(e.g., if two of your projects require different versions of the same module).

Python’s popularity has led to the creation of many active communities, and the lan‐

guage’s ecosystem is very active. The following sections outline some of the more

interesting recent developments, but our failure to include a project here reflects

limitations of space and time rather than implying any disapproval on our part.

8 | Chapter 1: Introduction to Python

剩余743页未读，继续阅读

lsb0733

粉丝: 1
资源: 54

Python快速参考手册：语言基础、标准库和第三方模块

C# 6.0 in a Nutshell(6th) 无水印pdf

C# 7.0 in a Nutshell The Definitive Reference epub

C# 7.0 in a Nutshell: The Definitive Reference -epub

python in a nutshell azw3

c# 5.0 in a nutshell.pdf网盘

linux in a nutshell

java in a nutshell 7th edition pdf

java in a nutshell

c# 10 in a nutshell

xml in a nutshell

c# 5.0 in a nutshell

c# 6.0 in a nutshell

Give me a sample IELTS essay with Advanced vocabulary and complex phrases

最近6年的C#参考书写在此处。要求序号、作者、书名、出版社、出版时间。

c#从入门到精通第九版

c#从入门到精通第六版

NEMU shell命令

.net相关电子书推荐

c#方向比较著名的文献

c#开发一个图书管理系统

最新资源