>>>
...
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 is available in the standard library as
lib2to3
; a standalone entry point is provided as
Tools/scripts/2to3
。见
2to3 - Automated Python 2 to 3 code translation
.
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()
; see the
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
模块。
A label associated with a variable, a class attribute or a function parameter or return value, used by convention as a type hint .
Annotations of local variables cannot be accessed at runtime, but annotations of global variables, class attributes, and functions are stored in the
__annotations__
special attribute of modules, classes, and functions, respectively.
见 variable annotation , function annotation , PEP 484 and PEP 526 , which describe this functionality.
A value passed to a function (or method ) when calling the function. There are two kinds of argument:
keyword argument
: 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})
positional argument
: 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.
另请参阅 parameter glossary entry, the FAQ question on the difference between arguments and parameters ，和 PEP 362 .
async
with
statement by defining
__aenter__()
and
__aexit__()
methods. Introduced by
PEP 492
.
A function which returns an
asynchronous generator iterator
. It looks like a coroutine function defined with
async
def
except that it contains
yield
expressions for producing a series of values usable in an
async
for
loop.
Usually refers to an asynchronous generator function, but may refer to an asynchronous generator iterator in some contexts. In cases where the intended meaning isn’t clear, using the full terms avoids ambiguity.
An asynchronous generator function may contain
await
expressions as well as
async
for
，和
async
with
statements.
An object created by a 异步生成器 函数。
这是
异步迭代器
which when called using the
__anext__()
method returns an awaitable object which will execute the body of the asynchronous generator function until the next
yield
表达式。
每
yield
temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the
asynchronous generator iterator
effectively resumes with another awaitable returned by
__anext__()
, it picks up where it left off. See
PEP 492
and
PEP 525
.
async
for
语句。
必须返回
异步迭代器
从其
__aiter__()
方法。引入通过
PEP 492
.
__aiter__()
and
__anext__()
方法。
__anext__
必须返回
awaitable
对象。
async
for
resolves the awaitables returned by an asynchronous
iterator’s
__anext__()
方法直到它引发
StopAsyncIteration
异常。引入通过
PEP 492
.
await
expression. Can be
a
协程
or an object with an
__await__()
方法。
另请参阅
PEP 492
.
A
文件对象
able to read and write
像字节对象
. Examples of binary files are files opened in binary mode (
'rb'
,
'wb'
or
'rb+'
),
sys.stdin.buffer
,
sys.stdout.buffer
, and instances of
io.BytesIO
and
gzip.GzipFile
.
另请参阅
text file
for a file object able to read and write
str
对象。
An object that supports the
缓冲协议
and can export a C-
contiguous
buffer. This includes all
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
of a
bytearray
. Other operations require the binary data to be stored in immutable objects (“read-only bytes-like objects”); examples of these include
bytes
和
memoryview
of a
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
virtual machine
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 the dis module .
int(3.15)
converts the floating point number to the integer
3
, but
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
will raise a
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
module, use
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
statement by defining
__enter__()
and
__exit__()
方法。
见
PEP 343
.
A buffer is considered contiguous exactly if it is either 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
statement. See also
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(...):
...
Any object which defines the methods
__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.
For more information about descriptors’ methods, see Implementing Descriptors .
__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)
。见
Dictionary view objects
.
__doc__
attribute
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.
'f'
or
'F'
are commonly called
“f-strings” which is short for
格式化字符串文字
。另请参阅
PEP 498
.
An object exposing a file-oriented API (with methods such as
read()
or
write()
) to an underlying resource. Depending on the way it was created, a file object can mediate access to a real on-disk file or to another type of storage or communication device (for example standard input/output, in-memory buffers, sockets, pipes, etc.). File objects are also called
file-like objects
or
streams
.
There are actually three categories of file objects: raw
二进制文件
, buffered
二进制文件
and
文本文件
. Their interfaces are defined in the
io
module. The canonical way to create a file object is by using the
open()
函数。
An object that tries to find the loader for a module that is being imported.
Since Python 3.3, there are two types of finder:
meta path finders
for use with
sys.meta_path
，和
path entry finders
for use with
sys.path_hooks
.
//
. For example, the expression
11
//
4
evaluates to
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 annotation of a function parameter or return value.
Function annotations are usually used for
type hints
: for example, this function is expected to take two
int
arguments and is also expected to have an
int
return value:
def sum_two_numbers(a: int, b: int) -> int:
return a + b
Function annotation syntax is explained in section 函数定义 .
见 variable annotation and PEP 484 , which describe this functionality.
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)
gc
模块。
A function which returns a
generator iterator
. It looks like a normal function except that it contains
yield
expressions for producing a series of values usable in a for-loop or that can be retrieved one at a time with the
next()
函数。
Usually refers to a generator function, but may refer to a generator iterator in some contexts. In cases where the intended meaning isn’t clear, using the full terms avoids ambiguity.
An object created by a generator 函数。
每
yield
temporarily suspends processing, remembering the location execution state (including local variables and pending try-statements). When the
generator iterator
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.
另请参阅
single dispatch
glossary entry, the
functools.singledispatch()
decorator, and
PEP 443
.
The mechanism used by the
CPython
interpreter to assure that only one thread executes Python
bytecode
at a time. This simplifies the CPython implementation by making the object model (including critical built-in types such as
dict
) implicitly safe against concurrent access. Locking the entire interpreter makes it easier for the interpreter to be multi-threaded, at the expense of much of the parallelism afforded by multi-processor machines.
However, some extension modules, either standard or third-party, are designed so as to release the GIL when doing computationally-intensive tasks such as compression or hashing. Also, the GIL is always released when doing I/O.
Past efforts to create a “free-threaded” interpreter (one which locks shared data at a much finer granularity) have not been successful because performance suffered in the common single-processor case. It is believed that overcoming this performance issue would make the implementation much more complicated and therefore costlier to maintain.
An object is
hashable
if it has a hash value which never changes during its lifetime (it needs a
__hash__()
method), and can be compared to other objects (it needs an
__eq__()
method). Hashable objects which compare equal must have the same hash value.
Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.
All of Python’s immutable built-in objects are hashable; mutable containers (such as lists or dictionaries) are not. Objects which are instances of user-defined classes are hashable by default. They all compare unequal (except with themselves), and their hash value is derived from their
id()
.
sys.path
, but
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 garbage collector . 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.
An object capable of returning its members one at a time. Examples of iterables include all sequence types (such as
list
,
str
，和
tuple
) and some non-sequence types like
dict
,
文件对象
, and objects of any classes you define with an
__iter__()
method or with a
__getitem__()
method that implements
Sequence
semantics.
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
.
An object representing a stream of data. Repeated calls to the iterator’s
__next__()
method (or passing it to the built-in function
next()
) return successive items in the stream. When no more data are available a
StopIteration
exception is raised instead. At this point, the iterator object is exhausted and any further calls to its
__next__()
method just raise
StopIteration
again. Iterators are required to have an
__iter__()
method that returns the iterator object itself so every iterator is also iterable and may be used in most places where other iterables are accepted. One notable exception is code which attempts multiple iteration passes. A container object (such as a
list
) produces a fresh new iterator each time you pass it to the
iter()
function or use it in a
for
loop. Attempting this with an iterator will just return the same exhausted iterator object used in the previous iteration pass, making it appear like an empty container.
可以找到更多信息在 迭代器类型 .
A key function or collation function is a callable that returns a value used for sorting or ordering. For example,
locale.strxfrm()
is used to produce a sort key that is aware of locale specific sort conventions.
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])
. Also, the
operator
module provides three key function constructors:
attrgetter()
,
itemgetter()
，和
methodcaller()
。见
Sorting HOW TO
for examples of how to create and use key functions.
lambda
[parameters]:
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
statements.
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
mapping
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
for an
抽象基类
.
Mapping
or
MutableMapping
抽象基类
. Examples
include
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
path entry finders
.
见
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.
可以找到更多信息在 Metaclasses .
self
).
见
function
and
nested scope
.
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 .
另请参阅 package .
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
package
which serves only as a container for subpackages. Namespace packages may have no physical representation, and specifically are not like a
regular package
because they have no
__init__.py
文件。
另请参阅 模块 .
nonlocal
allows writing to outer
scopes.
__slots__
, descriptors,
特性，
__getattribute__()
, class methods, and static methods.
A Python
模块
which can contain submodules or recursively, subpackages. Technically, a package is a Python module with an
__path__
属性。
另请参阅 regular package and namespace package .
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:
positional-or-keyword : specifies an argument that can be passed either positionally or as a keyword argument . This is the default kind of parameter, for example foo and bar in the following:
def func(foo, bar=None): ...
abs()
).
keyword-only
: 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
glossary entry, the FAQ question on
the difference between arguments and parameters
，
inspect.Parameter
class, the
函数定义
section, and
PEP 362
.
A
finder
returned by a callable on
sys.path_hooks
(i.e. a
path entry hook
) which knows how to locate modules given a
path entry
.
见
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
.
str
or
bytes
object representing a path, or an object
implementing the
os.PathLike
protocol. An object that supports
the
os.PathLike
protocol can be converted to a
str
or
bytes
file system path by calling the
os.fspath()
function;
os.fsdecode()
and
os.fsencode()
can be used to guarantee a
str
or
bytes
result instead, respectively. Introduced
by
PEP 519
.
Python Enhancement Proposal. A PEP is a design document providing information to the Python community, or describing a new feature for Python or its processes or environment. PEPs should provide a concise technical specification and a rationale for proposed features.
PEPs are intended to be the primary mechanisms for proposing major new features, for collecting community input on an issue, and for documenting the design decisions that have gone into Python. The PEP author is responsible for building consensus within the community and documenting dissenting opinions.
见 PEP 1 .
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
package
, such as a directory containing an
__init__.py
文件。
另请参阅 namespace package .
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.
collections.abc.Sequence
abstract base class defines a much richer interface that goes beyond just
__getitem__()
and
__len__()
, adding
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
include
sys.float_info
and the return value of
os.stat()
.
A
文件对象
able to read and write
str
objects. Often, a text file actually accesses a byte-oriented datastream and handles the
文本编码
automatically. Examples of text files are files opened in text mode (
'r'
or
'w'
),
sys.stdin
,
sys.stdout
, and instances of
io.StringIO
.
__class__
attribute or can be retrieved with
type(obj)
.
A synonym for a type, created by assigning the type to an identifier.
Type aliases are useful for simplifying type hints 。例如：
from typing import List, Tuple
def remove_gray_shades(
colors: List[Tuple[int, int, int]]) -> List[Tuple[int, int, int]]:
pass
could be made more readable like this:
from typing import List, Tuple
Color = Tuple[int, int, int]
def remove_gray_shades(colors: List[Color]) -> List[Color]:
pass
An annotation that specifies the expected type for a variable, a class attribute, or a function parameter or return value.
Type hints are optional and are not enforced by Python but they are useful to static type analysis tools, and aid IDEs with code completion and refactoring.
Type hints of global variables, class attributes, and functions, but not local variables, can be accessed using
typing.get_type_hints()
.
'\n'
,
the Windows convention
'\r\n'
, and the old Macintosh convention
'\r'
。见
PEP 278
and
PEP 3116
, as well as
bytes.splitlines()
for an additional use.
An annotation of a variable or a class attribute.
When annotating a variable or a class attribute, assignment is optional:
class C:
field: 'annotation'
Variable annotations are usually used for
type hints
: for example this variable is expected to take
int
values:
count: int = 0
Variable annotation syntax is explained in section Annotated assignment statements .
见 function annotation , PEP 484 and PEP 526 , which describe this functionality.
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.
另请参阅
venv
.
import
this
” at the interactive prompt.