Python 2.5参考手册：高级编程与模块化开发

需积分: 9 86 浏览量更新于2024-08-02 收藏 443KB PDF 举报

"Python Reference Manual.pdf" 《Python参考手册》是Python编程语言的重要参考资料，主要针对Python 2.5版本。该手册由Guido van Rossum编写，Fred L. Drake, Jr.担任编辑，并于2006年9月19日发布。此手册是由Python Software Foundation出版的，提供给开发者和学习者深入了解Python语言的官方文档。 Python是一种解释型、面向对象、高级编程语言，其主要特点包括动态语义。Python的高级内置数据结构，如列表、元组、字典等，结合动态类型和动态绑定，使得它在快速应用开发以及作为脚本或胶水语言连接现有组件方面具有显著优势。这使得Python在各种领域，如Web开发、数据分析、科学计算等，都得到了广泛应用。 Python的语法简洁易学，强调代码可读性，从而降低了程序维护的成本。它的语法特性包括缩进控制结构，使代码看起来更加整洁。此外，Python支持模块和包，这促进了程序的模块化和代码重用，增强了代码的组织性和可维护性。 Python解释器允许用户直接运行Python代码，而标准库提供了大量预先编写的函数和类，涵盖了操作系统接口、网络通信、文本处理、数学计算等多个方面，极大地丰富了Python的可用功能。这使得开发者无需从零开始，可以快速构建复杂的系统。 Python还支持异常处理机制，允许程序员优雅地处理运行时错误。同时，Python的面向对象特性包括类、继承、封装和多态，使得开发者可以创建复杂的数据结构和设计模式。Python还支持函数式编程元素，如高阶函数和闭包，增加了编程的灵活性。《Python参考手册》详细介绍了Python 2.5版本的语言特性和标准库，是Python程序员必备的参考书籍，无论你是初学者还是经验丰富的开发者，都能从中获取深入理解Python所需的知识。手册中涵盖的主题包括但不限于：基本语法、数据类型、控制流、函数、类与对象、模块和包、异常处理、输入和输出、标准库等，全面覆盖了Python编程的各个方面。

floatnumber ::= pointfloat | exponentfloat

pointfloat ::= [intpart] fraction | intpart "."

exponentfloat ::= (intpart | pointfloat) exponent

intpart ::= digit+

fraction ::= "." digit+

exponent ::= ("e" | "E") ["+" | "-"] digit+

Note that the integer and exponent parts of ﬂoating point numbers can look like octal integers, but are interpreted

using radix 10. For example, ‘077e010’ is legal, and denotes the same number as ‘77e10’. The allowed range

of ﬂoating point literals is implementation-dependent. Some examples of ﬂoating point literals:

3.14 10. .001 1e100 3.14e-10 0e0

Note that numeric literals do not include a sign; a phrase like -1 is actually an expression composed of the unary

operator - and the literal 1.

2.4.6 Imaginary literals

Imaginary literals are described by the following lexical deﬁnitions:

imagnumber ::= (floatnumber | intpart) ("j" | "J")

An imaginary literal yields a complex number with a real part of 0.0. Complex numbers are represented as a

pair of ﬂoating point numbers and have the same restrictions on their range. To create a complex number with a

nonzero real part, add a ﬂoating point number to it, e.g., (3+4j). Some examples of imaginary literals:

3.14j 10.j 10j .001j 1e100j 3.14e-10j

2.5 Operators

The following tokens are operators:

+ -

* **

/ // %

<< >> & | ˆ ˜

< > <= >= == != <>

The comparison operators <> and != are alternate spellings of the same operator. != is the preferred spelling; <>

is obsolescent.

2.6 Delimiters

The following tokens serve as delimiters in the grammar:

( ) [ ] { } @

, : . ‘ = ;

+= -=

= /= //= %=

&= |= ˆ= >>= <<=

The period can also occur in ﬂoating-point and imaginary literals. A sequence of three periods has a special

meaning as an ellipsis in slices. The second half of the list, the augmented assignment operators, serve lexically

as delimiters, but also perform an operation.

The following printing ASCII characters have special meaning as part of other tokens or are otherwise signiﬁcant

10 Chapter 2. Lexical analysis

CHAPTER

THREE

Data model

3.1 Objects, values and types

Objects are Python’s abstraction for data. All data in a Python program is represented by objects or by relations

between objects. (In a sense, and in conformance to Von Neumann’s model of a “stored program computer,” code

is also represented by objects.)

Every object has an identity, a type and a value. An object’s identity never changes once it has been created;

you may think of it as the object’s address in memory. The ‘is’ operator compares the identity of two objects;

the id() function returns an integer representing its identity (currently implemented as its address). An object’s

type is also unchangeable.

An object’s type determines the operations that the object supports (e.g., “does it

have a length?”) and also deﬁnes the possible values for objects of that type. The type() function returns an

object’s type (which is an object itself). The value of some objects can change. Objects whose value can change

are said to be mutable; objects whose value is unchangeable once they are created are called immutable. (The

value of an immutable container object that contains a reference to a mutable object can change when the latter’s

value is changed; however the container is still considered immutable, because the collection of objects it contains

cannot be changed. So, immutability is not strictly the same as having an unchangeable value, it is more subtle.)

An object’s mutability is determined by its type; for instance, numbers, strings and tuples are immutable, while

dictionaries and lists are mutable.

Objects are never explicitly destroyed; however, when they become unreachable they may be garbage-collected.

An implementation is allowed to postpone garbage collection or omit it altogether — it is a matter of implemen-

tation quality how garbage collection is implemented, as long as no objects are collected that are still reachable.

(Implementation note: the current implementation uses a reference-counting scheme with (optional) delayed de-

tection of cyclically linked garbage, which collects most objects as soon as they become unreachable, but is not

guaranteed to collect garbage containing circular references. See the

Python Library Reference for information on

controlling the collection of cyclic garbage.)

Note that the use of the implementation’s tracing or debugging facilities may keep objects alive that would nor-

mally be collectable. Also note that catching an exception with a ‘try...except’ statement may keep objects

alive.

Some objects contain references to “external” resources such as open ﬁles or windows. It is understood that

these resources are freed when the object is garbage-collected, but since garbage collection is not guaranteed to

happen, such objects also provide an explicit way to release the external resource, usually a close() method.

Programs are strongly recommended to explicitly close such objects. The ‘try...finally’ statement provides

a convenient way to do this.

Some objects contain references to other objects; these are called containers. Examples of containers are tuples,

lists and dictionaries. The references are part of a container’s value. In most cases, when we talk about the value

of a container, we imply the values, not the identities of the contained objects; however, when we talk about the

mutability of a container, only the identities of the immediately contained objects are implied. So, if an immutable

container (like a tuple) contains a reference to a mutable object, its value changes if that mutable object is changed.

Since Python 2.2, a gradual merging of types and classes has been started that makes this and a few other assertions made in this manual

not 100% accurate and complete: for example, it is now possible in some cases to change an object’s type, under certain controlled conditions.

Until this manual undergoes extensive revision, it must now be taken as authoritative only regarding “classic classes”, that are still the default,

for compatibility purposes, in Python 2.2 and 2.3. For more information, see http://www.python.org/doc/newstyle.html.

剩余93页未读，继续阅读

alexzhang010

粉丝: 0

Python 2.5参考手册：高级编程与模块化开发

phython3的manual手册中文版

一文掌握Python基础知识

python官方api参考手册chm格式

abaqus scripting reference manual.pdf

MySQL 5.6 Reference Manual.pdf

mysql reference manual.a4.pdf

2-Script reference manual 612-Python Commands.pdf

Python入门指南.pdf

The Python Language Reference Manual 无水印pdf

Python库参考手册.pdf

最新资源