Python 3.7.3rc1 标准库详览：内置函数与类型

Python

需积分: 15 151 浏览量更新于2024-07-17 收藏 8.14MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

本资源是关于Python 3.7.3rc1版本的Library标准库参考手册，由Guido van Rossum和Python开发团队共同编写，发布于2019年3月23日，由Python Software Foundation维护。这份文档详细介绍了Python语言随其发行版附带的一系列核心库，旨在为程序员提供丰富的工具和标准化解决方案，以支持日常编程工作。 Python的标准库非常庞大且功能多样，包括内置函数、常量、类型、异常处理、文本处理服务等多个部分。以下是部分内容概要： 1. **内置函数**：这部分列举了一系列Python内建的函数，如数学运算、逻辑测试、比较操作等，这些都是日常编程中不可或缺的基础工具。 2. **内置常量**：文档列出了由site模块新增的一些常量，这些常量用于配置Python环境或执行特定任务。 3. **内置类型**：涵盖了布尔类型（and, or, not）、数值类型（整型、浮点型、复数）、迭代器、序列类型（列表、元组、范围）、字符串类型（str）、二进制序列类型（bytes、bytearray、memoryview）以及集合和映射类型（set、frozenset、dict）等，强调了Python在数据结构上的丰富性和灵活性。 4. **Context Manager Types**：解释了上下文管理器的作用，这是一种特殊类型的对象，用于确保在使用后自动释放资源，例如文件或网络连接。 5. **异常处理**：这部分详细描述了Python的异常体系结构，包括基础类、具体异常和警告，以及异常处理的层次结构，帮助开发者编写健壮的错误处理代码。 6. **文本处理服务**：涵盖了string模块，提供字符串操作；re模块，用于正则表达式匹配；difflib模块，用于计算文本差异；以及textwrap模块，用于文本格式化，方便阅读。通过这份标准库文档，Python开发者可以深入了解如何利用这些内置工具进行高效的编程，提升代码的可读性、可移植性和性能。同时，了解和掌握这些库对于编写高质量的Python应用程序至关重要。

资源详情

资源推荐

The Python Library Reference, Release 3.7.3rc1

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

Changed in version 3.7: x is now a positional-only parameter.

breakpoint(*args, **kws)

This function drops you into the debugger at the call site. Specically, it calls sys.breakpointhook(),

passing args and kws straight through. By default, sys.breakpointhook() calls pdb.set_trace()

expecting no arguments. In this case, it is purely a convenience function so you don’t have to explicitly

import pdb or type as much code to enter the debugger. However, sys.breakpointhook() can be set

to some other function and breakpoint() will automatically call that, allowing you to drop into the

debugger of choice.

New in version 3.7.

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.

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.7.3rc1

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 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 Python Library Reference, Release 3.7.3rc1

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

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.

Warning: It is possible to crash the Python interpreter with a suciently large/complex string

when compiling to an AST object due to stack depth limitations in Python’s AST compiler.

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

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 3.7.3rc1

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 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 # doctest: +SKIP

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

>>> dir(struct) # show the names in the struct module # doctest: +SKIP

['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.

The Python Library Reference, Release 3.7.3rc1

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

10 Chapter 2. Built-in Functions

剩余2088页未读，继续阅读

weixin_44285588

粉丝: 0
资源: 4

Python 3.7.3rc1 标准库详览：内置函数与类型

Python3.7.2中文文档-标准库-合集

python3.7.3

Python 3.7.3rc1 中文官方文档

python-3.7.3-amd64.exe

python-3.7.3.exe下载

树莓派4b安装librosa，其中python为3.7.3

matplotlib-3.7.3-cp38-cp38-win32.whl

ubuntu20.04安装python3.7.3

青龙面板安装依赖显示失败

linux删除python环境

python3.7.3(32-bit)

配置python3.7.3

linux 安装python pip

conda create python3.7.3

Python运行的版本号

python3.7.3安装selenium2library_selenium2library倒入时候报错

树莓派4b安装python3.7.1

conda create -n tf2.3 python==3.7.3

python3.7.3的PIL库

Python3.7.3输出素数

最新资源