Python标准库文档指南

需积分: 36 156 浏览量更新于2024-07-20 1 收藏 22.63MB PDF 举报

Python 官方文档 Python 官方文档是 Python 语言的官方参考文献，提供了 Python 语言的语法、语义、标准库和其他相关信息。下面是对 Python 官方文档的详细解读。 Navigation Python 官方文档的 navigation 部分提供了文档的目录结构，方便用户快速查找相关信息。Navigation 部分包括 index、modules、next、previous 等部分，每个部分都包含了特定的信息，帮助用户快速了解 Python 语言。 The Python Standard Library Python 的标准库是 Python 语言的核心组件之一，提供了大量的功能来帮助开发者快速开发应用程序。标准库中包括了许多 built-in 模块，这些模块都是使用 C 语言编写的，提供了对系统功能的访问，例如文件 I/O 操作。同时，标准库中还包括了许多使用 Python 语言编写的模块，这些模块提供了标准化的解决方案，帮助开发者解决常见的问题。 Python 的标准库非常庞大，提供了广泛的功能，涵盖了许多方面，例如文件 I/O、网络编程、数据结构、算法等等。标准库中的模块都是经过精心设计的，旨在提高 Python 程序的可移植性，抽象出平台相关的细节，提供了平台中立的 API。 Python 安装程序 Python 的安装程序通常包括整个标准库，当然也包括许多其他的组件。例如，Windows 平台的 Python 安装程序通常包括整个标准库，以及许多其他的组件。这些组件都是 Python 社区贡献的，旨在帮助开发者快速开发应用程序。 Python 语言参考 Python 语言参考是 Python 语言的官方参考文献，提供了 Python 语言的语法、语义和其他相关信息。语言参考 manual 描述了 Python 语言的exact 语法和语义，帮助开发者正确地使用 Python 语言。 Python 版本 Python 官方文档支持多个版本的 Python，包括 Python 3.5.1 等。每个版本的文档都提供了特定的信息，帮助开发者了解该版本的特点和变化。 Python 官方文档是 Python 语言的核心组件之一，提供了大量的信息，帮助开发者快速了解 Python 语言和标准库。通过学习 Python 官方文档，开发者可以快速提高自己的技能，开发出更加优秀的应用程序。

    def x(self):
        del self._x
This code is exactly equivalent to the first example. Be sure to give the additional functions the same name as the
original property (x in this case.)
The returned property object also has the attributes fget, fset, and fdel corresponding to the constructor arguments.
Changed in version 3.5: The docstrings of property objects are now writeable.
range(stop)
range(start, stop[, step])
Rather than being a function, range is actually an immutable sequence type, as documented in Ranges and Sequence Types —
list, tuple, range.
repr(object)
Return a string containing a printable representation of an object. For many types, this function makes an attempt to
return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a
string enclosed in angle brackets that contains the name of the type of the object together with additional information
often including the name and address of the object. A class can control what this function returns for its instances by
defining a __repr__() method.
reversed(seq)
Return a reverse iterator. seq must be an object which has a __reversed__() method or supports the sequence protocol (the
__len__() method and the __getitem__() method with integer arguments starting at 0).
round(number[, ndigits])
Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it returns
the nearest integer to its input. Delegates to number.__round__(ndigits).
For the built-in types supporting round(), values are rounded to the closest multiple of 10 to the power minus ndigits; if
two multiples are equally close, rounding is done toward the even choice (so, for example, both round(0.5) and round(-0.5)
are 0, and round(1.5) is 2). The return value is an integer if called with one argument, otherwise of the same type as
number.
Note
The behavior of round() for floats can be surprising: for example, round(2.675, 2) gives 2.67 instead of the expected 2.68.
This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float. See
Floating Point Arithmetic: Issues and Limitations for more information.
class set([iterable])
Return a new set object, optionally with elements taken from iterable. set is a built-in class. See set and Set Types —
set, frozenset for documentation about this class.
For other containers see the built-in frozenset, list, tuple, and dict classes, as well as the collections module.
setattr(object, name, value)
This is the counterpart of getattr(). The arguments are an object, a string and an arbitrary value. The string may name an
existing attribute or a new attribute. The function assigns the value to the attribute, provided the object allows it. For
example, setattr(x, 'foobar', 123) is equivalent to x.foobar = 123.
class slice(stop)
class slice(start, stop[, step])
Return a slice object representing the set of indices specified by range(start, stop, step). The start and step arguments
default to None. Slice objects have read-only data attributes start, stop and step which merely return the argument values
(or their default). They have no other explicit functionality; however they are used by Numerical Python and other third
party extensions. Slice objects are also generated when extended indexing syntax is used. For example: a[start:stop:step]
or a[start:stop, i]. See itertools.islice() for an alternate version that returns an iterator.
sorted(iterable[, key][, reverse])
Return a new sorted list from the items in iterable.
Has two optional arguments which must be specified as keyword arguments.
key specifies a function of one argument that is used to extract a comparison key from each list element: key=str.lower.
The default value is None (compare the elements directly).
reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.

Use functools.cmp_to_key() to convert an old-style cmp function to a key function.
The built-in sorted() function is guaranteed to be stable. A sort is stable if it guarantees not to change the relative
order of elements that compare equal — this is helpful for sorting in multiple passes (for example, sort by department,
then by salary grade).
For sorting examples and a brief sorting tutorial, see Sorting HowTo.
staticmethod(function)
Return a static method for function.
A static method does not receive an implicit first argument. To declare a static method, use this idiom:
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
The @staticmethod form is a function decorator – see the description of function definitions in Function definitions 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.
Static methods in Python are similar to those found in Java or C++. Also see classmethod() for a variant that is useful for
creating alternate class constructors.
For more information on static methods, consult the documentation on the standard type hierarchy in The standard type
hierarchy.
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
Return a str version of object. See str() for details.
str is the built-in string class. For general information about strings, see Text Sequence Type — str.
sum(iterable[, start])
Sums start and the items of an iterable from left to right and returns the total. start defaults to 0. The iterable‘s
items are normally numbers, and the start value is not allowed to be a string.
For some use cases, there are good alternatives to sum(). The preferred, fast way to concatenate a sequence of strings is
by calling ''.join(sequence). To add floating point values with extended precision, see math.fsum(). To concatenate a series
of iterables, consider using itertools.chain().
super([type[, object-or-type]])
Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing
inherited methods that have been overridden in a class. The search order is same as that used by getattr() except that the
type itself is skipped.
The __mro__ attribute of the type lists the method resolution search order used by both getattr() and super(). The attribute
is dynamic and can change whenever the inheritance hierarchy is updated.
If the second argument is omitted, the super object returned is unbound. If the second argument is an object,
isinstance(obj, type) must be true. If the second argument is a type, issubclass(type2, type) must be true (this is useful
for classmethods).
There are two typical use cases for super. In a class hierarchy with single inheritance, super can be used to refer to
parent classes without naming them explicitly, thus making the code more maintainable. This use closely parallels the use
of super in other programming languages.
The second use case is to support cooperative multiple inheritance in a dynamic execution environment. This use case is
unique to Python and is not found in statically compiled languages or languages that only support single inheritance. This
makes it possible to implement “diamond diagrams” where multiple base classes implement the same method. Good design
dictates that this method have the same calling signature in every case (because the order of calls is determined at
runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes
that are unknown prior to runtime).
For both use cases, a typical superclass call looks like this:
class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

Note that super() is implemented as part of the binding process for explicit dotted attribute lookups such as
super().__getitem__(name). It does so by implementing its own __getattribute__() method for searching classes in a
predictable order that supports cooperative multiple inheritance. Accordingly, super() is undefined for implicit lookups
using statements or operators such as super()[name].
Also note that, aside from the zero argument form, super() is not limited to use inside methods. The two argument form
specifies the arguments exactly and makes the appropriate references. The zero argument form only works inside a class
definition, as the compiler fills in the necessary details to correctly retrieve the class being defined, as well as
accessing the current instance for ordinary methods.
For practical suggestions on how to design cooperative classes using super(), see guide to using super().
tuple([iterable])
Rather than being a function, tuple is actually an immutable sequence type, as documented in Tuples and Sequence Types —
list, tuple, range.
class type(object)
class type(name, bases, dict)
With one argument, return the type of an object. The return value is a type object and generally the same object as
returned by object.__class__.
The isinstance() built-in function is recommended for testing the type of an object, because it takes subclasses into
account.
With three arguments, return a new type object. This is essentially a dynamic form of the class statement. The name string
is the class name and becomes the __name__ attribute; the bases tuple itemizes the base classes and becomes the __bases__
attribute; and the dict dictionary is the namespace containing definitions for class body and becomes the __dict__
attribute. For example, the following two statements create identical type objects:
>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))
See also Type Objects.
vars([object])
Return the __dict__ attribute for a module, class, instance, or any other object with a __dict__ attribute.
Objects such as modules and instances have an updateable __dict__ attribute; however, other objects may have write
restrictions on their __dict__ attributes (for example, classes use a dictproxy to prevent direct dictionary updates).
Without an argument, vars() acts like locals(). Note, the locals dictionary is only useful for reads since updates to the
locals dictionary are ignored.
zip(*iterables)
Make an iterator that aggregates elements from each of the iterables.
Returns an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument sequences or
iterables. The iterator stops when the shortest input iterable is exhausted. With a single iterable argument, it returns an
iterator of 1-tuples. With no arguments, it returns an empty iterator. Equivalent to:
def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)
The left-to-right evaluation order of the iterables is guaranteed. This makes possible an idiom for clustering a data
series into n-length groups using zip(*[iter(s)]*n). This repeats the same iterator n times so that each output tuple has
the result of n calls to the iterator. This has the effect of dividing the input into n-length chunks.
zip() should only be used with unequal length inputs when you don’t care about trailing, unmatched values from the longer
iterables. If those values are important, use itertools.zip_longest() instead.
zip() in conjunction with the * operator can be used to unzip a list:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True
__import__(name, globals=None, locals=None, fromlist=(), level=0)
Note
This is an advanced function that is not needed in everyday Python programming, unlike importlib.import_module().
This function is invoked by the import statement. It can be replaced (by importing the builtins module and assigning to
builtins.__import__) in order to change semantics of the import statement, but doing so is strongly discouraged as it is
usually simpler to use import hooks (see PEP 302) to attain the same goals and does not cause issues with code which
assumes the default import implementation is in use. Direct use of __import__() is also discouraged in favor of
importlib.import_module().
The function imports the module name, potentially using the given globals and locals to determine how to interpret the name
in a package context. The fromlist gives the names of objects or submodules that should be imported from the module given
by name. The standard implementation does not use its locals argument at all, and uses its globals only to determine the
package context of the import statement.
level specifies whether to use absolute or relative imports. 0 (the default) 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__() (see PEP 328 for the details).
When the name variable is of the form package.module, normally, the top-level package (the name up till the first dot) is
returned, not the module named by name. However, when a non-empty fromlist argument is given, the module named by name is
returned.
For example, the statement import spam results in bytecode resembling the following code:
spam = __import__('spam', globals(), locals(), [], 0)
The statement import spam.ham results in this call:
spam = __import__('spam.ham', globals(), locals(), [], 0)
Note how __import__() returns the toplevel module here because this is the object that is bound to a name by the import
statement.
On the other hand, the statement from spam.ham import eggs, sausage as saus results in
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage
Here, the spam.ham module is returned from __import__(). From this object, the names to import are retrieved and assigned
to their respective names.
If you simply want to import a module (potentially within a package) by name, use importlib.import_module().
Changed in version 3.3: Negative values for level are no longer supported (which also changes the default value to 0).
Footnotes
[1] Note that the parser only accepts the Unix-style end of line convention. If you are reading the code from a file, make
sure to use newline conversion mode to convert Windows or Mac-style newlines.
3. Built-in Constants
A small number of constants live in the built-in namespace. They are:
False
The false value of the bool type. Assignments to False are illegal and raise a SyntaxError.
True
The true value of the bool type. Assignments to True are illegal and raise a SyntaxError.
None

The sole value of the type NoneType. None is frequently used to represent the absence of a value, as when default arguments
are not passed to a function. Assignments to None are illegal and raise a SyntaxError.
NotImplemented
Special value which should be returned by the binary special methods (e.g. __eq__(), __lt__(), __add__(), __rsub__(), etc.)
to indicate that the operation is not implemented with respect to the other type; may be returned by the in-place binary
special methods (e.g. __imul__(), __iand__(), etc.) for the same purpose. Its truth value is true.
Note
When NotImplemented is returned, the interpreter will then try the reflected operation on the other type, or some other
fallback, depending on the operator. If all attempted operations return NotImplemented, the interpreter will raise an
appropriate exception.
See Implementing the arithmetic operations for more details.
Ellipsis
The same as .... Special value used mostly in conjunction with extended slicing syntax for user-defined container data
types.
__debug__
This constant is true if Python was not started with an -O option. See also the assert statement.
Note
The names None, False, True and __debug__ cannot be reassigned (assignments to them, even as an attribute name, raise
SyntaxError), so they can be considered “true” constants.
3.1. Constants added by the site module
The site module (which is imported automatically during startup, except if the -S command-line option is given) adds several
constants to the built-in namespace. They are useful for the interactive interpreter shell and should not be used in programs.
quit(code=None)
exit(code=None)
Objects that when printed, print a message like “Use quit() or Ctrl-D (i.e. EOF) to exit”, and when called, raise
SystemExit with the specified exit code.
copyright
license
credits
Objects that when printed, print a message like “Type license() to see the full license text”, and when called, display
the corresponding text in a pager-like fashion (one screen at a time).
4. Built-in Types
The following sections describe the standard types that are built into the interpreter.
The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions.
Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don’t return a
specific item, never return the collection instance itself but None.
Some operations are supported by several object types; in particular, practically all objects can be compared, tested for truth
value, and converted to a string (with the repr() function or the slightly different str() function). The latter function is
implicitly used when an object is written by the print() function.
4.1. Truth Value Testing
Any object can be tested for truth value, for use in an if or while condition or as operand of the Boolean operations below. The
following values are considered false:
None
False
zero of any numeric type, for example, 0, 0.0, 0j.
any empty sequence, for example, '', (), [].