Python 3.5.2官方文档：全面指南与内置类型详解

需积分: 8 87 浏览量更新于2024-07-07 收藏 6.08MB PDF 举报

本资源是一份名为《Python Library Reference》的文档，针对Python 3.5.2版本进行了详细介绍。该文档由Guido van Rossum和Python开发团队编撰，发布日期为2016年9月24日，由Python Software Foundation维护并提供电子邮件支持（docs@python.org）。这份文档主要涵盖了Python语言的核心特性、内置函数、常量、数据类型、异常处理以及文本处理服务等关键知识点。 **1. Introduction** 章节一介绍了Python库的总体概述，可能包括了Python作为编程语言的特点、设计理念以及其在开发中的应用场景。 **2. Built-in Functions** 这部分详述了Python中的内置函数，例如逻辑测试（TruthValueTesting）、布尔运算（and, or, not）以及各种比较操作。这些函数是Python编程的基础，有助于程序员高效地进行数据处理和控制流程。 **3. Built-in Constants** 讲述了Python中的内置常量，如数学常量（如π和e）、特殊字符串常量（如None和True/False），以及由site模块新增的特定常量。理解这些常量有助于开发者编写更灵活的代码。 **4. Built-in Types** 本章详细分类了Python的数据类型，包括整数（int）、浮点数（float）、复数（complex）、迭代器（IteratorTypes）、序列类型（如列表、元组、range和字符串（str））、二进制序列类型（bytes、bytearray、memoryview）、集合（set、frozenset）、映射类型（dict）和上下文管理器（ContextManagerTypes）等。这些都是Python编程中的核心概念。 **4.11 MappingTypes—dict** 特别关注了字典类型，它在数据存储和查询方面具有高效性，是Python中常用的数据结构之一。 **5. Built-in Exceptions** 这一部分讲解了Python的异常处理系统，包括基础的异常类、具体的异常实例（如IOError、TypeError等）以及如何使用try/except块来捕获和处理错误。此外，还提到了警告（Warnings）的使用和Python的异常继承结构。 **6. Text Processing Services** 这部分提供了处理文本的工具，如string模块（字符串操作）、re模块（正则表达式）、difflib模块（计算差异）和textwrap模块（文本包装和填充）。这些功能对于文本处理、数据分析和格式化输出至关重要。这份Python 3.5.2 Library Reference文档为学习者提供了全面而深入的Python基础知识，无论是初学者还是进阶开发者，都可以从中找到所需的函数、类型和工具来提升编程能力。通过理解和掌握这些内容，读者可以更好地构建Python应用程序，并利用Python强大的文本处理功能。

The Python Library Reference, Release 3.5.2

bin(x)

Convert an integer number to a binary string. The result is a valid Python expression. If x is not a Python

int object, it has to deﬁne an __index__() method that returns an integer.

class bool([x ])

Return a Boolean value, i.e. one of True or False. x is converted using the standard truth testing

procedure. If x is false or omitted, this returns False; otherwise it returns True. The bool class is

a subclass of int (see Numeric Types — int, ﬂoat, complex). It cannot be subclassed further. Its only

instances are False and True (see Boolean Values).

class bytearray([source[, encoding[, errors ]]])

Return a new array of bytes. The bytearray class is a mutable sequence of integers in the range 0 <=

x < 256. It has most of the usual methods of mutable sequences, described in Mutable Sequence Types, as

well as most methods that the bytes type has, see Bytes and Bytearray Operations.

The optional source parameter can be used to initialize the array in a few different ways:

•If it is a string, you must also give the encoding (and optionally, errors) parameters; bytearray()

then converts the string to bytes using str.encode().

•If it is an integer, the array will have that size and will be initialized with null bytes.

•If it is an object conforming to the buffer interface, a read-only buffer of the object will be used to

initialize the bytes array.

•If it is an iterable, it must be an iterable of integers in the range 0 <= x < 256, which are used as

the initial contents of the array.

Without an argument, an array of size 0 is created.

See also Binary Sequence Types — bytes, bytearray, memoryview and Bytearray Objects.

class bytes([source[, encoding[, errors ]]])

Return a new “bytes” object, which is an immutable sequence of integers in the range 0 <= x < 256.

bytes is an immutable version of bytearray – it has the same non-mutating methods and the same

indexing and slicing behavior.

Accordingly, constructor arguments are interpreted as for bytearray().

Bytes objects can also be created with literals, see strings.

See also Binary Sequence Types — bytes, bytearray, memoryview, Bytes, and Bytes and Bytearray Opera-

tions.

callable(object)

Return True if the object argument appears callable, False if not. If this returns true, it is still possible

that a call fails, but if it is false, calling object will never succeed. Note that classes are callable (calling a

class returns a new instance); instances are callable if their class has a __call__() method.

New in version 3.2: This function was ﬁrst removed in Python 3.0 and then brought back in Python 3.2.

chr(i)

Return the string representing a character whose Unicode code point is the integer i. For example, chr(97)

returns the string ’a’, while chr(8364) returns the string ’C’. This is the inverse of ord().

The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). ValueError will

be raised if i is outside that range.

classmethod(function)

Return a class method for function.

A class method receives the class as implicit ﬁrst argument, just like an instance method receives the in-

stance. To declare a class method, use this idiom:

class C:

@classmethod

def f(cls, arg1, arg2, ...): ...

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.5.2

The @classmethod form is a function decorator – see the description of function deﬁnitions in function

for details.

It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is

ignored except for its class. If a class method is called for a derived class, the derived class object is passed

as the implied ﬁrst argument.

Class methods are different than C++ or Java static methods. If you want those, see staticmethod() in

this section.

For more information on class methods, consult the documentation on the standard type hierarchy in types.

compile(source, ﬁlename, mode, ﬂags=0, dont_inherit=False, optimize=-1)

Compile the source into a code or AST object. Code objects can be executed by exec() or eval().

source can either be a normal string, a byte string, or an AST object. Refer to the ast module documentation

for information on how to work with AST objects.

The ﬁlename argument should give the ﬁle from which the code was read; pass some recognizable value if

it wasn’t read from a ﬁle (’<string>’ is commonly used).

The mode argument speciﬁes what kind of code must be compiled; it can be ’exec’ if source consists of a

sequence of statements, ’eval’ if it consists of a single expression, or ’single’ if it consists of a single

interactive statement (in the latter case, expression statements that evaluate to something other than None

will be printed).

The optional arguments ﬂags and dont_inherit control which future statements (see PEP 236) affect the

compilation of source. If neither is present (or both are zero) the code is compiled with those future

statements that are in effect in the code that is calling compile(). If the ﬂags argument is given and

dont_inherit is not (or is zero) then the future statements speciﬁed by the ﬂags argument are used in addi-

tion to those that would be used anyway. If dont_inherit is a non-zero integer then the ﬂags argument is it –

the future statements in effect around the call to compile are ignored.

Future statements are speciﬁed by bits which can be bitwise ORed together to specify multiple statements.

The bitﬁeld required to specify a given feature can be found as the compiler_flag attribute on the

_Feature instance in the __future__ module.

The argument optimize speciﬁes the optimization level of the compiler; the default value of -1 selects

the optimization level of the interpreter as given by -O options. Explicit levels are 0 (no optimization;

__debug__ is true), 1 (asserts are removed, __debug__ is false) or 2 (docstrings are removed too).

This function raises SyntaxError if the compiled source is invalid, and ValueError if the source

contains null bytes.

If you want to parse Python code into its AST representation, see ast.parse().

Note: When compiling a string with multi-line code in ’single’ or ’eval’ mode, input must be

terminated by at least one newline character. This is to facilitate detection of incomplete and complete

statements in the code module.

Changed in version 3.2: Allowed use of Windows and Mac newlines. Also input in ’exec’ mode does not

have to end in a newline anymore. Added the optimize parameter.

Changed in version 3.5: Previously, TypeError was raised when null bytes were encountered in source.

class complex([real[, imag ]])

Return a complex number with the value real + imag*1j or convert a string or number to a complex number.

If the ﬁrst parameter is a string, it will be interpreted as a complex number and the function must be called

without a second parameter. The second parameter can never be a string. Each argument may be any

numeric type (including complex). If imag is omitted, it defaults to zero and the constructor serves as a

numeric conversion like int and float. If both arguments are omitted, returns 0j.

Note: When converting from a string, the string must not contain whitespace around the central + or -

operator. For example, complex(’1+2j’) is ﬁne, but complex(’1 + 2j’) raises ValueError.

The Python Library Reference, Release 3.5.2

The complex type is described in Numeric Types — int, ﬂoat, complex.

delattr(object, name)

This is a relative of setattr(). The arguments are an object and a string. The string must be the name

of one of the object’s attributes. The function deletes the named attribute, provided the object allows it. For

example, delattr(x, ’foobar’) is equivalent to del x.foobar.

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Create a new dictionary. The dict object is the dictionary class. See dict and Mapping Types — dict for

documentation about this class.

For other containers see the built-in list, set, and tuple classes, as well as the collections module.

dir([object ])

Without arguments, return the list of names in the current local scope. With an argument, attempt to return

a list of valid attributes for that object.

If the object has a method named __dir__(), this method will be called and must return the list of

attributes. This allows objects that implement a custom __getattr__() or __getattribute__()

function to customize the way dir() reports their attributes.

If the object does not provide __dir__(), the function tries its best to gather information from the object’s

__dict__ attribute, if deﬁned, and from its type object. The resulting list is not necessarily complete, and

may be inaccurate when the object has a custom __getattr__().

The default dir() mechanism behaves differently with different types of objects, as it attempts to produce

the most relevant, rather than complete, information:

•If the object is a module object, the list contains the names of the module’s attributes.

•If the object is a type or class object, the list contains the names of its attributes, and recursively of the

attributes of its bases.

•Otherwise, the list contains the object’s attributes’ names, the names of its class’s attributes, and re-

cursively of the attributes of its class’s base classes.

The resulting list is sorted alphabetically. For example:

>>> import struct

>>> dir() # show the names in the module namespace

['__builtins__', '__name__', 'struct']

>>> dir(struct) # show the names in the struct module

['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',

'__initializing__', '__loader__', '__name__', '__package__',

'_clearcache', 'calcsize', 'error', 'pack', 'pack_into',

'unpack', 'unpack_from']

>>> class Shape:

... def __dir__(self):

... return ['area', 'perimeter', 'location']

>>> s = Shape()

>>> dir(s)

['area', 'location', 'perimeter']

Note: Because dir() is supplied primarily as a convenience for use at an interactive prompt, it tries to

supply an interesting set of names more than it tries to supply a rigorously or consistently deﬁned set of

names, and its detailed behavior may change across releases. For example, metaclass attributes are not in

the result list when the argument is a class.

divmod(a, b)

Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient and

remainder when using integer division. With mixed operand types, the rules for binary arithmetic operators

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.5.2

apply. For integers, the result is the same as (a // b, a % b). For ﬂoating point numbers the result is

(q, a % b), where q is usually math.floor(a / b) but may be 1 less than that. In any case q

b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b)

< abs(b).

enumerate(iterable, start=0)

Return an enumerate object. iterable must be a sequence, an iterator, or some other object which supports

iteration. The __next__() method of the iterator returned by enumerate() returns a tuple containing

a count (from start which defaults to 0) and the values obtained from iterating over iterable.

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>> list(enumerate(seasons))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>> list(enumerate(seasons, start=1))

[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Equivalent to:

def enumerate(sequence, start=0):

n = start

for elem in sequence:

yield n, elem

n += 1

eval(expression, globals=None, locals=None)

The arguments are a string and optional globals and locals. If provided, globals must be a dictionary. If

provided, locals can be any mapping object.

The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition

list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is

present and lacks ‘__builtins__’, the current globals are copied into globals before expression is parsed.

This means that expression normally has full access to the standard builtins module and restricted

environments are propagated. If the locals dictionary is omitted it defaults to the globals dictionary. If both

dictionaries are omitted, the expression is executed in the environment where eval() is called. The return

value is the result of the evaluated expression. Syntax errors are reported as exceptions. Example:

>>> x = 1

>>> eval('x+1')

This function can also be used to execute arbitrary code objects (such as those created by compile()). In

this case pass a code object instead of a string. If the code object has been compiled with ’exec’ as the

mode argument, eval()‘s return value will be None.

Hints: dynamic execution of statements is supported by the exec() function. The globals() and

locals() functions returns the current global and local dictionary, respectively, which may be useful to

pass around for use by eval() or exec().

See ast.literal_eval() for a function that can safely evaluate strings with expressions containing

only literals.

exec(object[, globals[, locals ]])

This function supports dynamic execution of Python code. object must be either a string or a code object. If

it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error

occurs).

If it is a code object, it is simply executed. In all cases, the code that’s executed is expected to

be valid as ﬁle input (see the section “File input” in the Reference Manual). Be aware that the return and

yield statements may not be used outside of function deﬁnitions even within the context of code passed

to the exec() function. The return value is None.

Note that the parser only accepts the Unix-style end of line convention. If you are reading the code from a ﬁle, make sure to use newline

conversion mode to convert Windows or Mac-style newlines.

The Python Library Reference, Release 3.5.2

In all cases, if the optional parts are omitted, the code is executed in the current scope. If only globals is

provided, it must be a dictionary, which will be used for both the global and the local variables. If globals

and locals are given, they are used for the global and local variables, respectively. If provided, locals can

be any mapping object. Remember that at module level, globals and locals are the same dictionary. If exec

gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class

deﬁnition.

If the globals dictionary does not contain a value for the key __builtins__, a reference to the dictionary

of the built-in module builtins is inserted under that key. That way you can control what builtins

are available to the executed code by inserting your own __builtins__ dictionary into globals before

passing it to exec().

Note: The built-in functions globals() and locals() return the current global and local dictionary,

respectively, which may be useful to pass around for use as the second and third argument to exec().

Note: The default locals act as described for function locals() below: modiﬁcations to the default

locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the

code on locals after function exec() returns.

filter(function, iterable)

Construct an iterator from those elements of iterable for which function returns true. iterable may be either

a sequence, a container which supports iteration, or an iterator. If function is None, the identity function is

assumed, that is, all elements of iterable that are false are removed.

Note that filter(function, iterable) is equivalent to the generator expression (item for

item in iterable if function(item)) if function is not None and (item for item in

iterable if item) if function is None.

See itertools.filterfalse() for the complementary function that returns elements of iterable for

which function returns false.

class float([x ])

Return a ﬂoating point number constructed from a number or string x.

If the argument is a string, it should contain a decimal number, optionally preceded by a sign, and option-

ally embedded in whitespace. The optional sign may be ’+’ or ’-’; a ’+’ sign has no effect on the value

produced. The argument may also be a string representing a NaN (not-a-number), or a positive or nega-

tive inﬁnity. More precisely, the input must conform to the following grammar after leading and trailing

whitespace characters are removed:

sign ::= “+” | “-“

infinity ::= “Infinity” | “inf”

nan ::= “nan”

numeric_value ::= floatnumber | infinity | nan

numeric_string ::= [sign] numeric_value

Here floatnumber is the form of a Python ﬂoating-point literal, described in ﬂoating. Case is not sig-

niﬁcant, so, for example, “inf”, “Inf”, “INFINITY” and “iNfINity” are all acceptable spellings for positive

inﬁnity.

Otherwise, if the argument is an integer or a ﬂoating point number, a ﬂoating point number with the same

value (within Python’s ﬂoating point precision) is returned. If the argument is outside the range of a Python

ﬂoat, an OverflowError will be raised.

For a general Python object x, float(x) delegates to x.__float__().

If no argument is given, 0.0 is returned.

Examples:

>>> float('+1.23')

10 Chapter 2. Built-in Functions

剩余1744页未读，继续阅读

Hu_Bobby

粉丝: 0
资源: 4

Python 3.5.2官方文档：全面指南与内置类型详解

Windows7的资源管理革命：Library功能解析

压缩文件 library.zip 的核心内容解析

Spire.PDF.DLL可用版压缩包介绍

CUBLAS_Library.pdf

Intel MKL Library.PDF

the boost graph library.pdf

pMatlab Parallel Matlab Library.pdf

The C++ Standard Library.pdf

C28x IQmath Library.pdf 带书签

如何使用GD的Firmware_Library.pdf

最新资源