programming.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# eric R <trencyclopedia@gmail.com>, 2018
# ppcfish <ppcfish@gmail.com>, 2019
# Jiuh-star <jiuh.star@gmail.com>, 2021
# Dai Xu <daixu61@hotmail.com>, 2021
# WH-2099 <wh2099@outlook.com>, 2021
# Freesand Leo <yuqinju@163.com>, 2022
# Alpha Du <alphanow@gmail.com>, 2022
# Rafael Fontenelle <rffontenelle@gmail.com>, 2024
#
#,fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-01-12 22:01+0000\n"
"PO-Revision-Date: 2017-02-16 17:43+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2024\n"
"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#:../../faq/programming.rst:5
msgid"Programming FAQ"
msgstr"编程常见问题"

#:../../faq/programming.rst:8
msgid"Contents"
msgstr"目录"

#:../../faq/programming.rst:12
msgid"General Questions"
msgstr"一般问题"

#:../../faq/programming.rst:15
msgid""
"Is there a source code level debugger with breakpoints, single-stepping, "
"etc.?"
msgstr"Python 有没有提供带有断点、单步调试等功能的源码级调试器？"

#:../../faq/programming.rst:17../../faq/programming.rst:57
msgid"Yes."
msgstr"有的。"

#:../../faq/programming.rst:19
msgid""
"Several debuggers for Python are described below, and the built-in function "
":func:`breakpoint` allows you to drop into any of them."
msgstr"以下介绍了一些 Python 的调试器，用内置函数 :func:`breakpoint` 即可切入这些调试器中。"

#:../../faq/programming.rst:22
msgid""
"The pdb module is a simple but adequate console-mode debugger for Python. It"
" is part of the standard Python library, and is :mod:`documented in the "
"Library Reference Manual <pdb>`. You can also write your own debugger by "
"using the code for pdb as an example."
msgstr""
"pdb 模块是一个简单但是够用的控制台模式 Python 调试器。 它是标准 Python 库的一部分，并且 :mod:`已收录于库参考手册 "
"<pdb>`。 你也可以通过使用 pdb 代码作为样例来编写你自己的调试器。"

#:../../faq/programming.rst:27
msgid""
"The IDLE interactive development environment, which is part of the standard "
"Python distribution (normally available as Tools/scripts/idle), includes a "
"graphical debugger."
msgstr"作为标准 Python 发行版附带组件的 IDLE 交互式环境（通常位于 Tools/scripts/idle）中包含一个图形化的调试器。"

#:../../faq/programming.rst:31
msgid""
"PythonWin is a Python IDE that includes a GUI debugger based on pdb. The "
"PythonWin debugger colors breakpoints and has quite a few cool features such"
" as debugging non-PythonWin programs. PythonWin is available as part of "
"`pywin32 <https://github.com/mhammond/pywin32>`_ project and as a part of "
"the `ActivePython <https://www.activestate.com/products/python/>`_ "
"distribution."
msgstr""
"PythonWin 是一种 Python IDE，其中包含了一个基于 pdb 的 GUI 调试器。PythonWin "
"的调试器会为断点着色，并提供了相当多的超酷特性，例如调试非 PythonWin 程序等。PythonWin 是 `pywin32 "
"<https://github.com/mhammond/pywin32>`_ 项目的组成部分，也是 `ActivePython "
"<https://www.activestate.com/products/python/>`_ 发行版的组成部分。"

#:../../faq/programming.rst:38
msgid""
"`Eric <http://eric-ide.python-projects.org/>`_ is an IDE built on PyQt and "
"the Scintilla editing component."
msgstr""
"`Eric <http://eric-ide.python-projects.org/>`_ "
"是一个基于PyQt和Scintilla编辑组件构建的IDE。"

#:../../faq/programming.rst:41
msgid""
"`trepan3k <https://github.com/rocky/python3-trepan/>`_ is a gdb-like "
"debugger."
msgstr""
"`trepan3k <https://github.com/rocky/python3-trepan/>`_ 是一个类似 gdb 的调试器。"

#:../../faq/programming.rst:43
msgid""
"`Visual Studio Code <https://code.visualstudio.com/>`_ is an IDE with "
"debugging tools that integrates with version-control software."
msgstr""
"`Visual Studio Code <https://code.visualstudio.com/>`_ 是包含了调试工具的 "
"IDE，并集成了版本控制软件。"

#:../../faq/programming.rst:46
msgid""
"There are a number of commercial Python IDEs that include graphical "
"debuggers. They include:"
msgstr"有许多商业 Python IDE 都包含了图形化调试器。包括："

#:../../faq/programming.rst:49
msgid"`Wing IDE <https://wingware.com/>`_"
msgstr"`Wing IDE <https://wingware.com/>`_"

#:../../faq/programming.rst:50
msgid"`Komodo IDE <https://www.activestate.com/products/komodo-ide/>`_"
msgstr"`Komodo IDE <https://www.activestate.com/products/komodo-ide/>`_"

#:../../faq/programming.rst:51
msgid"`PyCharm <https://www.jetbrains.com/pycharm/>`_"
msgstr"`PyCharm <https://www.jetbrains.com/pycharm/>`_"

#:../../faq/programming.rst:55
msgid"Are there tools to help find bugs or perform static analysis?"
msgstr"是否有能帮助寻找漏洞或执行静态分析的工具？"

#:../../faq/programming.rst:59
msgid""
"`Pylint <https://www.pylint.org/>`_ and `Pyflakes "
"<https://github.com/PyCQA/pyflakes>`_ do basic checking that will help you "
"catch bugs sooner."
msgstr""
"`Pylint <https://www.pylint.org/>`_ 和 `Pyflakes "
"<https://github.com/PyCQA/pyflakes>`_ 可进行基本检查来帮助你尽早捕捉漏洞。"

#:../../faq/programming.rst:63
msgid""
"Static type checkers such as `Mypy <http://mypy-lang.org/>`_, `Pyre "
"<https://pyre-check.org/>`_, and `Pytype "
"<https://github.com/google/pytype>`_ can check type hints in Python source "
"code."
msgstr""
"静态类型检查器，例如 `Mypy <http://mypy-lang.org/>`_ 、 `Pyre <https://pyre-"
"check.org/>`_ 和 `Pytype <https://github.com/google/pytype>`_ "
"可以检查Python源代码中的类型提示。"

#:../../faq/programming.rst:72
msgid"How can I create a stand-alone binary from a Python script?"
msgstr"如何由 Python 脚本创建能独立运行的二进制程序？"

#:../../faq/programming.rst:74
msgid""
"You don't need the ability to compile Python to C code if all you want is a "
"stand-alone program that users can download and run without having to "
"install the Python distribution first. There are a number of tools that "
"determine the set of modules required by a program and bind these modules "
"together with a Python binary to produce a single executable."
msgstr""
"如果只是想要一个独立的程序，以便用户不必预先安装 Python 即可下载和运行它，则不需要将 Python 编译成 C "
"代码。有许多工具可以检测程序所需的模块，并将这些模块与 Python 二进制程序捆绑在一起生成单个可执行文件。"

#:../../faq/programming.rst:80
msgid""
"One is to use the freeze tool, which is included in the Python source tree "
"as ``Tools/freeze``. It converts Python byte code to C arrays; with a C "
"compiler you can embed all your modules into a new program, which is then "
"linked with the standard Python modules."
msgstr""
"一种方案是使用 freeze 工具，它以 ``Tools/freeze`` 的形式包含在 Python 源代码树中。它将 Python 的字节码转换为 "
"C 语言的数组；用 C 语言编译器可以将你的所有模块嵌入到一个新的程序中，然后与标准的 Python 模块连接。"

#:../../faq/programming.rst:85
msgid""
"It works by scanning your source recursively for import statements (in both "
"forms) and looking for the modules in the standard Python path as well as in"
" the source directory (for built-in modules). It then turns the bytecode "
"for modules written in Python into C code (array initializers that can be "
"turned into code objects using the marshal module) and creates a custom-made"
" config file that only contains those built-in modules which are actually "
"used in the program. It then compiles the generated C code and links it "
"with the rest of the Python interpreter to form a self-contained binary "
"which acts exactly like your script."
msgstr""
"它的工作原理是递归扫描源代码，获取两种格式的 import 语句，并在标准 Python 路径和源码目录（用于内置模块）检索这些模块。然后，把这些模块的"
" Python 字节码转换为 C 代码（可以利用 marshal "
"模块转换为代码对象的数组初始化器），并创建一个定制的配置文件，该文件仅包含程序实际用到的内置模块。然后，编译生成的 C 代码并将其与 Python "
"解释器的其余部分链接，形成一个自给自足的二进制文件，其功能与 Python 脚本代码完全相同。"

#:../../faq/programming.rst:94
msgid""
"The following packages can help with the creation of console and GUI "
"executables:"
msgstr"下列包可以用于帮助创建控制台和 GUI 的可执行文件:"

#:../../faq/programming.rst:97
msgid"`Nuitka <https://nuitka.net/>`_ (Cross-platform)"
msgstr"`Nuitka <https://nuitka.net/>`_ （跨平台）"

#:../../faq/programming.rst:98
msgid"`PyInstaller <http://www.pyinstaller.org/>`_ (Cross-platform)"
msgstr"`PyInstaller <http://www.pyinstaller.org/>`_ （跨平台）"

#:../../faq/programming.rst:99
msgid""
"`PyOxidizer <https://pyoxidizer.readthedocs.io/en/stable/>`_ (Cross-"
"platform)"
msgstr"`PyOxidizer <https://pyoxidizer.readthedocs.io/en/stable/>`_ （跨平台）"

#:../../faq/programming.rst:100
msgid""
"`cx_Freeze <https://marcelotduarte.github.io/cx_Freeze/>`_ (Cross-platform)"
msgstr"`cx_Freeze <https://marcelotduarte.github.io/cx_Freeze/>`_ （跨平台）"

#:../../faq/programming.rst:101
msgid"`py2app <https://github.com/ronaldoussoren/py2app>`_ (macOS only)"
msgstr"`py2app <https://github.com/ronaldoussoren/py2app>`_ （仅限 macOS）"

#:../../faq/programming.rst:102
msgid"`py2exe <http://www.py2exe.org/>`_ (Windows only)"
msgstr"`py2exe <http://www.py2exe.org/>`_ （仅限 Windows）"

#:../../faq/programming.rst:105
msgid"Are there coding standards or a style guide for Python programs?"
msgstr"是否有 Python 编码标准或风格指南？"

#:../../faq/programming.rst:107
msgid""
"Yes. The coding style required for standard library modules is documented "
"as :pep:`8`."
msgstr"有的。 标准库模块所要求的编码风格记录于 :pep:`8` 之中。"

#:../../faq/programming.rst:112
msgid"Core Language"
msgstr"语言核心内容"

#:../../faq/programming.rst:115
msgid"Why am I getting an UnboundLocalError when the variable has a value?"
msgstr"变量明明有值，为什么还会出现 UnboundLocalError？"

#:../../faq/programming.rst:117
msgid""
"It can be a surprise to get the UnboundLocalError in previously working code"
" when it is modified by adding an assignment statement somewhere in the body"
" of a function."
msgstr"因为在函数内部某处添加了一条赋值语句，导致之前正常工作的代码报出 UnboundLocalError 错误，这可能是有点令人惊讶。"

#:../../faq/programming.rst:121
msgid"This code:"
msgstr"以下代码："

#:../../faq/programming.rst:129
msgid"works, but this code:"
msgstr"正常工作，但是以下代码"

#:../../faq/programming.rst:136
msgid"results in an UnboundLocalError:"
msgstr"会得到一个 UnboundLocalError ："

#:../../faq/programming.rst:143
msgid""
"This is because when you make an assignment to a variable in a scope, that "
"variable becomes local to that scope and shadows any similarly named "
"variable in the outer scope. Since the last statement in foo assigns a new "
"value to ``x``, the compiler recognizes it as a local variable. "
"Consequently when the earlier ``print(x)`` attempts to print the "
"uninitialized local variable and an error results."
msgstr""
"原因就是，当对某作用域内的变量进行赋值时，该变量将成为该作用域内的局部变量，并覆盖外部作用域中的同名变量。由于 foo 的最后一条语句为 ``x`` "
"分配了一个新值，编译器会将其识别为局部变量。因此，前面的 ``print(x)`` 试图输出未初始化的局部变量，就会引发错误。"

#:../../faq/programming.rst:150
msgid""
"In the example above you can access the outer scope variable by declaring it"
" global:"
msgstr"在上面的示例中，可以将外部作用域的变量声明为全局变量以便访问："

#:../../faq/programming.rst:161
msgid""
"This explicit declaration is required in order to remind you that (unlike "
"the superficially analogous situation with class and instance variables) you"
" are actually modifying the value of the variable in the outer scope:"
msgstr"与类和实例变量貌似但不一样，其实以上是在修改外部作用域的变量值，为了提示这一点，这里需要显式声明一下。"

#:../../faq/programming.rst:168
msgid""
"You can do a similar thing in a nested scope using the :keyword:`nonlocal` "
"keyword:"
msgstr"你可以使用 :keyword:`nonlocal` 关键字在嵌套作用域中执行类似的操作："

#:../../faq/programming.rst:185
msgid"What are the rules for local and global variables in Python?"
msgstr"Python 的局部变量和全局变量有哪些规则？"

#:../../faq/programming.rst:187
msgid""
"In Python, variables that are only referenced inside a function are "
"implicitly global. If a variable is assigned a value anywhere within the "
"function's body, it's assumed to be a local unless explicitly declared as "
"global."
msgstr""
"函数内部只作引用的 Python 变量隐式视为全局变量。如果在函数内部任何位置为变量赋值，则除非明确声明为全局变量，否则均将其视为局部变量。"

#:../../faq/programming.rst:191
msgid""
"Though a bit surprising at first, a moment's consideration explains this. "
"On one hand, requiring :keyword:`global` for assigned variables provides a "
"bar against unintended side-effects. On the other hand, if ``global`` was "
"required for all global references, you'd be using ``global`` all the time."
" You'd have to declare as global every reference to a built-in function or "
"to a component of an imported module. This clutter would defeat the "
"usefulness of the ``global`` declaration for identifying side-effects."
msgstr""
"起初尽管有点令人惊讶，不过考虑片刻即可释然。一方面，已分配的变量要求加上 :keyword:`global` "
"可以防止意外的副作用发生。另一方面，如果所有全局引用都要加上 ``global`` ，那处处都得用上 ``global`` "
"了。那么每次对内置函数或导入模块中的组件进行引用时，都得声明为全局变量。这种杂乱会破坏 ``global`` 声明用于警示副作用的有效性。"

#:../../faq/programming.rst:201
msgid""
"Why do lambdas defined in a loop with different values all return the same "
"result?"
msgstr"为什么在循环中定义的参数各异的 lambda 都返回相同的结果？"

#:../../faq/programming.rst:203
msgid""
"Assume you use a for loop to define a few different lambdas (or even plain "
"functions), e.g.::"
msgstr"假设用 for 循环来定义几个取值各异的 lambda（即便是普通函数也一样）："

#:../../faq/programming.rst:210
msgid""
"This gives you a list that contains 5 lambdas that calculate ``x**2``. You "
"might expect that, when called, they would return, respectively, ``0``, "
"``1``, ``4``, ``9``, and ``16``. However, when you actually try you will "
"see that they all return ``16``::"
msgstr""
"以上会得到一个包含5个 lambda 函数的列表，这些函数将计算 ``x**2``。大家或许期望，调用这些函数会分别返回 ``0`` 、``1`` 、 "
"``4`` 、 ``9`` 和 ``16``。然而，真的试过就会发现，他们都会返回 ``16`` ："

#:../../faq/programming.rst:220
msgid""
"This happens because ``x`` is not local to the lambdas, but is defined in "
"the outer scope, and it is accessed when the lambda is called --- not when "
"it is defined. At the end of the loop, the value of ``x`` is ``4``, so all "
"the functions now return ``4**2``, i.e. ``16``. You can also verify this by"
" changing the value of ``x`` and see how the results of the lambdas change::"
msgstr""
"这是因为 ``x`` 不是 lambda 函数的内部变量，而是定义于外部作用域中的，并且 ``x`` 是在调用 lambda "
"时访问的——而不是在定义时访问。循环结束时 ``x`` 的值是 ``4`` ，所以此时所有的函数都将返回 ``4**2`` ，即 ``16`` "
"。通过改变 ``x`` 的值并查看 lambda 的结果变化，也可以验证这一点。"

#:../../faq/programming.rst:230
msgid""
"In order to avoid this, you need to save the values in variables local to "
"the lambdas, so that they don't rely on the value of the global ``x``::"
msgstr"为了避免发生上述情况，需要将值保存在 lambda 局部变量，以使其不依赖于全局 ``x`` 的值："

#:../../faq/programming.rst:237
msgid""
"Here, ``n=x`` creates a new variable ``n`` local to the lambda and computed "
"when the lambda is defined so that it has the same value that ``x`` had at "
"that point in the loop. This means that the value of ``n`` will be ``0`` in"
" the first lambda, ``1`` in the second, ``2`` in the third, and so on. "
"Therefore each lambda will now return the correct result::"
msgstr""
"以上 ``n=x`` 创建了一个新的 lambda 本地变量 ``n``，并在定义 lambda 时计算其值，使其与循环当前时点的 ``x`` "
"值相同。这意味着 ``n`` 的值在第 1 个 lambda 中为 ``0`` ，在第 2 个 lambda 中为 ``1`` ，在第 3 个中为 "
"``2``，依此类推。因此现在每个 lambda 都会返回正确结果："

#:../../faq/programming.rst:248
msgid""
"Note that this behaviour is not peculiar to lambdas, but applies to regular "
"functions too."
msgstr"请注意，上述表现并不是 lambda 所特有的，常规的函数也同样适用。"

#:../../faq/programming.rst:253
msgid"How do I share global variables across modules?"
msgstr"如何跨模块共享全局变量？"

#:../../faq/programming.rst:255
msgid""
"The canonical way to share information across modules within a single "
"program is to create a special module (often called config or cfg). Just "
"import the config module in all modules of your application; the module then"
" becomes available as a global name. Because there is only one instance of "
"each module, any changes made to the module object get reflected everywhere."
" For example:"
msgstr""
"在单个程序中跨模块共享信息的规范方法是创建一个特殊模块（通常称为 config 或 cfg）。只需在应用程序的所有模块中导入该 config "
"模块；然后该模块就可当作全局名称使用了。因为每个模块只有一个实例，所以对该模块对象所做的任何更改将会在所有地方得以体现。 例如："

#:../../faq/programming.rst:261
msgid"config.py::"
msgstr"config.py："

#:../../faq/programming.rst:265
msgid"mod.py::"
msgstr"mod.py："

#:../../faq/programming.rst:270
msgid"main.py::"
msgstr"main.py："

#:../../faq/programming.rst:276
msgid""
"Note that using a module is also the basis for implementing the Singleton "
"design pattern, for the same reason."
msgstr"请注意，出于同样的原因，采用模块也是实现单例设计模式的基础。"

#:../../faq/programming.rst:281
msgid"What are the \"best practices\" for using import in a module?"
msgstr"导入模块的“最佳实践”是什么？"

#:../../faq/programming.rst:283
msgid""
"In general, don't use ``from modulename import *``. Doing so clutters the "
"importer's namespace, and makes it much harder for linters to detect "
"undefined names."
msgstr""
"通常请勿使用 ``from modulename import *`` 。因为这会扰乱 importer 的命名空间，且会造成未定义名称更难以被 "
"Linter 检查出来。"

#:../../faq/programming.rst:287
msgid""
"Import modules at the top of a file. Doing so makes it clear what other "
"modules your code requires and avoids questions of whether the module name "
"is in scope. Using one import per line makes it easy to add and delete "
"module imports, but using multiple imports per line uses less screen space."
msgstr""
"请在代码文件的首部就导入模块。这样代码所需的模块就一目了然了，也不用考虑模块名是否在作用域内的问题。每行导入一个模块则增删起来会比较容易，每行导入多个模块则更节省屏幕空间。"

#:../../faq/programming.rst:292
msgid"It's good practice if you import modules in the following order:"
msgstr"按如下顺序导入模块就是一种好做法："

#:../../faq/programming.rst:294
msgid"standard library modules -- e.g. ``sys``, ``os``, ``getopt``, ``re``"
msgstr"标准库模块——比如： ``sys`` 、 ``os`` 、 ``getopt`` 、 ``re`` 等。"

#:../../faq/programming.rst:295
msgid""
"third-party library modules (anything installed in Python's site-packages "
"directory) -- e.g. mx.DateTime, ZODB, PIL.Image, etc."
msgstr""
"第三方库模块（安装于 Python site-packages 目录中的内容）——如 mx.DateTime、ZODB、PIL.Image 等。"

#:../../faq/programming.rst:297
msgid"locally-developed modules"
msgstr"本地开发的模块"

#:../../faq/programming.rst:299
msgid""
"It is sometimes necessary to move imports to a function or class to avoid "
"problems with circular imports. Gordon McMillan says:"
msgstr"为了避免循环导入引发的问题，有时需要将模块导入语句移入函数或类的内部。Gordon McMillan 的说法如下："

#:../../faq/programming.rst:302
msgid""
"Circular imports are fine where both modules use the \"import <module>\" "
"form of import. They fail when the 2nd module wants to grab a name out of "
"the first (\"from module import name\") and the import is at the top level."
" That's because names in the 1st are not yet available, because the first "
"module is busy importing the 2nd."
msgstr""
"当两个模块都采用 \"import <module>\" 的导入形式时，循环导入是没有问题的。但如果第 2 个模块想从第 1 "
"个模块中取出一个名称（\"from module import name\"）并且导入处于代码的最顶层，那导入就会失败。原因是第 1 "
"个模块中的名称还不可用，这时第 1 个模块正忙于导入第 2 个模块呢。"

#:../../faq/programming.rst:308
msgid""
"In this case, if the second module is only used in one function, then the "
"import can easily be moved into that function. By the time the import is "
"called, the first module will have finished initializing, and the second "
"module can do its import."
msgstr""
"如果只是在一个函数中用到第 2 个模块，那这时将导入语句移入该函数内部即可。当调用到导入语句时，第 1 个模块将已经完成初始化，第 2 "
"个模块就可以进行导入了。"

#:../../faq/programming.rst:313
msgid""
"It may also be necessary to move imports out of the top level of code if "
"some of the modules are platform-specific. In that case, it may not even be"
" possible to import all of the modules at the top of the file. In this "
"case, importing the correct modules in the corresponding platform-specific "
"code is a good option."
msgstr""
"如果某些模块是平台相关的，可能还需要把导入语句移出最顶级代码。这种情况下，甚至有可能无法导入文件首部的所有模块。于是在对应的平台相关代码中导入正确的模块，就是一种不错的选择。"

#:../../faq/programming.rst:318
msgid""
"Only move imports into a local scope, such as inside a function definition, "
"if it's necessary to solve a problem such as avoiding a circular import or "
"are trying to reduce the initialization time of a module. This technique is"
" especially helpful if many of the imports are unnecessary depending on how "
"the program executes. You may also want to move imports into a function if "
"the modules are only ever used in that function. Note that loading a module"
" the first time may be expensive because of the one time initialization of "
"the module, but loading a module multiple times is virtually free, costing "
"only a couple of dictionary lookups. Even if the module name has gone out "
"of scope, the module is probably available in :data:`sys.modules`."
msgstr""
"只有为了避免循环导入问题，或有必要减少模块初始化时间时，才把导入语句移入类似函数定义内部的局部作用域。如果根据程序的执行方式，许多导入操作不是必需的，那么这种技术尤其有用。如果模块仅在某个函数中用到，可能还要将导入操作移入该函数内部。请注意，因为模块有一次初始化过程，所以第一次加载模块的代价可能会比较高，但多次加载几乎没有什么花费，代价只是进行几次字典检索而已。即使模块名超出了作用域，模块在"
" :data:`sys.modules` 中也是可用的。 "

#:../../faq/programming.rst:331
msgid"Why are default values shared between objects?"
msgstr"为什么对象之间会共享默认值？"

#:../../faq/programming.rst:333
msgid""
"This type of bug commonly bites neophyte programmers. Consider this "
"function::"
msgstr"新手程序员常常中招这类 Bug。请看以下函数："

#:../../faq/programming.rst:340
msgid""
"The first time you call this function, ``mydict`` contains a single item. "
"The second time, ``mydict`` contains two items because when ``foo()`` begins"
" executing, ``mydict`` starts out with an item already in it."
msgstr""
"第一次调用此函数时， ``mydict`` 中只有一个数据项。第二次调用 ``mydict`` 则会包含两个数据项，因为 ``foo()`` "
"开始执行时， ``mydict`` 中已经带有一个数据项了。"

#:../../faq/programming.rst:344
msgid""
"It is often expected that a function call creates new objects for default "
"values. This is not what happens. Default values are created exactly once, "
"when the function is defined. If that object is changed, like the "
"dictionary in this example, subsequent calls to the function will refer to "
"this changed object."
msgstr""
"大家往往希望，函数调用会为默认值创建新的对象。但事实并非如此。默认值只会在函数定义时创建一次。如果对象发生改变，就如上例中的字典那样，则后续调用该函数时将会引用这个改动的对象。"

#:../../faq/programming.rst:349
msgid""
"By definition, immutable objects such as numbers, strings, tuples, and "
"``None``, are safe from change. Changes to mutable objects such as "
"dictionaries, lists, and class instances can lead to confusion."
msgstr""
"按照定义，不可变对象改动起来是安全的，诸如数字、字符串、元组和 ``None`` 之类。而可变对象的改动则可能引起困惑，例如字典、列表和类实例等。"

#:../../faq/programming.rst:353
msgid""
"Because of this feature, it is good programming practice to not use mutable "
"objects as default values. Instead, use ``None`` as the default value and "
"inside the function, check if the parameter is ``None`` and create a new "
"list/dictionary/whatever if it is. For example, don't write::"
msgstr""
"因此，不把可变对象用作默认值是一种良好的编程做法。而应采用 ``None`` 作为默认值，然后在函数中检查参数是否为 ``None`` "
"并新建列表、字典或其他对象。例如，代码不应如下所示："

#:../../faq/programming.rst:361
msgid"but::"
msgstr"而应这么写："

#:../../faq/programming.rst:367
msgid""
"This feature can be useful. When you have a function that's time-consuming "
"to compute, a common technique is to cache the parameters and the resulting "
"value of each call to the function, and return the cached value if the same "
"value is requested again. This is called \"memoizing\", and can be "
"implemented like this::"
msgstr""
"参数默认值的特性有时会很有用处。 "
"如果有个函数的计算过程会比较耗时，有一种常见技巧是将每次函数调用的参数和结果缓存起来，并在同样的值被再次请求时返回缓存的值。这种技巧被称为“memoize”，实现代码可如下所示："

#:../../faq/programming.rst:382
msgid""
"You could use a global variable containing a dictionary instead of the "
"default value; it's a matter of taste."
msgstr"也可以不用参数默认值来实现，而是采用全局的字典变量；这取决于个人偏好。"

#:../../faq/programming.rst:387
msgid""
"How can I pass optional or keyword parameters from one function to another?"
msgstr"如何将可选参数或关键字参数从一个函数传递到另一个函数？"

#:../../faq/programming.rst:389
msgid""
"Collect the arguments using the ``*`` and ``**`` specifiers in the "
"function's parameter list; this gives you the positional arguments as a "
"tuple and the keyword arguments as a dictionary. You can then pass these "
"arguments when calling another function by using ``*`` and ``**``::"
msgstr""
"请利用函数参数列表中的标识符 ``*`` 和 ``**`` 归集实参；结果会是元组形式的位置实参和字典形式的关键字实参。然后就可利用 ``*`` 和 "
"``**`` 在调用其他函数时传入这些实参："

#:../../faq/programming.rst:408
msgid"What is the difference between arguments and parameters?"
msgstr"形参和实参之间有什么区别？"

#:../../faq/programming.rst:410
msgid""
":term:`Parameters <parameter>` are defined by the names that appear in a "
"function definition, whereas :term:`arguments <argument>` are the values "
"actually passed to a function when calling it. Parameters define what types"
" of arguments a function can accept. For example, given the function "
"definition::"
msgstr""
":term:`形参 <parameter>` 是指出现在函数定义中的名称，而 :term:`实参 <argument>` 则是在调用函数时实际传入的值。"
" 形参定义了一个函数能接受何种类型的实参。 例如，对于以下函数定义::"

#:../../faq/programming.rst:418
msgid""
"*foo*, *bar* and *kwargs* are parameters of ``func``. However, when calling"
" ``func``, for example::"
msgstr"*foo* 、 *bar* 和 *kwargs* 是 ``func`` 的形参。 不过在调用 ``func`` 时，例如："

#:../../faq/programming.rst:423
msgid"the values ``42``, ``314``, and ``somevar`` are arguments."
msgstr"``42`` 、 ``314`` 和 ``somevar`` 则是实参。"

#:../../faq/programming.rst:427
msgid"Why did changing list 'y' also change list 'x'?"
msgstr"为什么修改列表 'y' 也会更改列表 'x'？"

#:../../faq/programming.rst:429
msgid"If you wrote code like::"
msgstr"如果代码编写如下："

#:../../faq/programming.rst:439
msgid""
"you might be wondering why appending an element to ``y`` changed ``x`` too."
msgstr"或许大家很想知道，为什么在 y 中添加一个元素时， x 也会改变。"

#:../../faq/programming.rst:441
msgid"There are two factors that produce this result:"
msgstr"产生这种结果有两个因素："

#:../../faq/programming.rst:443
msgid""
"Variables are simply names that refer to objects. Doing ``y = x`` doesn't "
"create a copy of the list -- it creates a new variable ``y`` that refers to "
"the same object ``x`` refers to. This means that there is only one object "
"(the list), and both ``x`` and ``y`` refer to it."
msgstr""
"变量只是指向对象的一个名称。执行 ``y = x`` 并不会创建列表的副本——而只是创建了一个新变量 ``y``，并指向 ``x`` "
"所指的同一对象。这就意味着只存在一个列表对象，``x`` 和 ``y`` 都是对它的引用。"

#:../../faq/programming.rst:447
msgid""
"Lists are :term:`mutable`, which means that you can change their content."
msgstr"列表属于 :term:`mutable` 对象，这意味着它的内容是可以修改的。"

#:../../faq/programming.rst:449
msgid""
"After the call to :meth:`~list.append`, the content of the mutable object "
"has changed from ``[]`` to ``[10]``. Since both the variables refer to the "
"same object, using either name accesses the modified value ``[10]``."
msgstr""
"在调用 :meth:`~list.append` 之后，该可变对象的内容由 ``[]`` 变为 ``[10]``。由于 x 和 y "
"这两个变量引用了同一对象，因此用其中任意一个名称所访问到的都是修改后的值 ``[10]``。"

#:../../faq/programming.rst:453
msgid"If we instead assign an immutable object to ``x``::"
msgstr"如果把赋给 ``x`` 的对象换成一个不可变对象："

#:../../faq/programming.rst:463
msgid""
"we can see that in this case ``x`` and ``y`` are not equal anymore. This is"
" because integers are :term:`immutable`, and when we do ``x = x + 1`` we are"
" not mutating the int ``5`` by incrementing its value; instead, we are "
"creating a new object (the int ``6``) and assigning it to ``x`` (that is, "
"changing which object ``x`` refers to). After this assignment we have two "
"objects (the ints ``6`` and ``5``) and two variables that refer to them "
"(``x`` now refers to ``6`` but ``y`` still refers to ``5``)."
msgstr""
"可见这时 ``x`` 和 ``y`` 就不再相等了。因为整数是 :term:`immutable` 对象，在执行 ``x = x + 1`` "
"时，并不会修改整数对象 ``5``，给它加上 1；而是创建了一个新的对象（整数对象 ``6`` ）并将其赋给 ``x`` （也就是改变了 ``x`` "
"所指向的对象）。在赋值完成后，就有了两个对象（整数对象 ``6`` 和 ``5`` ）和分别指向他俩的两个变量（ ``x`` 现在指向 ``6`` 而 "
"``y`` 仍然指向 ``5`` ）。"

#:../../faq/programming.rst:471
msgid""
"Some operations (for example ``y.append(10)`` and ``y.sort()``) mutate the "
"object, whereas superficially similar operations (for example ``y = y + "
"[10]`` and ``sorted(y)``) create a new object. In general in Python (and in"
" all cases in the standard library) a method that mutates an object will "
"return ``None`` to help avoid getting the two types of operations confused."
" So if you mistakenly write ``y.sort()`` thinking it will give you a sorted"
" copy of ``y``, you'll instead end up with ``None``, which will likely cause"
" your program to generate an easily diagnosed error."
msgstr""
"某些操作（例如 ``y.append(10)`` 和 ``y.sort()`` ）会直接修改原对象，而看上去相似的另一些操作（例如 ``y = y + "
"[10]`` 和 ``sorted(y)`` ）则会创建新的对象。通常在 Python 中（以及所有标准库），直接修改原对象的方法将会返回 "
"``None`` ，以助避免混淆这两种不同类型的操作。因此如果误用了 ``y.sort()`` 并期望返回 ``y`` 的有序副本，则结果只会是 "
"``None`` ，这可能就能让程序引发一条容易诊断的错误。"

#:../../faq/programming.rst:480
msgid""
"However, there is one class of operations where the same operation sometimes"
" has different behaviors with different types: the augmented assignment "
"operators. For example, ``+=`` mutates lists but not tuples or ints "
"(``a_list += [1, 2, 3]`` is equivalent to ``a_list.extend([1, 2, 3])`` and "
"mutates ``a_list``, whereas ``some_tuple += (1, 2, 3)`` and ``some_int += "
"1`` create new objects)."
msgstr""
"不过还存在一类操作，用不同的类型执行相同的操作有时会发生不同的行为：即增量赋值运算符。例如，``+=`` "
"会修改列表，但不会修改元组或整数（``a_list += [1, 2, 3]`` 与 ``a_list.extend([1, 2, 3])`` "
"同样都会改变 ``a_list``，而 ``some_tuple += (1, 2, 3)`` 和 ``some_int += 1`` "
"则会创建新的对象）。"

#:../../faq/programming.rst:487
msgid"In other words:"
msgstr"换而言之："

#:../../faq/programming.rst:489
msgid""
"If we have a mutable object (:class:`list`, :class:`dict`, :class:`set`, "
"etc.), we can use some specific operations to mutate it and all the "
"variables that refer to it will see the change."
msgstr""
"对于一个可变对象（ :class:`list` 、 :class:`dict` 、 :class:`set` "
"等等），可以利用某些特定的操作进行修改，所有引用它的变量都会反映出改动情况。"

#:../../faq/programming.rst:492
msgid""
"If we have an immutable object (:class:`str`, :class:`int`, :class:`tuple`, "
"etc.), all the variables that refer to it will always see the same value, "
"but operations that transform that value into a new value always return a "
"new object."
msgstr""
"对于一个不可变对象（ :class:`str` 、 :class:`int` 、 :class:`tuple` "
"等），所有引用它的变量都会给出相同的值，但所有改变其值的操作都将返回一个新的对象。"

#:../../faq/programming.rst:497
msgid""
"If you want to know if two variables refer to the same object or not, you "
"can use the :keyword:`is` operator, or the built-in function :func:`id`."
msgstr"如要知道两个变量是否指向同一个对象，可以利用 :keyword:`is` 运算符或内置函数 :func:`id`。"

#:../../faq/programming.rst:502
msgid"How do I write a function with output parameters (call by reference)?"
msgstr"如何编写带有输出参数的函数（按照引用调用）？"

#:../../faq/programming.rst:504
msgid""
"Remember that arguments are passed by assignment in Python. Since "
"assignment just creates references to objects, there's no alias between an "
"argument name in the caller and callee, and so no call-by-reference per se."
" You can achieve the desired effect in a number of ways."
msgstr""
"请记住，Python "
"中的实参是通过赋值传递的。由于赋值只是创建了对象的引用，所以调用方和被调用方的参数名都不存在别名，本质上也就不存在按引用调用的方式。通过以下几种方式，可以得到所需的效果。"

#:../../faq/programming.rst:509
msgid"By returning a tuple of the results::"
msgstr"返回一个元组："

#:../../faq/programming.rst:520
msgid"This is almost always the clearest solution."
msgstr"这差不多是最明晰的解决方案了。"

#:../../faq/programming.rst:522
msgid""
"By using global variables. This isn't thread-safe, and is not recommended."
msgstr"使用全局变量。这不是线程安全的方案，不推荐使用。"

#:../../faq/programming.rst:524
msgid"By passing a mutable (changeable in-place) object::"
msgstr"传递一个可变（即可原地修改的） 对象："

#:../../faq/programming.rst:535
msgid"By passing in a dictionary that gets mutated::"
msgstr"传入一个接收可变对象的字典::"

#:../../faq/programming.rst:546
msgid"Or bundle up values in a class instance::"
msgstr"或者把值用类实例封装起来："

#:../../faq/programming.rst:563
msgid"There's almost never a good reason to get this complicated."
msgstr"没有什么理由要把问题搞得这么复杂。"

#:../../faq/programming.rst:565
msgid"Your best choice is to return a tuple containing the multiple results."
msgstr"最佳选择就是返回一个包含多个结果值的元组。"

#:../../faq/programming.rst:569
msgid"How do you make a higher order function in Python?"
msgstr"如何在 Python 中创建高阶函数？"

#:../../faq/programming.rst:571
msgid""
"You have two choices: you can use nested scopes or you can use callable "
"objects. For example, suppose you wanted to define ``linear(a,b)`` which "
"returns a function ``f(x)`` that computes the value ``a*x+b``. Using nested"
" scopes::"
msgstr""
"有两种选择：嵌套作用域、可调用对象。假定需要定义 ``linear(a,b)`` ，其返回结果是一个计算出 ``a*x+b`` 的函数 "
"``f(x)``。 采用嵌套作用域的方案如下："

#:../../faq/programming.rst:580
msgid"Or using a callable object::"
msgstr"或者可采用可调用对象："

#:../../faq/programming.rst:590
msgid"In both cases, ::"
msgstr"采用这两种方案时："

#:../../faq/programming.rst:594
msgid"gives a callable object where ``taxes(10e6) == 0.3 * 10e6 + 2``."
msgstr"都会得到一个可调用对象，可实现 ``taxes(10e6) == 0.3 * 10e6 + 2`` 。"

#:../../faq/programming.rst:596
msgid""
"The callable object approach has the disadvantage that it is a bit slower "
"and results in slightly longer code. However, note that a collection of "
"callables can share their signature via inheritance::"
msgstr"可调用对象的方案有个缺点，就是速度稍慢且生成的代码略长。不过值得注意的是，同一组可调用对象能够通过继承来共享签名（类声明）："

#:../../faq/programming.rst:605
msgid"Object can encapsulate state for several methods::"
msgstr"对象可以为多个方法的运行状态进行封装："

#:../../faq/programming.rst:623
msgid""
"Here ``inc()``, ``dec()`` and ``reset()`` act like functions which share the"
" same counting variable."
msgstr"以上 ``inc()`` 、 ``dec()`` 和 ``reset()`` 的表现，就如同共享了同一计数变量一样。"

#:../../faq/programming.rst:628
msgid"How do I copy an object in Python?"
msgstr"如何复制 Python 对象？"

#:../../faq/programming.rst:630
msgid""
"In general, try :func:`copy.copy` or :func:`copy.deepcopy` for the general "
"case. Not all objects can be copied, but most can."
msgstr""
"一般情况下，用 :func:`copy.copy` 或 :func:`copy.deepcopy` "
"基本就可以了。并不是所有对象都支持复制，但多数是可以的。"

#:../../faq/programming.rst:633
msgid""
"Some objects can be copied more easily. Dictionaries have a "
":meth:`~dict.copy` method::"
msgstr"某些对象可以用更简便的方法进行复制。比如字典对象就提供了 :meth:`~dict.copy` 方法："

#:../../faq/programming.rst:638
msgid"Sequences can be copied by slicing::"
msgstr"序列可以用切片操作进行复制："

#:../../faq/programming.rst:644
msgid"How can I find the methods or attributes of an object?"
msgstr"如何找到对象的方法或属性？"

#:../../faq/programming.rst:646
msgid""
"For an instance x of a user-defined class, ``dir(x)`` returns an "
"alphabetized list of the names containing the instance attributes and "
"methods and attributes defined by its class."
msgstr"假定 x 是一个用户自定义类的实例，``dir(x)`` 将返回一个按字母排序的名称列表，其中包含了实例的属性及由类定义的方法和属性。 "

#:../../faq/programming.rst:652
msgid"How can my code discover the name of an object?"
msgstr"如何用代码获取对象的名称？"

#:../../faq/programming.rst:654
msgid""
"Generally speaking, it can't, because objects don't really have names. "
"Essentially, assignment always binds a name to a value; the same is true of "
"``def`` and ``class`` statements, but in that case the value is a callable. "
"Consider the following code::"
msgstr""
"一般而言这是无法实现的，因为对象并不存在真正的名称。赋值本质上是把某个名称绑定到某个值上；``def`` 和 ``class`` "
"语句同样如此，只是值换成了某个可调用对象。比如以下代码："

#:../../faq/programming.rst:670
msgid""
"Arguably the class has a name: even though it is bound to two names and "
"invoked through the name B the created instance is still reported as an "
"instance of class A. However, it is impossible to say whether the "
"instance's name is a or b, since both names are bound to the same value."
msgstr""
"可以不太严谨地说，上述类具有一个名称：即便它绑定了两个名称并通过名称 B 发起调用，可是创建出来的实例仍被视为是类 A 的实例。但无法说出实例的名称是 "
"a 还是 b，因为这两个名称都被绑定到同一个值上了。"

#:../../faq/programming.rst:675
msgid""
"Generally speaking it should not be necessary for your code to \"know the "
"names\" of particular values. Unless you are deliberately writing "
"introspective programs, this is usually an indication that a change of "
"approach might be beneficial."
msgstr"代码一般没有必要去“知晓”某个值的名称。通常这种需求预示着还是改变方案为好，除非真的是要编写内审程序。"

#:../../faq/programming.rst:680
msgid""
"In comp.lang.python, Fredrik Lundh once gave an excellent analogy in answer "
"to this question:"
msgstr"在 comp.lang.python 中，Fredrik Lundh 在回答这样的问题时曾经给出过一个绝佳的类比："

#:../../faq/programming.rst:683
msgid""
"The same way as you get the name of that cat you found on your porch: the "
"cat (object) itself cannot tell you its name, and it doesn't really care -- "
"so the only way to find out what it's called is to ask all your neighbours "
"(namespaces) if it's their cat (object)..."
msgstr""
"这就像要知道家门口的那只猫的名字一样：猫（对象）自己不会说出它的名字，它根本就不在乎自己叫什么——所以唯一方法就是问一遍你所有的邻居（命名空间），这是不是他们家的猫（对象）……"

#:../../faq/programming.rst:688
msgid""
"....and don't be surprised if you'll find that it's known by many names, or "
"no name at all!"
msgstr"……并且如果你发现它有很多名字或根本没有名字，那也不必惊讶！"

#:../../faq/programming.rst:693
msgid"What's up with the comma operator's precedence?"
msgstr"逗号运算符的优先级是什么？"

#:../../faq/programming.rst:695
msgid"Comma is not an operator in Python. Consider this session::"
msgstr"逗号不是 Python 的运算符。 请看以下例子："

#:../../faq/programming.rst:700
msgid""
"Since the comma is not an operator, but a separator between expressions the "
"above is evaluated as if you had entered::"
msgstr"由于逗号不是运算符，而只是表达式之间的分隔符，因此上述代码就相当于："

#:../../faq/programming.rst:705
msgid"not::"
msgstr"而不是："

#:../../faq/programming.rst:709
msgid""
"The same is true of the various assignment operators (``=``, ``+=`` etc). "
"They are not truly operators but syntactic delimiters in assignment "
"statements."
msgstr"对于各种赋值运算符（ ``=`` 、 ``+=`` 等）来说同样如此。他们并不是真正的运算符，而只是赋值语句中的语法分隔符。"

#:../../faq/programming.rst:714
msgid"Is there an equivalent of C's \"?:\" ternary operator?"
msgstr"是否提供等价于 C 语言 \"?:\" 三目运算符的东西？"

#:../../faq/programming.rst:716
msgid"Yes, there is. The syntax is as follows::"
msgstr"有的。语法如下："

#:../../faq/programming.rst:723
msgid""
"Before this syntax was introduced in Python 2.5, a common idiom was to use "
"logical operators::"
msgstr"在 Python 2.5 引入上述语法之前，通常的做法是使用逻辑运算符："

#:../../faq/programming.rst:728
msgid""
"However, this idiom is unsafe, as it can give wrong results when *on_true* "
"has a false boolean value. Therefore, it is always better to use the ``... "
"if ... else ...`` form."
msgstr""
"然而这种做法并不保险，因为当 *on_true* 为布尔值“假”时，结果将会出错。所以肯定还是采用 ``... if ... else ...`` "
"形式为妙。"

#:../../faq/programming.rst:734
msgid"Is it possible to write obfuscated one-liners in Python?"
msgstr"是否可以用 Python 编写让人眼晕的单行程序?"

#:../../faq/programming.rst:736
msgid""
"Yes. Usually this is done by nesting :keyword:`lambda` within "
":keyword:`!lambda`. See the following three examples, due to Ulf Bartelt::"
msgstr""
"可以。通常是在 :keyword:`lambda` 中嵌套 :keyword:`!lambda` 来实现的。请参阅以下三个来自 Ulf Bartelt "
"的示例代码："

#:../../faq/programming.rst:763
msgid"Don't try this at home, kids!"
msgstr"请不要在家里尝试，骚年！"

#:../../faq/programming.rst:769
msgid"What does the slash(/) in the parameter list of a function mean?"
msgstr"函数形参列表中的斜杠（/）是什么意思？"

#:../../faq/programming.rst:771
msgid""
"A slash in the argument list of a function denotes that the parameters prior"
" to it are positional-only. Positional-only parameters are the ones without"
" an externally-usable name. Upon calling a function that accepts "
"positional-only parameters, arguments are mapped to parameters based solely "
"on their position. For example, :func:`divmod` is a function that accepts "
"positional-only parameters. Its documentation looks like this::"
msgstr""
"函数参数列表中的斜杠表示在它之前的形参全都仅限位置形参。仅限位置形参没有可供外部使用的名称。在调用仅接受位置形参的函数时，实参只会根据位置映射到形参上。假定"
" :func:`divmod` 是一个仅接受位置形参的函数。 它的帮助文档如下所示："

#:../../faq/programming.rst:784
msgid""
"The slash at the end of the parameter list means that both parameters are "
"positional-only. Thus, calling :func:`divmod` with keyword arguments would "
"lead to an error::"
msgstr"形参列表尾部的斜杠说明，两个形参都是仅限位置形参。因此，用关键字参数调用 :func:`divmod` 将会引发错误："