Python语言参考手册：2.6.2版详解

3星 · 超过75%的资源需积分: 9 11 浏览量更新于2024-08-02 收藏 836KB PDF 举报

本资源是一份Python语言的官方参考手册，名为"The Python Language Reference", 发布于2009年7月15日，由Guido van Rossum撰写，Fred L. Drake Jr.担任编辑。该手册主要针对Python编程语言，提供详细的语法、数据模型、执行模型以及核心概念的介绍，适合深入理解和学习Python的开发者。 1. **介绍**： - 手册首先概述了Python语言的替代实现，表明其在多样性的开发环境中的适用性。 - 介绍了手册使用的符号和术语约定，确保读者在阅读过程中能够准确理解。 2. **词法分析**： - 包括Python的语句结构，如行分隔符、关键字、标识符等。 - 特别强调了不同类型的常量（literals）及其使用规则，比如数值、字符串和标识符。 - 深入解析了运算符（包括算术、逻辑和位操作符），以及用于控制程序流程的分隔符（delimiters）。 3. **数据模型**： - 解释了Python中的对象、值和类型，区分新式类（new-style classes）与经典类（classic classes）的概念。 - 提供了标准类型层次结构，帮助开发者理解内置数据结构和对象的行为。 4. **执行模型**： - 讨论了命名和绑定规则，即变量是如何在程序中关联到特定值的。 - 强调了异常处理机制，是Python编程中不可或缺的一部分。 5. **表达式**： - 阐述了不同类型的转换规则，例如算术运算符的优先级和原子表达式的概念。 - 详细解释了递增、递减运算符，二进制算术、位移和比较操作。 - 介绍了匿名函数（lambda表达式）、列表推导等高级特性，以及表达式的评估顺序。 6. **简单语句**： - 重点讨论了表达式语句和赋值，这些基本语句构成程序的基本构造单元。这份手册是Python初学者和专业开发者的必备工具，它提供了丰富的理论基础和实践指导，有助于深入理解Python的内在机制，提升编程技能。无论是新手想要入门，还是经验丰富的开发者遇到复杂问题，都能从中找到所需的信息。

The Python Language Reference, Release 2.6.2

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

to the lexical analyzer:

’ " # \

The following printing ASCII characters are not used in Python. Their occurrence outside string literals and

comments is an unconditional error:

$ ?

12 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 implementation quality how garbage collection is implemented,

as long as no objects are collected that are still reachable. (Implementation note: CPython currently uses a

reference-counting scheme with (optional) delayed detection 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 documentation of the gc module for information on controlling the collection of cyclic garbage. Other

implementations act differently and CPython may change.)

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.

Types affect almost all aspects of object behavior. Even the importance of object identity is affected in some sense:

for immutable types, operations that compute new values may actually return a reference to any existing object

with the same type and value, while for mutable objects this is not allowed. E.g., after a = 1; b = 1, a and

It is possible in some cases to change an object’s type, under certain controlled conditions. It generally isn’t a good idea though, since it

can lead to some very strange behaviour if it is handled incorrectly.

The Python Language Reference, Release 2.6.2

b may or may not refer to the same object with the value one, depending on the implementation, but after c =

[]; d = [], c and d are guaranteed to refer to two different, unique, newly created empty lists. (Note that c

= d = [] assigns the same object to both c and d.)

3.2 The standard type hierarchy

Below is a list of the types that are built into Python. Extension modules (written in C, Java, or other languages,

depending on the implementation) can deﬁne additional types. Future versions of Python may add types to the type

hierarchy (e.g., rational numbers, efﬁciently stored arrays of integers, etc.). Some of the type descriptions below

contain a paragraph listing ‘special attributes.’ These are attributes that provide access to the implementation and

are not intended for general use. Their deﬁnition may change in the future.

None This type has a single value. There is a single object with this value. This object is accessed through the

built-in name None. It is used to signify the absence of a value in many situations, e.g., it is returned from

functions that don’t explicitly return anything. Its truth value is false.

NotImplemented This type has a single value. There is a single object with this value. This object is accessed

through the built-in name NotImplemented. Numeric methods and rich comparison methods may return

this value if they do not implement the operation for the operands provided. (The interpreter will then try

the reﬂected operation, or some other fallback, depending on the operator.) Its truth value is true.

Ellipsis This type has a single value. There is a single object with this value. This object is accessed through the

built-in name Ellipsis. It is used to indicate the presence of the ... syntax in a slice. Its truth value is

true.

numbers.Number These are created by numeric literals and returned as results by arithmetic operators and

arithmetic built-in functions. Numeric objects are immutable; once created their value never changes.

Python numbers are of course strongly related to mathematical numbers, but subject to the limitations of

numerical representation in computers.

Python distinguishes between integers, ﬂoating point numbers, and complex numbers:

numbers.Integral These represent elements from the mathematical set of integers (positive and neg-

ative).

There are three types of integers:

Plain integers These represent numbers in the range -2147483648 through 2147483647. (The range

may be larger on machines with a larger natural word size, but not smaller.) When the result of an

operation would fall outside this range, the result is normally returned as a long integer (in some

cases, the exception OverflowError is raised instead). For the purpose of shift and mask

operations, integers are assumed to have a binary, 2’s complement notation using 32 or more bits,

and hiding no bits from the user (i.e., all 4294967296 different bit patterns correspond to different

values).

Long integers These represent numbers in an unlimited range, subject to available (virtual) memory

only. For the purpose of shift and mask operations, a binary representation is assumed, and

negative numbers are represented in a variant of 2’s complement which gives the illusion of an

inﬁnite string of sign bits extending to the left.

Booleans These represent the truth values False and True. The two objects representing the values

False and True are the only Boolean objects. The Boolean type is a subtype of plain integers, and

Boolean values behave like the values 0 and 1, respectively, in almost all contexts, the exception

being that when converted to a string, the strings "False" or "True" are returned, respectively.

The rules for integer representation are intended to give the most meaningful interpretation of shift

and mask operations involving negative integers and the least surprises when switching between the

plain and long integer domains. Any operation, if it yields a result in the plain integer domain, will

yield the same result in the long integer domain or when using mixed operands. The switch between

domains is transparent to the programmer.

14 Chapter 3. Data model

The Python Language Reference, Release 2.6.2

numbers.Real (float) These represent machine-level double precision ﬂoating point numbers. You

are at the mercy of the underlying machine architecture (and C or Java implementation) for the ac-

cepted range and handling of overﬂow. Python does not support single-precision ﬂoating point num-

bers; the savings in processor and memory usage that are usually the reason for using these is dwarfed

by the overhead of using objects in Python, so there is no reason to complicate the language with two

kinds of ﬂoating point numbers.

numbers.Complex These represent complex numbers as a pair of machine-level double precision ﬂoat-

ing point numbers. The same caveats apply as for ﬂoating point numbers. The real and imaginary

parts of a complex number z can be retrieved through the read-only attributes z.real and z.imag.

Sequences These represent ﬁnite ordered sets indexed by non-negative numbers. The built-in function len()

returns the number of items of a sequence. When the length of a sequence is n, the index set contains the

numbers 0, 1, ..., n-1. Item i of sequence a is selected by a[i]. Sequences also support slicing: a[i:j]

selects all items with index k such that i <= k < j. When used as an expression, a slice is a sequence of the

same type. This implies that the index set is renumbered so that it starts at 0. Some sequences also support

“extended slicing” with a third “step” parameter: a[i:j:k] selects all items of a with index x where x =

i + n*k, n >= 0 and i <= x < j.

Sequences are distinguished according to their mutability:

Immutable sequences An object of an immutable sequence type cannot change once it is created. (If the

object contains references to other objects, these other objects may be mutable and may be changed;

however, the collection of objects directly referenced by an immutable object cannot change.)

The following types are immutable sequences:

Strings The items of a string are characters. There is no separate character type; a character is repre-

sented by a string of one item. Characters represent (at least) 8-bit bytes. The built-in functions

chr() and ord() convert between characters and nonnegative integers representing the byte

values. Bytes with the values 0-127 usually represent the corresponding ASCII values, but the

interpretation of values is up to the program. The string data type is also used to represent ar-

rays of bytes, e.g., to hold data read from a ﬁle. (On systems whose native character set is not

ASCII, strings may use EBCDIC in their internal representation, provided the functions chr()

and ord() implement a mapping between ASCII and EBCDIC, and string comparison preserves

the ASCII order. Or perhaps someone can propose a better rule?)

Unicode The items of a Unicode object are Unicode code units. A Unicode code unit is represented by

a Unicode object of one item and can hold either a 16-bit or 32-bit value representing a Unicode

ordinal (the maximum value for the ordinal is given in sys.maxunicode, and depends on how

Python is conﬁgured at compile time). Surrogate pairs may be present in the Unicode object, and

will be reported as two separate items. The built-in functions unichr() and ord() convert

between code units and nonnegative integers representing the Unicode ordinals as deﬁned in the

Unicode Standard 3.0. Conversion from and to other encodings are possible through the Unicode

method encode() and the built-in function unicode().

Tuples The items of a tuple are arbitrary Python objects. Tuples of two or more items are formed by

comma-separated lists of expressions. A tuple of one item (a ‘singleton’) can be formed by afﬁx-

ing a comma to an expression (an expression by itself does not create a tuple, since parentheses

must be usable for grouping of expressions). An empty tuple can be formed by an empty pair of

parentheses.

Mutable sequences Mutable sequences can be changed after they are created. The subscription and slicing

notations can be used as the target of assignment and del (delete) statements.

There is currently a single intrinsic mutable sequence type:

Lists The items of a list are arbitrary Python objects. Lists are formed by placing a comma-separated

list of expressions in square brackets. (Note that there are no special cases needed to form lists of

length 0 or 1.)

The extension module array provides an additional example of a mutable sequence type.

Set types These represent unordered, ﬁnite sets of unique, immutable objects. As such, they cannot be indexed

by any subscript. However, they can be iterated over, and the built-in function len() returns the number

3.2. The standard type hierarchy 15

The Python Language Reference, Release 2.6.2

of items in a set. Common uses for sets are fast membership testing, removing duplicates from a sequence,

and computing mathematical operations such as intersection, union, difference, and symmetric difference.

For set elements, the same immutability rules apply as for dictionary keys. Note that numeric types obey the

normal rules for numeric comparison: if two numbers compare equal (e.g., 1 and 1.0), only one of them

can be contained in a set.

There are currently two intrinsic set types:

Sets These represent a mutable set. They are created by the built-in set() constructor and can be modiﬁed

afterwards by several methods, such as add().

Frozen sets These represent an immutable set. They are created by the built-in frozenset() construc-

tor. As a frozenset is immutable and hashable, it can be used again as an element of another set, or as

a dictionary key.

Mappings These represent ﬁnite sets of objects indexed by arbitrary index sets. The subscript notation a[k]

selects the item indexed by k from the mapping a; this can be used in expressions and as the target of

assignments or del statements. The built-in function len() returns the number of items in a mapping.

There is currently a single intrinsic mapping type:

Dictionaries These represent ﬁnite sets of objects indexed by nearly arbitrary values. The only types of

values not acceptable as keys are values containing lists or dictionaries or other mutable types that are

compared by value rather than by object identity, the reason being that the efﬁcient implementation

of dictionaries requires a key’s hash value to remain constant. Numeric types used for keys obey the

normal rules for numeric comparison: if two numbers compare equal (e.g., 1 and 1.0) then they can

be used interchangeably to index the same dictionary entry.

Dictionaries are mutable; they can be created by the {...} notation (see section Dictionary displays).

The extension modules dbm, gdbm, and bsddb provide additional examples of mapping types.

Callable types These are the types to which the function call operation (see section Calls) can be applied:

User-deﬁned functions A user-deﬁned function object is created by a function deﬁnition (see section

Function deﬁnitions). It should be called with an argument list containing the same number of items

as the function’s formal parameter list.

Special attributes:

Attribute Meaning

func_doc The function’s documentation string, or None if unavailable Writable

__doc__ Another way of spelling func_doc Writable

func_name The function’s name Writable

__name__ Another way of spelling func_name Writable

__module__The name of the module the function was deﬁned in, or None if unavailable. Writable

func_defaultsA tuple containing default argument values for those arguments that have defaults, or

None if no arguments have a default value

Writable

func_code The code object representing the compiled function body. Writable

func_globalsA reference to the dictionary that holds the function’s global variables — the global

namespace of the module in which the function was deﬁned.

Read-

only

func_dict The namespace supporting arbitrary function attributes. Writable

func_closureNone or a tuple of cells that contain bindings for the function’s free variables. Read-

only

Most of the attributes labelled “Writable” check the type of the assigned value. Changed in version 2.4:

func_name is now writable. Function objects also support getting and setting arbitrary attributes,

which can be used, for example, to attach metadata to functions. Regular attribute dot-notation is used

to get and set such attributes. Note that the current implementation only supports function attributes

on user-deﬁned functions. Function attributes on built-in functions may be supported in the future.

Additional information about a function’s deﬁnition can be retrieved from its code object; see the

description of internal types below.

User-deﬁned methods A user-deﬁned method object combines a class, a class instance (or None) and any

callable object (normally a user-deﬁned function).

16 Chapter 3. Data model

剩余110页未读，继续阅读

wgd243

粉丝: 0
资源: 5

Python语言参考手册：2.6.2版详解

python reference and libaray

python-3.6.1 Reference Manual

python_reference_card

Storing unsafe C derivative of temporary Python reference

python遥感影像配准arcpy

python 统一响度如何实现

python怎么加一个时间戳

python中Reference用法

sacrebleu的使用

最新资源