Python 2.7.11 Library Reference：必备指南

python2.7.11

需积分: 9 176 浏览量更新于2024-07-21 收藏 5.03MB PDF 举报

在Python学习的进阶阶段，深入理解Python Library Reference（2.7.11版）是至关重要的。此文档由Guido van Rossum和Python开发团队编写，于2016年1月发布，由Python Software Foundation发行，是每个Python程序员必备的参考书籍，与《Learning Python》和《Python Cookbook》并列为学习的三大基石。文档内容涵盖多个核心主题，包括： 1. **Introduction**：这部分介绍了库参考手册的总体结构和目的，帮助读者了解如何有效利用它进行编程实践。 2. **Built-in Functions**：涵盖了Python内建的函数，如常用的数学运算、字符串处理等，这些函数是程序设计的基础，对提高代码效率至关重要。 3. **Non-essential Built-in Functions**：这部分列举了一些非必需但实用的内建函数，帮助用户扩展功能或优化解决方案。 4. **Built-in Constants**：介绍了Python中的常量，如True和False、特殊数值等，以及由site模块添加的一些新常量。 5. **Built-in Types**：详细解释了Python的各种内置数据类型，如整型、浮点型、布尔型、序列（如字符串、列表、元组）、集合、映射（字典）、文件对象、内存视图等，以及它们的特性和用法。 6. **Built-in Exceptions**：讲解了Python的异常处理体系，包括异常的层次结构，如何捕获和处理不同类型的错误。 7. **String Services**：这一章节着重于字符串操作，包括string模块提供的常用操作，正则表达式处理（re模块），以及结构化数据解析（struct模块）和文本差异计算（difflib模块）。 8. **StringIO**：介绍了StringIO模块，用于以文件方式读写字符串，这对于处理字符串流很有用。通过深入学习这些部分，Python开发者可以熟练掌握语言的核心机制和标准库的使用，从而编写出更高效、更灵活的代码。随着Python版本的更新，部分章节可能已过时，但对于理解早期版本（如2.7.11）的Python编程依然具有参考价值。因此，这份文档不仅适合初级学习者提升基础，也适合有一定经验的开发者查阅特定功能的实现细节。

The Python Library Reference, Release 2.7.11

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.

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.

New in version 2.6.

class bool([x ])

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

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

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 str type has, see String Methods.

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

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

then converts the unicode to bytes using unicode.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.

New in version 2.6.

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. See also unichr().

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(object):

@classmethod

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

...

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 2.7.11

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.

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(source, ﬁlename, mode[, ﬂags[, dont_inherit ]])

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

evaluated by a call to eval(). source can either be a Unicode string, a Latin-1 encoded 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.

This function raises SyntaxError if the compiled source is invalid, and TypeError if the source con-

tains 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 2.3: The ﬂags and dont_inherit arguments were added.

Changed in version 2.6: Support for compiling AST objects.

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

have to end in a newline anymore.

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 function serves as a

The Python Library Reference, Release 2.7.11

numeric conversion function like int(), long() 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, long, 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__', '__doc__', '__name__', 'struct']

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

['Struct', '__builtins__', '__doc__', '__file__', '__name__',

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

'unpack', 'unpack_from']

>>> class Shape(object):

def __dir__(self):

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

>>> s = Shape()

>>> dir(s)

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

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

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 2.7.11

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 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(sequence, start=0)

Return an enumerate object. sequence 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 sequence:

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

New in version 2.3.

Changed in version 2.6: The start parameter was added.

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

The arguments are a Unicode or Latin-1 encoded 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 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 __builtin__ 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

>>> 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. 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 statement. Execution of statements from

a ﬁle is supported by the execfile() function. The globals() and locals() functions returns the

The Python Library Reference, Release 2.7.11

current global and local dictionary, respectively, which may be useful to pass around for use by eval() or

execfile().

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

only literals.

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. Remember that at module level, globals and

locals are the same dictionary. If two separate objects are passed as globals and locals, the code will be

executed as if it were embedded in a class deﬁnition.

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.

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

a function’s locals.

file(name[, mode[, buffering ]])

Constructor function for the file type, described further in section File Objects. The constructor’s argu-

ments 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, iterable)

Construct a list 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 iterable 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 iterable that are false are removed.

Note that filter(function, iterable) is equivalent to [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.ifilter() and itertools.ifilterfalse() for iterator versions of this func-

tion, including a variation that ﬁlters for elements where the 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 must contain a possibly signed decimal or ﬂoating point number, possibly

embedded in whitespace. The argument may also be [+|-]nan or [+|-]inf. 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. Float accepts the strings nan, inf and -inf for NaN and positive or negative inﬁnity. The case and

a leading + are ignored as well as a leading - is ignored for NaN. Float always represents NaN and inﬁnity

as nan, inf or -inf.

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

10 Chapter 2. Built-in Functions

剩余1429页未读，继续阅读

abel_qy

粉丝: 10
资源: 8

Python 2.7.11 Library Reference：必备指南

python下载

Python 标准库Library.zip

Python Library-Rammbock

PackagesNotFoundError: The following packages are not available from current channels: - python=2.7.11

miwifi_r1cm_firmware_b9d56_2.7.11.bin

CXF-demo.zip_cxf_cxf 2.7.11 demo_cxf demo_cxf webservice demo_we

Python2.7.11安装包

python2.7.11 documentation

python2.7.11参考文档

Python-2.7.11.tgz

最新资源