>>>
...
A tool that tries to convert Python 2.x code to Python 3.x code by handling most of the incompatibilities which can be detected by parsing the source and traversing the parse tree.
2to3 可用于标准库作为
lib2to3
；独立入口点的提供作为
Tools/scripts/2to3
。见
2to3 - 自动 Python 2 到 3 代码翻译
.
hasattr()
would be clumsy or subtly wrong (for example with
magic methods
). ABCs introduce virtual
subclasses, which are classes that don’t inherit from a class but are
still recognized by
isinstance()
and
issubclass()
；见
abc
module documentation. Python comes with many built-in ABCs for
data structures (in the
collections.abc
module), numbers (in the
numbers
module), streams (in the
io
module), import finders
and loaders (in the
importlib.abc
module). You can create your own
ABCs with the
abc
模块。
值被传递给 function (或 方法 ) 当调用函数时。有 2 种自变量：
关键词自变量
: an argument preceded by an identifier (e.g.
name=
) in a function call or passed as a value in a dictionary preceded by
**
。例如，
3
and
5
are both keyword arguments in the following calls to
complex()
:
complex(real=3, imag=5) complex(**{'real': 3, 'imag': 5})
位置自变量
: an argument that is not a keyword argument. Positional arguments can appear at the beginning of an argument list and/or be passed as elements of an
iterable
preceded by
*
。例如，
3
and
5
are both positional arguments in the following calls:
complex(3, 5) complex(*(3, 5))
Arguments are assigned to the named local variables in a function body. See the 调用 section for the rules governing this assignment. Syntactically, any expression can be used to represent an argument; the evaluated value is assigned to the local variable.
另请参阅 参数 词汇表条目，FAQ 问题有关 自变量和参数之间的差异 ，和 PEP 362 .
async with
语句通过定义
__aenter__()
and
__aexit__()
方法。引入通过
PEP 492
.
async for
语句。
必须返回
异步迭代器
从其
__aiter__()
方法。引入通过
PEP 492
.
__aiter__()
and
__anext__()
方法。
__anext__
必须返回
awaitable
对象。
async for
resolves awaitable returned from asynchronous
iterator’s
__anext__()
method until it raises
StopAsyncIteration
异常。引入通过
PEP 492
.
await
expression. Can be
a
协程
或对象具有
__await__()
方法。
另请参阅
PEP 492
.
A
文件对象
能读取和写入
像字节对象
。二进制文件的范例是以二进制模式打开的文件 (
'rb'
,
'wb'
or
'rb+'
),
sys.stdin.buffer
,
sys.stdout.buffer
，和实例化的
io.BytesIO
and
gzip.GzipFile
.
另请参阅
对象支持
缓冲协议
且可以导出 C
contiguous
缓冲。这包括所有
bytes
,
bytearray
，和
array.array
objects, as well as many common
memoryview
objects. Bytes-like objects can be used for various operations that work with binary data; these include compression, saving to a binary file, and sending over a socket.
Some operations need the binary data to be mutable. The documentation often refers to these as “read-write bytes-like objects”. Example mutable buffer objects include
bytearray
和
memoryview
的
bytearray
. Other operations require the binary data to be stored in immutable objects (“read-only bytes-like objects”); examples of these include
bytes
和
memoryview
的
bytes
对象。
Python source code is compiled into bytecode, the internal representation of a Python program in the CPython interpreter. The bytecode is also cached in
.pyc
files so that executing the same file is faster the second time (recompilation from source to bytecode can be avoided). This “intermediate language” is said to run on a
虚拟机
that executes the machine code corresponding to each bytecode. Do note that bytecodes are not expected to work between different Python virtual machines, nor to be stable between Python releases.
A list of bytecode instructions can be found in the documentation for dis 模块 .
int(3.15)
converts the floating point number to the integer
3
，但
in
3+4.5
, each argument is of a different type (one int, one float),
and both must be converted to the same type before they can be added or it
将引发
TypeError
. Without coercion, all arguments of even
compatible types would have to be normalized to the same value by the
programmer, e.g.,
float(3)+4.5
rather than just
3+4.5
.
-1
), often written
i
in mathematics or
j
in
engineering. Python has built-in support for complex numbers, which are
written with this latter notation; the imaginary part is written with a
j
suffix, e.g.,
3+1j
. To get access to complex equivalents of the
math
模块，使用
cmath
. Use of complex numbers is a fairly
advanced mathematical feature. If you’re not aware of a need for them,
it’s almost certain you can safely ignore them.
with
语句通过定义
__enter__()
and
__exit__()
方法。
见
PEP 343
.
准确认为缓冲是连续的，若它是 C-contiguous or Fortran contiguous . Zero-dimensional buffers are C and Fortran contiguous. In one-dimensional arrays, the items must be laid out in memory next to each other, in order of increasing indexes starting from zero. In multidimensional C-contiguous arrays, the last index varies the fastest when visiting items in order of memory address. However, in Fortran contiguous arrays, the first index varies the fastest.
async def
语句。另请参阅
PEP 492
.
async def
statement,
and may contain
await
,
async for
，和
async with
keywords. These were introduced
by
PEP 492
.
返回另一函数的函数，通常作为函数变换运用，使用
@wrapper
句法。装饰器的常见范例是
classmethod()
and
staticmethod()
.
装饰器句法仅仅是句法糖，以下 2 函数定义在语义上是等效的：
def f(...): ... f = staticmethod(f) @staticmethod def f(...): ...
任何对象若有定义方法
__get__()
,
__set__()
，或
__delete__()
. When a class attribute is a descriptor, its special binding behavior is triggered upon attribute lookup. Normally, using
a.b
to get, set or delete an attribute looks up the object named
b
in the class dictionary for
a
, but if
b
is a descriptor, the respective descriptor method gets called. Understanding descriptors is a key to a deep understanding of Python because they are the basis for many features including functions, methods, properties, class methods, static methods, and reference to super classes.
有关描述符方法的更多信息，见 实现描述符 .
__hash__()
and
__eq__()
方法。
Called a hash in Perl.
dict.keys()
,
dict.values()
，和
dict.items()
are called dictionary views. They provide a dynamic
view on the dictionary’s entries, which means that when the dictionary
changes, the view reflects these changes. To force the
dictionary view to become a full list use
list(dictview)
。见
字典视图对象
.
__doc__
属性
of the enclosing class, function or module. Since it is available via
introspection, it is the canonical place for documentation of the
对象。
type()
or
isinstance()
. (Note, however, that duck-typing can be complemented
with
抽象基类
.) Instead, it
typically employs
hasattr()
tests or
EAFP
programming.
try
and
except
statements. The technique contrasts with the
LBYL
style
common to many other languages such as C.
if
. Assignments are also statements,
not expressions.
对象暴露面向文件 API (采用方法，譬如
read()
or
write()
) 到底层资源。根据创建方式，文件对象可以中介访问真实磁盘文件、其它类型存储或通信设备 (例如：标准输入/输出、内存缓冲、套接字、管道、等)。文件对象也称
像文件对象
or
流
.
实际有 3 类文件对象：原生
二进制文件
，缓冲
二进制文件
and
文本文件
。它们接口的定义在
io
模块。创建文件对象的典型方式是使用
open()
函数。
对象试着查找 loader 为正导入模块。
从 Python 3.3 起，有 2 种类型的查找器：
元路径查找器
用于
sys.meta_path
，和
路径条目查找器
用于
sys.path_hooks
.
//
。例如，表达式
11 // 4
评估为
2
in contrast to the
2.75
returned by float true
division. Note that
(-11) // 4
is
-3
because that is
-2.75
rounded
downward
。见
PEP 238
.
An arbitrary metadata value associated with a function parameter or return value. Its syntax is explained in section
函数定义
. Annotations may be accessed via the
__annotations__
special attribute of a function object.
Python itself does not assign any particular meaning to function annotations. They are intended to be interpreted by third-party libraries or tools. See PEP 3107 , which describes some of their potential uses.
A pseudo-module which programmers can use to enable new language features which are not compatible with the current interpreter.
By importing the
__future__
module and evaluating its variables, you can see when a new feature was first added to the language and when it becomes the default:
>>> import __future__ >>> __future__.division _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)
函数返回
生成器迭代器
。它看起来像正常函数，除了它包含
yield
表达式，用于产生可用于 for 循环的一系列值，或每次可以检索一值采用
next()
函数。
通常指生成器函数，但也可能指 生成器迭代器 在某些上下文中。若欲表达含义不清晰，使用完整术语避免歧义。
对象的创建通过 generator 函数。
每个
yield
会临时挂起处理，记住定位执行状态 (包括局部变量和待决 try 语句)。当
生成器迭代器
resumes, it picks-up where it left-off (in contrast to functions which start fresh on every invocation).
An expression that returns an iterator. It looks like a normal expression followed by a
for
expression defining a loop variable, range, and an optional
if
expression. The combined expression generates values for an enclosing function:
>>> sum(i*i for i in range(10)) # sum of squares 0, 1, 4, ... 81 285
A function composed of multiple functions implementing the same operation for different types. Which implementation should be used during a call is determined by the dispatch algorithm.
另请参阅
单次分派
词汇表条目，
functools.singledispatch()
装饰器，和
PEP 443
.
机制用于
CPython
解释器担保只有一个线程执行 Python
bytecode
每次。这简化 CPython 实现通过使对象模型 (包括关键内置类型，譬如
dict
) 隐含安全阻止并发访问。锁定整个解释器使解释器更易于多线程，以付出由多处理器机器提供的许多并行性为代价。
不管怎样，一些扩展模块 (标准或第 3 方) 被设计为在履行计算密集任务 (譬如：压缩或散列) 时释放 GIL。此外，当履行 I/O 时始终释放 GIL。
过去创建 "自由线程" 解释器 (以更细粒度锁定共享数据) 的努力并不成功，因为在常见单处理器情况下会损失性能。据信，克服此性能问题将使得实现更加复杂，因此维护更昂贵。
对象
hashable
若它拥有的哈希值在其寿命内从不改变 (它需要
__hash__()
方法)，且可以比较其它对象 (它需要
__eq__()
方法)。比较相等的可哈希对象必须拥有相同的哈希值。
可哈希性使对象可用作字典键和 set 成员，因为这些数据结构内部使用哈希值。
Python 的所有不可变内置对象都是可哈希的。可变容器 (譬如：列表或字典) 不是。默认情况下，用户定义类实例的对象是可哈希的。比较他们不相等 (除他们自己外)，且他们的哈希值派生自其
id()
.
sys.path
，但
for subpackages it may also come from the parent package’s
__path__
属性。
python
with no
arguments (possibly by selecting it from your computer’s main
menu). It is a very powerful way to test out new ideas or inspect
modules and packages (remember
help(x)
).
When asked to shut down, the Python interpreter enters a special phase where it gradually releases all allocated resources, such as modules and various critical internal structures. It also makes several calls to the 垃圾收集器 . This can trigger the execution of code in user-defined destructors or weakref callbacks. Code executed during the shutdown phase can encounter various exceptions as the resources it relies on may not function anymore (common examples are library modules or the warnings machinery).
The main reason for interpreter shutdown is that the
__main__
module or the script being run has finished executing.
list
,
str
,
and
tuple
) 和一些非序列类型像
dict
,
文件对象
, and objects of any classes you define
with an
__iter__()
or
__getitem__()
method. Iterables can be
used in a
for
loop and in many other places where a sequence is
needed (
zip()
,
map()
, ...). When an iterable object is passed
as an argument to the built-in function
iter()
, it returns an
iterator for the object. This iterator is good for one pass over the set
of values. When using iterables, it is usually not necessary to call
iter()
or deal with iterator objects yourself. The
for
statement does that automatically for you, creating a temporary unnamed
variable to hold the iterator for the duration of the loop. See also
iterator
,
sequence
，和
generator
.
表示数据流的对象。重复调用迭代器的
__next__()
方法 (或把它传递给内置函数
next()
) 会依次返回流中的项。当没有更多数据可用时
StopIteration
异常被引发取而代之。此时，迭代器对象耗尽，且任何进一步调用其
__next__()
方法仅仅引发
StopIteration
再次。要求迭代器有
__iter__()
方法返回迭代器对象本身，所以，每个迭代器也可迭代，且可以用于接受其它可迭代的大多数地方。试图多次迭代遍历的代码是一个值得注意的例外。容器对象 (譬如
list
) 将产生刷新的新迭代器，每次把它传递给
iter()
函数或把它用于
for
循环。采用迭代器尝试这将仅仅返回用于先前迭代遍历的同一耗尽迭代器对象，使它看起来像空容器。
可以找到更多信息在 迭代器类型 .
关键函数 (或整理函数) 是返回用于排序 (或次序) 值的可调用。例如，
locale.strxfrm()
是用于产生特定区域设置排序约定意识的排序键。
A number of tools in Python accept key functions to control how elements are ordered or grouped. They include
min()
,
max()
,
sorted()
,
list.sort()
,
heapq.merge()
,
heapq.nsmallest()
,
heapq.nlargest()
，和
itertools.groupby()
.
There are several ways to create a key function. For example. the
str.lower()
method can serve as a key function for case insensitive sorts. Alternatively, a key function can be built from a
lambda
expression such as
lambda r: (r[0], r[2])
。另外，
operator
module provides three key function constructors:
attrgetter()
,
itemgetter()
，和
methodcaller()
。见
排序怎么样
for examples of how to create and use key functions.
lambda [arguments]: expression
Look before you leap. This coding style explicitly tests for pre-conditions before making calls or lookups. This style contrasts with the
EAFP
approach and is characterized by the presence of many
if
语句。
In a multi-threaded environment, the LBYL approach can risk introducing a race condition between “the looking” and “the leaping”. For example, the code,
if key in mapping: return mapping[key]
can fail if another thread removes
key
from
映射
after the test, but before the lookup. This issue can be solved with locks or by using the EAFP approach.
result = ['{:#04x}'.format(x) for x in
range(256) if x % 2 == 0]
generates a list of strings containing
even hex numbers (0x..) in the range from 0 to 255. The
if
clause is optional. If omitted, all elements in
range(256)
are
processed.
load_module()
. A loader is typically returned by a
finder
。见
PEP 302
for details and
importlib.abc.Loader
对于
抽象基类
.
Mapping
or
MutableMapping
抽象基类
. Examples
包括
dict
,
collections.defaultdict
,
collections.OrderedDict
and
collections.Counter
.
A
finder
returned by a search of
sys.meta_path
. Meta path finders are related to, but different from
路径条目查找器
.
见
importlib.abc.MetaPathFinder
for the methods that meta path finders implement.
The class of a class. Class definitions create a class name, a class dictionary, and a list of base classes. The metaclass is responsible for taking those three arguments and creating the class. Most object oriented programming languages provide a default implementation. What makes Python special is that it is possible to create custom metaclasses. Most users never need this tool, but when the need arises, metaclasses can provide powerful, elegant solutions. They have been used for logging attribute access, adding thread-safety, tracking object creation, implementing singletons, and many other tasks.
可以找到更多信息在 定制类创建 .
self
).
见
function
and
嵌套作用域
.
An object that serves as an organizational unit of Python code. Modules have a namespace containing arbitrary Python objects. Modules are loaded into Python by the process of importing .
另请参阅 包 .
importlib.machinery.ModuleSpec
.
id()
。见
also
immutable
.
Any tuple-like class whose indexable elements are also accessible using named attributes (for example,
time.localtime()
returns a tuple-like object where the
year
is accessible either with an index such as
t[0]
or with a named attribute like
t.tm_year
).
A named tuple can be a built-in type such as
time.struct_time
, or it can be created with a regular class definition. A full featured named tuple can also be created with the factory function
collections.namedtuple()
. The latter approach automatically provides extra features such as a self-documenting representation like
Employee(name='jones', title='programmer')
.
builtins.open
and
os.open()
are distinguished by
their namespaces. Namespaces also aid readability and maintainability by
making it clear which module implements a function. For instance, writing
random.seed()
or
itertools.islice()
makes it clear that those
functions are implemented by the
random
and
itertools
modules, respectively.
A
PEP 420
包
which serves only as a container for subpackages. Namespace packages may have no physical representation, and specifically are not like a
正则包
because they have no
__init__.py
文件。
另请参阅 模块 .
nonlocal
allows writing to outer
scopes.
__slots__
, descriptors,
properties,
__getattribute__()
，类方法，和静态方法。
Python
模块
which can contain submodules or recursively, subpackages. Technically, a package is a Python module with an
__path__
属性。
A named entity in a function (or method) definition that specifies an argument (or in some cases, arguments) that the function can accept. There are five kinds of parameter:
位置或关键词 : specifies an argument that can be passed either positionally 或作为 关键词自变量 . This is the default kind of parameter, for example foo and bar in the following:
def func(foo, bar=None): ...
仅位置
: specifies an argument that can be supplied only by position. Python has no syntax for defining positional-only parameters. However, some built-in functions have positional-only parameters (e.g.
abs()
).
仅关键词
: specifies an argument that can be supplied only by keyword. Keyword-only parameters can be defined by including a single var-positional parameter or bare
*
in the parameter list of the function definition before them, for example
kw_only1
and
kw_only2
in the following:
def func(arg, *, kw_only1, kw_only2): ...
var-positional
: specifies that an arbitrary sequence of positional arguments can be provided (in addition to any positional arguments already accepted by other parameters). Such a parameter can be defined by prepending the parameter name with
*
，例如
args
in the following:
def func(*args, **kwargs): ...
var-keyword
: specifies that arbitrarily many keyword arguments can be provided (in addition to any keyword arguments already accepted by other parameters). Such a parameter can be defined by prepending the parameter name with
**
，例如
kwargs
in the example above.
Parameters can specify both optional and required arguments, as well as default values for some optional arguments.
另请参阅
argument
词汇表条目，FAQ 问题有关
自变量和参数之间的差异
，
inspect.Parameter
类，
函数定义
章节，和
PEP 362
.
A
finder
returned by a callable on
sys.path_hooks
(i.e. a
路径条目挂钩
) which knows how to locate modules given a
路径条目
.
见
importlib.abc.PathEntryFinder
for the methods that path entry finders implement.
sys.path_hook
list which returns a
path
entry finder
if it knows how to find modules on a specific
path
entry
.
A provisional API is one which has been deliberately excluded from the standard library’s backwards compatibility guarantees. While major changes to such interfaces are not expected, as long as they are marked provisional, backwards incompatible changes (up to and including removal of the interface) may occur if deemed necessary by core developers. Such changes will not be made gratuitously – they will occur only if serious fundamental flaws are uncovered that were missed prior to the inclusion of the API.
Even for provisional APIs, backwards incompatible changes are seen as a “solution of last resort” - every attempt will still be made to find a backwards compatible resolution to any identified problems.
This process allows the standard library to continue to evolve over time, without locking in problematic design errors for extended periods of time. See PEP 411 了解更多细节。
An idea or piece of code which closely follows the most common idioms of the Python language, rather than implementing code using concepts common to other languages. For example, a common idiom in Python is to loop over all elements of an iterable using a
for
statement. Many other languages don’t have this type of construct, so people unfamiliar with Python sometimes use a numerical counter instead:
for i in range(len(food)): print(food[i])
As opposed to the cleaner, Pythonic method:
for piece in food: print(piece)
A dotted name showing the “path” from a module’s global scope to a class, function or method defined in that module, as defined in PEP 3155 . For top-level functions and classes, the qualified name is the same as the object’s name:
>>> class C: ... class D: ... def meth(self): ... pass ... >>> C.__qualname__ 'C' >>> C.D.__qualname__ 'C.D' >>> C.D.meth.__qualname__ 'C.D.meth'
When used to refer to modules, the
fully qualified name
means the entire dotted path to the module, including any parent packages, e.g.
email.mime.text
:
>>> import email.mime.text >>> email.mime.text.__name__ 'email.mime.text'
sys
module defines a
getrefcount()
function that programmers can call to return the
reference count for a particular object.
A traditional
包
, such as a directory containing an
__init__.py
文件。
另请参阅 名称空间包 .
An
iterable
which supports efficient element access using integer indices via the
__getitem__()
special method and defines a
__len__()
method that returns the length of the sequence. Some built-in sequence types are
list
,
str
,
tuple
，和
bytes
。注意，
dict
also supports
__getitem__()
and
__len__()
, but is considered a mapping rather than a sequence because the lookups use arbitrary
immutable
keys rather than integers.
The
collections.abc.Sequence
abstract base class defines a much richer interface that goes beyond just
__getitem__()
and
__len__()
，添加
count()
,
index()
,
__contains__()
，和
__reversed__()
. Types that implement this expanded interface can be registered explicitly using
register()
.
[]
with colons between numbers
when several are given, such as in
variable_name[1:3:5]
. The bracket
(subscript) notation uses
slice
objects internally.
if
,
while
or
for
.
_make()
or
_asdict()
. Examples of struct sequences
包括
sys.float_info
and the return value of
os.stat()
.
A
文件对象
能读取和写入
str
对象。经常，文本文件实际访问面向字节的数据流，并处理
文本编码
自动。文本文件范例是打开文件按文本模式 (
'r'
or
'w'
),
sys.stdin
,
sys.stdout
，和实例化的
io.StringIO
.
另请参阅
__class__
attribute or can be retrieved with
type(obj)
.
'\n'
,
the Windows convention
'\r\n'
, and the old Macintosh convention
'\r'
。见
PEP 278
and
PEP 3116
，及
bytes.splitlines()
for an additional use.
A cooperatively isolated runtime environment that allows Python users and applications to install and upgrade Python distribution packages without interfering with the behaviour of other Python applications running on the same system.
import this
” at the interactive prompt.