Python 2.6官方库函数详解与类型参考

5星 · 超过95%的资源需积分: 31 185 浏览量更新于2024-07-26 3 收藏 7.93MB PDF 举报

本Python库函数参考手册详细介绍了Python 2.6版本的内置功能、非必需内置函数、常量、对象、类型以及其特性。以下是部分内容的详细解读： 1. **介绍**：这部分首先概述了Python语言的基本概念和使用环境，由Guido van Rossum创建，Fred L. Drake Jr.任编辑，发布于2008年10月2日，由Python Software Foundation提供。文档提供了联系信息，以便用户获取更多支持和反馈。 2. **内置函数**： Python的核心库包含了大量预定义的函数，如数学运算、数据处理等。这部分列举了核心且常用的内置函数，方便开发者快速查找和调用。 3. **非必需内置函数**：包括一些虽然实用但可能不经常使用的函数，它们在特定场景下可以提高开发效率。 4. **内置常量**：文档详细列出了Python标准库中新增的常量，这些常量在编程中作为标识符或预设值使用。 5. **内置对象**：介绍Python中的基本对象类型，如整数、浮点数、字符串、列表、元组、字典等，以及它们的特性和用法。 6. **内置类型**： - **Truth Value Testing**：如何判断一个对象是否为真（如非零数值、非空字符串等）。 - **Boolean Operations**：Python中的逻辑运算符`and`, `or`, `not`的用法。 - **Comparisons**：比较操作符如`<`, `>`, `==`的使用方法。 - **Numeric Types**：解释了整数、浮点数、长整型和复数类型。 - **Iterator Types**：迭代器的原理和使用方法。 - **Sequence Types**：字符串、Unicode、列表、元组和缓冲区等序列类型的特性。 - **Set Types**：集合和冻结集合的数据结构和操作。 - **Mapping Types**：字典类型的详细描述和操作。 - **File Objects**：文件操作的接口和注意事项。 - **Context Manager Types**：上下文管理器的使用，用于处理资源的自动清理。 7. **内置异常**：提供了Python中常见的内置异常及其处理方法，帮助开发者编写健壮的代码。 8. **String Services**： - `string`模块提供了一组常用的字符串处理函数，如字符转换、编码等。 - `re`模块是正则表达式操作工具，支持复杂的文本匹配和替换。 - `struct`模块用于解析和构建字符串的二进制数据。 - `difflib`模块用于计算字符串之间的差异。 - `StringIO`和`cStringIO`是用于读写字符串的模拟文件类，提供高效的操作。通过这份Python库函数参考手册，开发者能够深入了解Python语言的核心组件，提升编程技能，更好地利用Python进行各种任务的实现。

The Python Library Reference, Release 2.6

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

@classmethod

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

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

deﬁnitions (in The Python Language Reference) 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 The

standard type hierarchy (in The Python Language Reference). New in version 2.2.Changed in version 2.4:

Function decorator syntax added.

6 Chapter 2. Built-in Functions

The Python Library Reference, Release 2.6

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 string or an AST object. Refer to the _ast module

documentation for information on how to compile into and from AST objects.

When compiling a string with 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 ﬁ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 else than None

will be printed).

The optional arguments ﬂags and dont_inherit (which are new in Python 2.2) control which future state-

ments (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 argu-

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

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

tains null bytes. New in version 2.6: Support for compiling AST objects.

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.

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.

dict([arg])

Create a new data dictionary, optionally with items taken from arg. The dictionary type is described in

Mapping Types — dict.

For other containers see the built in list, set, and tuple classes, and 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 Python Library Reference, Release 2.6

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

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

>>> dir(struct) # doctest: +NORMALIZE_WHITESPACE

[’Struct’, ’__builtins__’, ’__doc__’, ’__file__’, ’__name__’,

’__package__’, ’_clearcache’, ’calcsize’, ’error’, ’pack’, ’pack_into’,

’unpack’, ’unpack_from’]

>>> class Foo(object):

... def __dir__(self):

... return ["kan", "ga", "roo"]

...

>>> f = Foo()

>>> dir(f)

[’ga’, ’kan’, ’roo’]

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

ports iteration. The next() method of the iterator returned by enumerate() returns a tuple containing

a count (from start which defaults to 0) and the corresponding value obtained from iterating over iter-

able. enumerate() is useful for obtaining an indexed series: (0, seq[0]), (1, seq[1]), (2,

seq[2]), .... For example:

>>> for i, season in enumerate([’Spring’, ’Summer’, ’Fall’, ’Winter’]):

... print i, season

0 Spring

1 Summer

2 Fall

3 Winter

New in version 2.3.New in version 2.6: The start parameter.

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 namespace. If the globals

dictionary is present and lacks ‘__builtins__’, the current globals are copied into globals before expression

8 Chapter 2. Built-in Functions

The Python Library Reference, Release 2.6

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

kind 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

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

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

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

The Python Library Reference, Release 2.6

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.

The ﬂoat type is described in Numeric Types — int, ﬂoat, long, complex.

frozenset([iterable])

Return a frozenset object, optionally with elements taken from iterable. The frozenset type is described in

Set Types — set, frozenset.

For other containers see the built in dict, list, and tuple classes, and the collections module.

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

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

This function is added to the built-in namespace by the site module. 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

10 Chapter 2. Built-in Functions

剩余1189页未读，继续阅读

jichunlai

粉丝: 38
资源: 43

Python 2.6官方库函数详解与类型参考

Python标准库中文版 高清.chm版

Python3.5函数API离线查询手册html版

python中文手册.pdf

python库函数手册

python说明书汉化版

怎么用python调用双目相机

在进行科学计算时，如何在Python中使用math库或scipy库来精确计算三角函数的值？请提供示例代码。

step7编程手册csdn

树莓派pico中文手册

如何在雷达系统中实现基于ASTERIX标准的数据格式解析？请结合ASTRRIX类型001数据项进行说明。

最新资源

Python标准库中文版高清.chm版