Python 3.5.1 库参考指南

python3.5.1

需积分: 12 178 浏览量更新于2024-07-19 1 收藏 6.08MB PDF 举报

"《Python Library Reference》是Python 3.5.1版本的官方文档，由Guido van Rossum和Python开发团队编写，发布于2016年2月24日，是深入学习Python编程的进阶参考资料，特别适合已经掌握了Python基础的读者作为进一步提升的读物。这本书详细介绍了Python的内置函数、常量、类型、异常以及文本处理服务等核心内容。" 这篇文档主要涵盖了以下几个方面： 1. **介绍**：这部分可能包含对Python编程语言的概述，解释了该参考手册的目的和使用方法，可能还会提到Python 3.5.1版本的一些新特性或改进。 2. **内置函数**：这部分详细列举并解释了Python标准库中的所有内置函数，如`len()`, `print()`, `type()`等，是理解和使用Python功能的关键。 3. **内置常量**：这部分列出由`sitemodule`添加的常量，这些常量在Python环境中具有特殊意义，比如`None`, `True`, `False`等。 4. **内置类型**：详述了Python支持的各种数据类型，包括： - **真值测试**：讨论了如何判断一个对象在布尔上下文中的真假值。 - **逻辑运算**：解释了`and`, `or`, `not`三个逻辑运算符的工作方式。 - **比较操作**：涵盖了不同类型的比较操作，如相等性、不等性和排序比较。 - **数值类型**：如整型（`int`）、浮点型（`float`）和复数（`complex`）的使用和特性。 - **迭代器类型**：阐述了迭代器的概念和工作原理。 - **序列类型**：包括列表（`list`）、元组（`tuple`）和范围（`range`），以及它们的使用方法。 - **文本序列类型**：详细介绍了字符串（`str`）的处理和操作。 - **二进制序列类型**：如字节（`bytes`）、字节数组（`bytearray`）和内存视图（`memoryview`）。 - **集合类型**：如可变集合（`set`）和不可变集合（`frozenset`）。 - **映射类型**：主要讲解字典（`dict`）的用法。 - **上下文管理器类型**：涉及Python中的`with`语句和上下文管理协议。 - **其他内置类型**：包含其他的内置数据结构或对象。 - **特殊属性**：讨论了一些特定对象的属性，如`__name__`, `__doc__`等。 5. **内置异常**：这部分列出了Python中的所有内置异常类，包括基类、具体异常类型和警告，以及异常层次结构，帮助开发者理解错误处理和异常处理机制。 6. **文本处理服务**：涵盖了一系列用于文本处理的模块，如： - **string模块**：提供了对字符串操作的通用工具。 - **re模块**：支持正则表达式操作，用于模式匹配和字符串搜索替换。 - **difflib模块**：用于计算和展示文本差异，常见于代码或文本的比较。 - **textwrap模块**：提供文本自动换行和填充功能，使输出更美观。 - **un模块**：可能涉及到Unicode相关的操作和转换。这份文档对于任何想要深入理解Python 3.5.1版本的开发者来说，都是一份不可或缺的参考资料，它可以帮助读者掌握Python的核心概念，提高编程技巧，并解决实际问题。

The Python Library Reference, Release 3.5.1

ascii(object)

As repr(), return a string containing a printable representation of an object, but escape the non-ASCII char-

acters in the string returned by repr() using \x, \u or \U escapes. This generates a string similar to that

returned by repr() in Python 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 Operations.

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(957) returns the string ’𝜈’. 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.

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.5.1

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 instance.

To declare a class method, use this idiom:

class C:

@classmethod

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

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 compi-

lation 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 addition 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.

The Python Library Reference, Release 3.5.1

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 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 cus-

tomize 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 recursively

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__',

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.5.1

'__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

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

The Python Library Reference, Release 3.5.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.

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.

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.

10 Chapter 2. Built-in Functions

剩余1830页未读，继续阅读

matlon

粉丝: 0
资源: 5

Python 3.5.1 库参考指南

The Python Library Reference Release 3.0

Python学习三部曲之二：library Reference_3.4.4

Python for Windows v3.5.1 官方版.rar

Python库 ecoledirect-3.5.1最新版本发布

Python环境下Protobuf 3.5.1离线安装指南

探索Python库aiohttp-3.5.1的强大功能与应用

Python 入门指南3.5.1 中文

python-3.5.1

pythonwin-64-3.5.1版本

Python3.5.1Windows

最新资源