Python3.6标准库详解：内置函数与模块

需积分: 30 48 浏览量更新于2024-07-18 收藏 7.71MB PDF 举报

"Python3.6标准库包含了通常被认为是语言核心的部分，如数字和列表等数据类型。Python语言核心定义了字面量的形式，并对它们的语义施加了一些限制，但并未完全定义语义。库还包含内置函数和异常，这些在所有Python代码中无需导入语句即可使用。一部分由核心语言定义，但许多不是核心语义所必需的，仅在这里描述。大部分库由一系列模块组成，这些模块可以根据多种方式进行划分。有些模块是用C编写的并内置到Python解释器中，有些是用Python编写的并以源码形式导入。这些模块提供了从打印堆栈跟踪到特定硬件访问，再到特定应用领域（如万维网）的各种接口。某些模块在所有Python版本和移植中都可用，而其他模块则只在底层系统支持或需要时才可用，还有一些仅在Python编译和安装时选择了特定配置选项时可用。该手册按“从内到外”的方式组织：首先描述内置函数、数据类型和异常，最后是按相关模块章节分组的模块。如果你从手册开头读起，当对某个主题感到厌倦时跳到下一章，你会得到Python库提供的模块和应用领域的合理概述。当然，你也可以浏览目录，或者在索引中查找特定的函数、模块或术语。此外，如果你想随机学习，可以选一个随机页码阅读一两个部分。无论你按照何种顺序阅读手册的各个部分，从《内置函数》章节开始会有所帮助，因为手册的其余部分假设你熟悉这部分内容。" 此文档是Python 3.6.4版本的Python标准库参考指南，由Guido van Rossum和Python开发团队编写。文档内容涵盖广泛，包括以下几个主要部分： 1. 引言：介绍Python标准库的基本信息。 2. 内置函数：详述Python中的基本函数，如print()、len()等。 3. 内置常量：列出由site模块添加的常量。 4. 内置类型：详细说明各种内置数据类型，如布尔型、整型、浮点型、复数、迭代器、序列类型（列表、元组、范围）、文本序列类型（字符串）、二进制序列类型（字节、字节数组、内存视图）、集合类型（集合、冻结集）、映射类型（字典）和上下文管理器类型。 5. 内置异常：列出所有基础异常类以及具体异常，还包括警告和异常层次结构。 6. 文本处理服务：介绍处理文本的模块，如字符串操作、正则表达式、差异计算、文本包装和填充以及Unicode数据。该文档是Python程序员的重要参考资料，提供对Python核心功能和库的深入理解，帮助开发者更好地利用Python进行编程。通过阅读，用户可以了解Python语言的基础和高级特性，以及如何使用各种模块来实现特定的功能。

The Python Library Reference, Release 3.6.4

ascii(object)

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

characters 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 preﬁxed with “0b”. 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. Some examples:

>>> bin(3)

'0b11'

>>> bin(-10)

'-0b1010'

If preﬁx “0b” is desired or not, you can use either of the following ways.

>>> format(14, '#b'), format(14, 'b')

('0b1110', '1110')

>>> f'{14:#b}', f'{14:b}'

('0b1110', '1110')

See also format() for more information.

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 diﬀerent 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 buﬀer interface, a read-only buﬀer 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.

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.6.4

See also Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects, and Bytes and Bytear-

ray 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(8364) 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.

@classmethod

Transform a method into a class method.

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 diﬀerent 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) aﬀect

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

statements that are in eﬀect 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 eﬀect around the call to compile are ignored.

The Python Library Reference, Release 3.6.4

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

ments. 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 complex type is described in Numeric Types — int, ﬂoat, complex.

Changed in version 3.6: Grouping digits with underscores as in code literals is allowed.

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.

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.6.4

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 diﬀerently with diﬀerent 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__',

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

The Python Library Reference, Release 3.6.4

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

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

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,

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

剩余1929页未读，继续阅读

weixin_36211687

粉丝: 0
资源: 1

Python3.6标准库详解：内置函数与模块

Python Standard Library

Python 标准库Library.zip

Python Library-Rammbock

Python库参考手册(Python Library Reference).zip

the python library of fetool

怎么安装新的Python library

Bredalis/Flask Python library to work with Python on the Back

The Python Library Reference(Release 3.5.1)

Python library for processing Chinese text.zip

Python library for interacting with FreeIPA network protocols

最新资源