Python3.4语言参考手册

需积分: 9 104 浏览量更新于2024-07-21 收藏 588KB PDF 举报

"Python3.4参考手册" 《Python3.4参考手册》是Python编程者的重要参考资料，尤其对于初学者而言，它提供了全面的语言规范和解释。本手册由Guido van Rossum和Python开发团队编写，最新版本为3.4.3，发布于2015年7月8日，由Python Software Foundation出版。 1. 介绍 - 替代实现：Python有多个不同的实现，如CPython（官方实现）、Jython（在Java平台上运行的Python）、IronPython（在.NET平台上运行的Python）等，它们都遵循Python语言规范。 - 记号：手册详细介绍了Python中的语法记号，如缩进、注释、行结构等，这些都是Python语法的关键组成部分。 2. 词法分析 - 行结构：Python代码中，行的结束通常由换行符表示，但可以通过反斜杠(\)进行续行。 - 其他标记：包括各种符号，如括号、引号、运算符等。 - 标识符和关键字：Python的变量名必须符合特定规则，且不能与关键字冲突。 - 字面量：整数、浮点数、字符串、布尔值等常量的表示方式。 - 运算符：加减乘除、比较、逻辑等运算符的使用。 - 分隔符：逗号、冒号、点等在Python中的作用。 3. 数据模型 - 对象、值和类型：Python的一切皆为对象，每个对象都有其特定的类型和值。 - 标准类型层次：Python中的基本数据类型，如整型(int)、浮点型(float)、字符串(str)、列表(list)、元组(tuple)、字典(dict)等的层级关系。 - 特殊方法名：如`__init__`、`__add__`等，用于对象的创建、操作和自定义行为。 4. 执行模型 - 命名和绑定：解释了Python中的变量是如何被命名和绑定到值的，以及作用域规则。 - 异常：如何处理程序运行时出现的错误，包括异常的捕获、抛出和自定义异常。 5. 导入系统 - importlib：Python的模块导入机制，允许动态加载和管理模块。 - 包：多级目录结构的模块组织方式。 - 搜索：Python如何查找模块，包括sys.path中的路径。 - 加载：模块被找到后如何加载到内存中。 - PathBasedFinder：一种模块查找策略。 - 替换标准导入系统：如何自定义模块导入行为。 - __main__：模块作为脚本执行时的特殊行为。 - 开放问题：当前导入系统的一些未解决或待改进的问题。 6. 表达式 - 算术转换：不同类型数值之间的运算会自动进行类型转换。 - 原子：包括空值(None)、数字、字符串、布尔值等基本表达式。 - 主要表达式：更复杂的表达式结构，如函数调用、字典和列表的构造等。 - 幂运算：``运算符的用法。 - 一元运算符：如`+`、`-`、`~`等对数值和位进行操作。 - 二元算术运算：加、减、乘、除、取模等运算。 - 移位运算：左移(`<<`)和右移(`>>`)运算符。 - 位运算：按位与(`&`)、按位或(`|`)、按位异或(`^`)和按位取反(`~`)。此外，手册还涵盖了语句、控制流、函数、类、模块、异常处理、输入/输出、标准库等内容，为Python3.4的开发者提供了详尽的指导。通过深入学习，开发者可以更好地理解和掌握Python3.4的语法特性，从而编写出高效、健壮的代码。

The Python Language Reference, Release 3.4.3

There is no limit for the length of integer literals apart from what can be stored in available memory.

Note that leading zeros in a non-zero decimal number are not allowed. This is for disambiguation with C-style

octal literals, which Python used before version 3.0.

Some examples of integer literals:

7 2147483647 0o177 0b100110111

3 79228162514264337593543950336 0o377 0xdeadbeef

2.4.5 Floating point literals

Floating point literals are described by the following lexical deﬁnitions:

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 are always 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:

+ -

* **

/ // %

<< >> & | ^ ~

< > <= >= == !=

2.6 Delimiters

The following tokens serve as delimiters in the grammar:

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.

CPython implementation detail: For CPython, id(x) is the memory address where x is stored.

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). Like its identity, an object’s type is also unchangeable.

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.

CPython implementation detail: 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. Do not depend on immediate ﬁnalization of objects when they become unreachable (so you should

always close ﬁles explicitly).

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 and the ‘with‘

statement provide convenient ways 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

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 3.4.3

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

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.), although such additions will often

be provided via the standard library instead.

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 should

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.

See implementing-the-arithmetic-operations for more details.

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

literal ... or the built-in name Ellipsis. 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 two types of integers:

Integers (int)

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 (bool) 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

the integer type, 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.

16 Chapter 3. Data model

剩余134页未读，继续阅读

追曦之翼

粉丝: 0
资源: 1

Python3.4语言参考手册

python3.4官方手册

Python3.4中文手册.zip

python2.7与python3.4帮助手册

Python 3.4 官方中文手册指南

Python 3.4中文入门手册：简洁高效的语言特性

掌握Python3.4：中文手册带你领略编程语言的魅力

Python编程速查手册第5版：针对Python 3.4和2.7更新

Python 3.4 & 2.7速查手册：第五版

python3.6.5参考手册 chm

python最新参考手册3.4.0.chm

最新资源