Python标准库参考手册

需积分: 9 155 浏览量更新于2024-07-28 收藏 3.76MB PDF 举报

"Python库参考手册，版本2.5，由Guido van Rossum编写，Fred L. Drake, Jr.编辑，2006年9月19日发布，由Python Software Foundation出版。该手册详细介绍了Python的标准库，包含版权信息，并提供了完整的许可和权限信息。" Python是一种高级的、可扩展的、解释型、面向对象的编程语言，适用于各种应用，从小规模的文本处理脚本到复杂的交互式Web浏览器。Python的特点之一是其强大的标准库，它与语言本身一样重要。 Python参考手册主要关注语言的语法和语义，而Python库参考手册则专注于随语言一起分发的标准库。这个库包含了内置模块，这些模块用C语言编写，使得Python程序员能够访问如文件I/O等系统功能，否则这些功能将难以在Python中实现。此外，库还包含许多用Python编写的模块，它们提供了广泛的用途，如网络通信、操作系统接口、数据结构、图形系统、数学计算、加密、单元测试等。例如，`sys`模块提供与Python解释器和它的环境进行交互的接口；`os`模块提供了许多与操作系统交互的函数，如创建、删除和改变目录，以及读写文件；`socket`模块则支持网络通信，允许创建套接字进行TCP/IP或UDP通信；`math`模块提供了大量的数学函数，如三角函数、指数、对数等；`numpy`和`pandas`用于数值计算和数据分析，是科学计算的重要工具；`requests`模块则方便了HTTP请求的发送，是Web开发中的常用库。标准库还包含一些用于处理字符串、列表、字典等基本数据结构的模块，如`re`模块用于正则表达式操作，`itertools`提供了高效的迭代器工具，`collections`模块提供了更复杂的数据结构，如有序字典。对于错误和异常处理，`traceback`模块可以帮助调试代码，而`logging`模块则提供了日志记录功能。 Python库的另一个关键部分是`unittest`模块，它是Python的内置单元测试框架，用于确保代码的质量和稳定性。还有像`doctest`这样的模块，可以检查文档字符串中的代码片段是否正确执行，促进了文档和测试的一体化。 Python库参考手册是Python程序员不可或缺的资源，它详细列出了Python生态系统中丰富的模块和功能，使得Python能够适应各种需求，无论是在系统管理、科学计算、网络编程还是数据分析等领域。通过深入理解和熟练运用这些库，开发者可以大大提高生产力，编写出高效、可靠的Python程序。

level speciﬁes whether to use absolute or relative imports. The default is -1 which indicates both absolute

and relative imports will be attempted. 0 means only perform absolute imports. Positive values for level

indicate the number of parent directories to search relative to the directory of the module calling __-

import__. Changed in version 2.5: The level parameter was added. Changed in version 2.5: Keyword

support for parameters was added.

abs(x)

Return the absolute value of a number. The argument may be a plain or long integer or a ﬂoating point

number. If the argument is a complex number, its magnitude is returned.

all(iterable)

Return True if all elements of the iterable are true. Equivalent to:

def all(iterable):

for element in iterable:

if not element:

return False

return True

New in version 2.5.

any(iterable)

Return True if any element of the iterable is true. Equivalent to:

def any(iterable):

for element in iterable:

if element:

return True

return False

New in version 2.5.

basestring()

This abstract type is the superclass for str and unicode. It cannot be called or instantiated, but it can be

used to test whether an object is an instance of str or unicode. isinstance(obj, basestring)

is equivalent to isinstance(obj, (str, unicode)). New in version 2.3.

bool([x ])

Convert a value to a Boolean, using the standard truth testing procedure. If x is false or omitted, this returns

False; otherwise it returns True. bool is also a class, which is a subclass of int. Class bool cannot

be subclassed further. Its only instances are False and True.

New in version 2.2.1. Changed in version 2.3: If no argument is given, this function returns False.

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); class instances are callable if they have a __call__() method.

chr(i)

Return a string of one character whose ASCII code is the integer i. For example, chr(97) returns the string

’a’. This is the inverse of ord(). The argument must be in the range [0..255], inclusive; 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, ...): ...

4 Chapter 2. Built-in Objects

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

of the Python Reference Manual 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 chapter

3 of the Python Reference Manual (at the bottom). New in version 2.2. Changed in version 2.4: Function

decorator syntax added.

cmp(x, y)

Compare the two objects x and y and return an integer according to the outcome. The return value is negative

if x < y, zero if x == y and strictly positive if x > y.

compile(string, ﬁlename, kind[, ﬂags[, dont inherit ]])

Compile the string into a code object. Code objects can be executed by an exec statement or evaluated by

a call to eval(). 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 kind argument spec-

iﬁes what kind of code must be compiled; it can be ’exec’ if string 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 else than None will be printed).

When compiling multi-line statements, two caveats apply: line endings must be represented by a single

newline character (’\n’), and the input must be terminated by at least one newline character. If line

endings are represented by ’\r\n’, use the string replace() method to change them into ’\n’.

The optional arguments ﬂags and dont inherit (which are new in Python 2.2) control which future statements

(see PEP 236) affect the compilation of string. 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 or-ed 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.

complex([real[, imag ]])

Create a complex number with the value real + imag*j 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 function serves as a

numeric conversion function like int(), long() and float(). If both arguments are omitted, returns

0j.

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.

dict([mapping-or-sequence ])

Return a new dictionary initialized from an optional positional argument or from a set of keyword argu-

ments. If no arguments are given, return a new empty dictionary. If the positional argument is a mapping

object, return a dictionary mapping the same keys to the same values as does the mapping object. Otherwise

the positional argument must be a sequence, a container that supports iteration, or an iterator object. The

elements of the argument must each also be of one of those kinds, and each must in turn contain exactly two

objects. The ﬁrst is used as a key in the new dictionary, and the second as the key’s value. If a given key is

seen more than once, the last value associated with it is retained in the new dictionary.

If keyword arguments are given, the keywords themselves with their associated values are added as items

to the dictionary. If a key is speciﬁed both in the positional argument and as a keyword argument, the value

2.1. Built-in Functions 5

associated with the keyword is retained in the dictionary. For example, these all return a dictionary equal to

{"one": 2, "two": 3}:



dict({’one’: 2, ’two’: 3})



dict({’one’: 2, ’two’: 3}.items())



dict({’one’: 2, ’two’: 3}.iteritems())



dict(zip((’one’, ’two’), (2, 3)))



dict([[’two’, 3], [’one’, 2]])



dict(one=2, two=3)



dict([([’one’, ’two’][i-2], i) for i in (2, 3)])

New in version 2.2. Changed in version 2.3: Support for building a dictionary from keyword arguments

added.

dir([object ])

Without arguments, return the list of names in the current local symbol table. With an argument, attempts

to return a list of valid attributes for that object. This information is gleaned from the object’s __dict__-

attribute, if deﬁned, and from the class or type object. The list is not necessarily complete. 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()

[’__builtins__’, ’__doc__’, ’__name__’, ’struct’]

>>> dir(struct)

[’__doc__’, ’__name__’, ’calcsize’, ’error’, ’pack’, ’unpack’]

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.

divmod(a, b)

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

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

apply. For plain and long 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).

Changed in version 2.3: Using divmod() with complex numbers is deprecated.

enumerate(iterable)

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 zero) and the corresponding value obtained from iterating over iterable. enumerate() is

useful for obtaining an indexed series: (0, seq[0]), (1, seq[1]), (2, seq[2]), . . . . New in

version 2.3.

eval(expression[, globals[, locals ]])

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. Changed in version 2.4: formerly locals was required to be a

dictionary.

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

__builtin__ module and restricted

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

6 Chapter 2. Built-in Objects

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

>>> print 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. The code object must have been compiled passing ’eval’

as the kind argument.

Hints: dynamic execution of statements is supported by the exec statement. Execution of statements from

a ﬁle is supported by the execfile() 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

execfile().

execfile(ﬁlename[, globals[, locals ]])

This function is similar to the exec statement, but parses a ﬁle instead of a string. It is different from the

import statement in that it does not use the module administration — it reads the ﬁle unconditionally and

does not create a new module.

The arguments are a ﬁle name and two optional dictionaries. The ﬁle is parsed and evaluated as a sequence

of Python statements (similarly to a module) using the globals and locals dictionaries as global and local

namespace. If provided, locals can be any mapping object. Changed in version 2.4: formerly locals was

required to be a dictionary. 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 execfile() is called. The

return value is None.

Warning: 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 execfile() returns. execfile() cannot be used reliably to modify

a function’s locals.

file(ﬁlename[, mode[, bufsize ]])

Constructor function for the file type, described further in section 3.9, “

File Objects”. The constructor’s

arguments are the same as those of the open() built-in function described below.

When opening a ﬁle, it’s preferable to use open() instead of invoking this constructor directly. file is

more suited to type testing (for example, writing ‘isinstance(f, file)’).

New in version 2.2.

filter(function, list)

Construct a list from those elements of list for which function returns true. list may be either a sequence,

a container which supports iteration, or an iterator, If list is a string or a tuple, the result also has that type;

otherwise it is always a list. If function is None, the identity function is assumed, that is, all elements of list

that are false are removed.

Note that filter(function, list) is equivalent to [item for item in list if

function(item)] if function is not None and [item for item in list if item] if

function is None.

float([x ])

Convert a string or a number to ﬂoating point. If the argument is a string, it must contain a possibly signed

decimal or ﬂoating point number, possibly embedded in whitespace. Otherwise, the argument may be a

plain or long integer or a ﬂoating point number, and a ﬂoating point number with the same value (within

Python’s ﬂoating point precision) is returned. If no argument is given, returns 0.0.

Note: When passing in a string, values for NaN and Inﬁnity may be returned, depending on the underlying

C library. The speciﬁc set of strings accepted which cause these values to be returned depends entirely on

the C library and is known to vary.

frozenset([iterable ])

Return a frozenset object whose elements are taken from iterable. Frozensets are sets that have no up-

date methods but can be hashed and used as members of other sets or as dictionary keys. The elements

It is used relatively rarely so does not warrant being made into a statement.

2.1. Built-in Functions 7

of a frozenset must be immutable themselves. To represent sets of sets, the inner sets should also be

frozenset objects. If iterable is not speciﬁed, returns a new empty set, frozenset([]). New

in version 2.4.

getattr(object, name[, default ])

Return the value of the named attributed of object. name must be a string. If the string is the name of one

of the object’s attributes, the result is the value of that attribute. For example, getattr(x, ’foobar’)

is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise

AttributeError is raised.

globals()

Return a dictionary representing the current global symbol table. This is always the dictionary of the current

module (inside a function or method, this is the module where it is deﬁned, not the module from which it is

called).

hasattr(object, name)

The arguments are an object and a string. The result is True if the string is the name of one of the object’s

attributes, False if not. (This is implemented by calling getattr(object, name) and seeing whether

it raises an exception or not.)

hash(object)

Return the hash value of the object (if it has one). Hash values are integers. They are used to quickly

compare dictionary keys during a dictionary lookup. Numeric values that compare equal have the same

hash value (even if they are of different types, as is the case for 1 and 1.0).

help([object ])

Invoke the built-in help system. (This function is intended for interactive use.) If no argument is given, the

interactive help system starts on the interpreter console. If the argument is a string, then the string is looked

up as the name of a module, function, class, method, keyword, or documentation topic, and a help page is

printed on the console. If the argument is any other kind of object, a help page on the object is generated.

New in version 2.2.

hex(x)

Convert an integer number (of any size) to a hexadecimal string. The result is a valid Python expression.

Changed in version 2.4: Formerly only returned an unsigned literal.

id(object)

Return the “identity” of an object. This is an integer (or long integer) which is guaranteed to be unique and

constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same

id() value. (Implementation note: this is the address of the object.)

input([prompt ])

Equivalent to eval(raw_input(prompt)). Warning: This function is not safe from user errors! It

expects a valid Python expression as input; if the input is not syntactically valid, a SyntaxError will be

raised. Other exceptions may be raised if there is an error during evaluation. (On the other hand, sometimes

this is exactly what you need when writing a quick script for expert use.)

If the readline module was loaded, then input() will use it to provide elaborate line editing and

history features.

Consider using the raw_input() function for general input from users.

int([x[, radix ]])

Convert a string or number to a plain integer. If the argument is a string, it must contain a possibly signed

decimal number representable as a Python integer, possibly embedded in whitespace. The radix parameter

gives the base for the conversion and may be any integer in the range [2, 36], or zero. If radix is zero, the

proper radix is guessed based on the contents of string; the interpretation is the same as for integer literals.

If radix is speciﬁed and x is not a string, TypeError is raised. Otherwise, the argument may be a plain or

long integer or a ﬂoating point number. Conversion of ﬂoating point numbers to integers truncates (towards

zero). If the argument is outside the integer range a long object will be returned instead. If no arguments

are given, returns 0.

isinstance(object, classinfo)

Return true if the object argument is an instance of the classinfo argument, or of a (direct or indirect)

subclass thereof. Also return true if classinfo is a type object and object is an object of that type. If object

8 Chapter 2. Built-in Objects

剩余985页未读，继续阅读

happyran89

粉丝: 1
资源: 9

Python标准库参考手册

Python库参考手册

Python库参考手册.pdf

Python 库参考手册

Python库参考手册中文版

Python库参考手册2.3.3版

Python库参考手册：2.3.3版

Python库参考手册：全面解析

Python库参考手册：权威指南

Pytorch版代码幻灯片.zip

Jupyter_Chat甄嬛是利用甄嬛传剧本中所有关于甄嬛的台词和语句基于ChatGLM2进行LoRA微调得到的模仿甄.zip

最新资源