# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-07-25 16:03+0000\n"
"PO-Revision-Date: 2025-07-18 19:59+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\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"

#: ../../tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Python 速览"

#: ../../tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears;"
" lines that do not begin with a prompt are output from the interpreter. Note"
" that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"下面的例子以是否显示提示符（:term:`>>>` 与 "
":term:`...`）区分输入与输出：输入例子中的代码时，要键入以提示符开头的行中提示符后的所有内容；未以提示符开头的行是解释器的输出。注意，例子中的某行出现的第二个提示符是用来结束多行命令的，此时，要键入一个空白行。"

#: ../../tutorial/introduction.rst:16
msgid ""
"You can toggle the display of prompts and output by clicking on ``>>>`` in "
"the upper-right corner of an example box.  If you hide the prompts and "
"output for an example, then you can easily copy and paste the input lines "
"into your interpreter."
msgstr ""
"你可以通过在示例方块右上角的 ``>>>`` 上点击来切换显示提示符和输出。 "
"如果你隐藏了一个示例的提示符和输出，那么你可以方便地将输入行复制并粘贴到你的解释器中。"

#: ../../tutorial/introduction.rst:23
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments.  Comments in Python start with the hash character,"
" ``#``, and extend to the end of the physical line.  A comment may appear at"
" the start of a line or following whitespace or code, but not within a "
"string literal.  A hash character within a string literal is just a hash "
"character. Since comments are to clarify code and are not interpreted by "
"Python, they may be omitted when typing in examples."
msgstr ""
"本手册中的许多例子，甚至交互式命令都包含注释。Python 注释以 ``#`` "
"开头，直到该物理行结束。注释可以在行开头，或空白符与代码之后，但不能在字符串里面。字符串中的 # 号就是 # 号。注释用于阐明代码，Python "
"不解释注释，键入例子时，可以不输入注释。"

#: ../../tutorial/introduction.rst:31
msgid "Some examples::"
msgstr "示例如下："

#: ../../tutorial/introduction.rst:33
msgid ""
"# this is the first comment\n"
"spam = 1  # and this is the second comment\n"
"          # ... and now a third!\n"
"text = \"# This is not a comment because it's inside quotes.\""
msgstr ""
"# 这是第一条注释\n"
"spam = 1  # 而这是第二条注释\n"
"          # ... 而这是第三条！\n"
"text = \"# 这不是注释因为它是在引号之内。\""

#: ../../tutorial/introduction.rst:42
msgid "Using Python as a Calculator"
msgstr "Python 用作计算器"

#: ../../tutorial/introduction.rst:44
msgid ""
"Let's try some simple Python commands.  Start the interpreter and wait for "
"the primary prompt, ``>>>``.  (It shouldn't take long.)"
msgstr "现在，尝试一些简单的 Python 命令。启动解释器，等待主提示符（``>>>`` ）出现。"

#: ../../tutorial/introduction.rst:51
msgid "Numbers"
msgstr "数字"

#: ../../tutorial/introduction.rst:53
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value.  Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` can be used to perform arithmetic; "
"parentheses (``()``) can be used for grouping. For example::"
msgstr ""
"解释器像一个简单的计算器：你可以输入一个表达式，它将给出结果值。 表达式语法很直观：运算符 ``+``, ``-``, ``*`` 和 ``/`` "
"可被用来执行算术运算；圆括号 (``()``) 可被用来进行分组。 例如::"

#: ../../tutorial/introduction.rst:59
msgid ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # division always returns a floating-point number\n"
"1.6"
msgstr ""
">>> 2 + 2\n"
"4\n"
">>> 50 - 5*6\n"
"20\n"
">>> (50 - 5*6) / 4\n"
"5.0\n"
">>> 8 / 5  # 除法运算总是返回一个浮点数\n"
"1.6"

#: ../../tutorial/introduction.rst:68
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type "
":class:`float`.  We will see more about numeric types later in the tutorial."
msgstr ""
"整数（如，``2``、``4``、``20`` ）的类型是 :class:`int`，带小数（如，``5.0``、``1.6`` ）的类型是 "
":class:`float`。本教程后半部分将介绍更多数字类型。"

#: ../../tutorial/introduction.rst:72
msgid ""
"Division (``/``) always returns a float.  To do :term:`floor division` and "
"get an integer result you can use the ``//`` operator; to calculate the "
"remainder you can use ``%``::"
msgstr ""
"除法运算 (``/``) 总是返回浮点数。 如果要做 :term:`floor division` 得到一个整数结果你可以使用 ``//`` "
"运算符；要计算余数你可以使用 ``%``::"

#: ../../tutorial/introduction.rst:76
msgid ""
">>> 17 / 3  # classic division returns a float\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # floor division discards the fractional part\n"
"5\n"
">>> 17 % 3  # the % operator returns the remainder of the division\n"
"2\n"
">>> 5 * 3 + 2  # floored quotient * divisor + remainder\n"
"17"
msgstr ""
">>> 17 / 3  # 经典除法运算返回一个浮点数\n"
"5.666666666666667\n"
">>>\n"
">>> 17 // 3  # 向下取整除法运算会丢弃小数部分\n"
"5\n"
">>> 17 % 3  # % 运算返回相除的余数\n"
"2\n"
">>> 5 * 3 + 2  # 向下取整的商 * 除数 + 余数\n"
"17"

#: ../../tutorial/introduction.rst:86
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr "Python 用 ``**`` 运算符计算乘方 [#]_："

#: ../../tutorial/introduction.rst:88
msgid ""
">>> 5 ** 2  # 5 squared\n"
"25\n"
">>> 2 ** 7  # 2 to the power of 7\n"
"128"
msgstr ""
">>> 5 ** 2  # 5 的平方\n"
"25\n"
">>> 2 ** 7  # 2 的 7 次方\n"
"128"

#: ../../tutorial/introduction.rst:93
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr "等号（``=``）用于给变量赋值。赋值后，下一个交互提示符的位置不显示任何结果："

#: ../../tutorial/introduction.rst:96
msgid ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"
msgstr ""
">>> width = 20\n"
">>> height = 5 * 9\n"
">>> width * height\n"
"900"

#: ../../tutorial/introduction.rst:101
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr "如果变量未定义（即，未赋值），使用该变量会提示错误："

#: ../../tutorial/introduction.rst:104
msgid ""
">>> n  # try to access an undefined variable\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"
msgstr ""
">>> n  # 试图访问一个未定义的变量\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"NameError: name 'n' is not defined"

#: ../../tutorial/introduction.rst:109
msgid ""
"There is full support for floating point; operators with mixed type operands"
" convert the integer operand to floating point::"
msgstr "Python 全面支持浮点数；混合类型运算数的运算会把整数转换为浮点数："

#: ../../tutorial/introduction.rst:112
msgid ""
">>> 4 * 3.75 - 1\n"
"14.0"
msgstr ""
">>> 4 * 3.75 - 1\n"
"14.0"

#: ../../tutorial/introduction.rst:115
msgid ""
"In interactive mode, the last printed expression is assigned to the variable"
" ``_``.  This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr "交互模式下，上次输出的表达式会赋给变量 ``_``。把 Python 当作计算器时，用该变量实现下一步计算更简单，例如："

#: ../../tutorial/introduction.rst:119
msgid ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"
msgstr ""
">>> tax = 12.5 / 100\n"
">>> price = 100.50\n"
">>> price * tax\n"
"12.5625\n"
">>> price + _\n"
"113.0625\n"
">>> round(_, 2)\n"
"113.06"

#: ../../tutorial/introduction.rst:128
msgid ""
"This variable should be treated as read-only by the user.  Don't explicitly "
"assign a value to it --- you would create an independent local variable with"
" the same name masking the built-in variable with its magic behavior."
msgstr "最好把该变量当作只读类型。不要为它显式赋值，否则会创建一个同名独立局部变量，该变量会用它的魔法行为屏蔽内置变量。"

#: ../../tutorial/introduction.rst:132
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and "
":class:`~fractions.Fraction`. Python also has built-in support for "
":ref:`complex numbers <typesnumeric>`, and uses the ``j`` or ``J`` suffix to"
" indicate the imaginary part (e.g. ``3+5j``)."
msgstr ""
"除了 :class:`int` 和 :class:`float`，Python 还支持其他数字类型，例如 "
":class:`~decimal.Decimal` 或 :class:`~fractions.Fraction`。Python 还内置支持 "
":ref:`复数 <typesnumeric>`，后缀 ``j`` 或 ``J`` 用于表示虚数（例如 ``3+5j`` ）。"

#: ../../tutorial/introduction.rst:142
msgid "Text"
msgstr "文本"

#: ../../tutorial/introduction.rst:144
msgid ""
"Python can manipulate text (represented by type :class:`str`, so-called "
"\"strings\") as well as numbers.  This includes characters \"``!``\", words "
"\"``rabbit``\", names \"``Paris``\", sentences \"``Got your back.``\", etc. "
"\"``Yay! :)``\". They can be enclosed in single quotes (``'...'``) or double"
" quotes (``\"...\"``) with the same result [#]_."
msgstr ""
"除了数字 Python 还可以操作文本（由 :class:`str` 类型表示，称为“字符串”）。 这包括字符 \"``!``\", 单词 "
"\"``rabbit``\", 名称 \"``Paris``\", 句子 \"``Got your back.``\" 等等. \"``Yay! "
":)``\"。 它们可以用成对的单引号 (``'...'``) 或双引号 (``\"...\"``) 来标示，结果完全相同 [#]_。"

#: ../../tutorial/introduction.rst:157
msgid ""
"To quote a quote, we need to \"escape\" it, by preceding it with ``\\``. "
"Alternatively, we can use the other type of quotation marks::"
msgstr "要标示引号本身，我们需要对它进行“转义”，即在前面加一个 ``\\``。 或者，我们也可以使用不同类型的引号::"

#: ../../tutorial/introduction.rst:160
msgid ""
">>> 'doesn\\'t'  # use \\' to escape the single quote...\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...or use double quotes instead\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"
msgstr ""
">>> 'doesn\\'t'  # 使用 \\' 来转义单引号...\n"
"\"doesn't\"\n"
">>> \"doesn't\"  # ...或者改用双引号\n"
"\"doesn't\"\n"
">>> '\"Yes,\" they said.'\n"
"'\"Yes,\" they said.'\n"
">>> \"\\\"Yes,\\\" they said.\"\n"
"'\"Yes,\" they said.'\n"
">>> '\"Isn\\'t,\" they said.'\n"
"'\"Isn\\'t,\" they said.'"

#: ../../tutorial/introduction.rst:171
msgid ""
"In the Python shell, the string definition and output string can look "
"different.  The :func:`print` function produces a more readable output, by "
"omitting the enclosing quotes and by printing escaped and special "
"characters::"
msgstr ""
"在 Python shell 中，字符串定义和输出字符串看起来可能不同。 :func:`print` "
"函数会略去标示用的引号，并打印经过转义的特殊字符，产生更为易读的输出::"

#: ../../tutorial/introduction.rst:175
msgid ""
">>> s = 'First line.\\nSecond line.'  # \\n means newline\n"
">>> s  # without print(), special characters are included in the string\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # with print(), special characters are interpreted, so \\n produces new line\n"
"First line.\n"
"Second line."
msgstr ""
">>> s = 'First line.\\nSecond line.'  # \\n 表示换行符\n"
">>> s  # 不用 print()，特殊字符将包括在字符串中\n"
"'First line.\\nSecond line.'\n"
">>> print(s)  # 用 print()，特殊字符会被转写，因此 \\n 将产生一个新行\n"
"First line.\n"
"Second line."

#: ../../tutorial/introduction.rst:182
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special"
" characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr "如果不希望前置 ``\\`` 的字符转义成特殊字符，可以使用 *原始字符串*，在引号前添加 ``r`` 即可："

#: ../../tutorial/introduction.rst:186
msgid ""
">>> print('C:\\some\\name')  # here \\n means newline!\n"
"C:\\some\n"
"ame\n"
">>> print(r'C:\\some\\name')  # note the r before the quote\n"
"C:\\some\\name"
msgstr ""
">>> print('C:\\some\\name')  # 这里 \\n 表示换行符！\n"
"C:\\some\n"
"ame\n"
">>> print(r'C:\\some\\name')  # 请注意引号前的 r\n"
"C:\\some\\name"

#: ../../tutorial/introduction.rst:192
msgid ""
"There is one subtle aspect to raw strings: a raw string may not end in an "
"odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-"
"raw-string-backslash>` for more information and workarounds."
msgstr ""
"原始字符串还有一个微妙的限制：一个原始字符串不能以奇数个 ``\\`` 字符结束；请参阅 :ref:`此 FAQ 条目 <faq-"
"programming-raw-string-backslash>` 了解更多信息及绕过的办法。"

#: ../../tutorial/introduction.rst:197
msgid ""
"String literals can span multiple lines.  One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``.  End-of-line characters are "
"automatically included in the string, but it's possible to prevent this by "
"adding a ``\\`` at the end of the line.  In the following example, the "
"initial newline is not included::"
msgstr ""
"字符串字面值可以跨越多行。 一种做法是使用三重引号: ``\"\"\"...\"\"\"`` 或 ``'''...'''``。 "
"行结束符会自动包括在字符串中，但可以通过在行尾添加 ``\\`` 来避免此行为。 在下面的例子中，开头的换行符将不会被包括::"

#: ../../tutorial/introduction.rst:203
msgid ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"
msgstr ""
">>> print(\"\"\"\\\n"
"... Usage: thingy [OPTIONS]\n"
"...      -h                        Display this usage message\n"
"...      -H hostname               Hostname to connect to\n"
"... \"\"\")\n"
"Usage: thingy [OPTIONS]\n"
"     -h                        Display this usage message\n"
"     -H hostname               Hostname to connect to\n"
"\n"
">>>"

#: ../../tutorial/introduction.rst:214
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr "字符串可以用 ``+`` 合并（粘到一起），也可以用 ``*`` 重复："

#: ../../tutorial/introduction.rst:217
msgid ""
">>> # 3 times 'un', followed by 'ium'\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"
msgstr ""
">>> # 3 乘以 'un'，再加 'ium'\n"
">>> 3 * 'un' + 'ium'\n"
"'unununium'"

#: ../../tutorial/introduction.rst:221
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr "相邻的两个或多个 *字符串字面值* （引号标注的字符）会自动合并："

#: ../../tutorial/introduction.rst:224
msgid ""
">>> 'Py' 'thon'\n"
"'Python'"
msgstr ""
">>> 'Py' 'thon'\n"
"'Python'"

#: ../../tutorial/introduction.rst:227
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr "拼接分隔开的长字符串时，这个功能特别实用："

#: ../../tutorial/introduction.rst:229
msgid ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"
msgstr ""
">>> text = ('Put several strings within parentheses '\n"
"...         'to have them joined together.')\n"
">>> text\n"
"'Put several strings within parentheses to have them joined together.'"

#: ../../tutorial/introduction.rst:234
msgid ""
"This only works with two literals though, not with variables or "
"expressions::"
msgstr "这项功能只能用于两个字面值，不能用于变量或表达式："

#: ../../tutorial/introduction.rst:236
msgid ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # can't concatenate a variable and a string literal\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"
msgstr ""
">>> prefix = 'Py'\n"
">>> prefix 'thon'  # 不能拼接变量和字符串字面值\n"
"  File \"<stdin>\", line 1\n"
"    prefix 'thon'\n"
"           ^^^^^^\n"
"SyntaxError: invalid syntax\n"
">>> ('un' * 3) 'ium'\n"
"  File \"<stdin>\", line 1\n"
"    ('un' * 3) 'ium'\n"
"               ^^^^^\n"
"SyntaxError: invalid syntax"

#: ../../tutorial/introduction.rst:248
msgid ""
"If you want to concatenate variables or a variable and a literal, use "
"``+``::"
msgstr "合并多个变量，或合并变量与字面值，要用 ``+``："

#: ../../tutorial/introduction.rst:250
msgid ""
">>> prefix + 'thon'\n"
"'Python'"
msgstr ""
">>> prefix + 'thon'\n"
"'Python'"

#: ../../tutorial/introduction.rst:253
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string"
" of size one::"
msgstr "字符串支持 *索引* （下标访问），第一个字符的索引是 0。单字符没有专用的类型，就是长度为一的字符串："

#: ../../tutorial/introduction.rst:257
msgid ""
">>> word = 'Python'\n"
">>> word[0]  # character in position 0\n"
"'P'\n"
">>> word[5]  # character in position 5\n"
"'n'"
msgstr ""
">>> word = 'Python'\n"
">>> word[0]  # 0 号位的字符\n"
"'P'\n"
">>> word[5]  # 5 号位的字符\n"
"'n'"

#: ../../tutorial/introduction.rst:263
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr "索引还支持负数，用负数索引时，从右边开始计数："

#: ../../tutorial/introduction.rst:265
msgid ""
">>> word[-1]  # last character\n"
"'n'\n"
">>> word[-2]  # second-last character\n"
"'o'\n"
">>> word[-6]\n"
"'P'"
msgstr ""
">>> word[-1]  # 最后一个字符\n"
"'n'\n"
">>> word[-2]  # 倒数第二个字符\n"
"'o'\n"
">>> word[-6]\n"
"'P'"

#: ../../tutorial/introduction.rst:272
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "注意，-0 和 0 一样，因此，负数索引从 -1 开始。"

#: ../../tutorial/introduction.rst:274
msgid ""
"In addition to indexing, *slicing* is also supported.  While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain a "
"substring::"
msgstr "除了索引操作，还支持 *切片*。 索引用来获取单个字符，而 *切片* 允许你获取子字符串::"

#: ../../tutorial/introduction.rst:277
msgid ""
">>> word[0:2]  # characters from position 0 (included) to 2 (excluded)\n"
"'Py'\n"
">>> word[2:5]  # characters from position 2 (included) to 5 (excluded)\n"
"'tho'"
msgstr ""
">>> word[0:2]  # 从 0 号位 (含) 到 2 号位 (不含) 的字符\n"
"'Py'\n"
">>> word[2:5]  # 从 2 号位 (含) 到 5 号位 (不含) 的字符\n"
"'tho'"

#: ../../tutorial/introduction.rst:282
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero,"
" an omitted second index defaults to the size of the string being sliced. ::"
msgstr "切片索引的默认值很有用；省略开始索引时，默认值为 0，省略结束索引时，默认为到字符串的结尾："

#: ../../tutorial/introduction.rst:285
msgid ""
">>> word[:2]   # character from the beginning to position 2 (excluded)\n"
"'Py'\n"
">>> word[4:]   # characters from position 4 (included) to the end\n"
"'on'\n"
">>> word[-2:]  # characters from the second-last (included) to the end\n"
"'on'"
msgstr ""
">>> word[:2]   # 从开头到 2 号位 (不含) 的字符\n"
"'Py'\n"
">>> word[4:]   # 从 4 号位 (含) 到末尾\n"
"'on'\n"
">>> word[-2:]  # 从倒数第二个 (含) 到末尾\n"
"'on'"

#: ../../tutorial/introduction.rst:292
msgid ""
"Note how the start is always included, and the end always excluded.  This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr "注意，输出结果包含切片开始，但不包含切片结束。因此，``s[:i] + s[i:]`` 总是等于 ``s``："

#: ../../tutorial/introduction.rst:295
msgid ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"
msgstr ""
">>> word[:2] + word[2:]\n"
"'Python'\n"
">>> word[:4] + word[4:]\n"
"'Python'"

#: ../../tutorial/introduction.rst:300
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr "还可以这样理解切片，索引指向的是字符 *之间* ，第一个字符的左侧标为 0，最后一个字符的右侧标为 *n* ，*n* 是字符串长度。例如："

#: ../../tutorial/introduction.rst:305
msgid ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"
msgstr ""
" +---+---+---+---+---+---+\n"
" | P | y | t | h | o | n |\n"
" +---+---+---+---+---+---+\n"
" 0   1   2   3   4   5   6\n"
"-6  -5  -4  -3  -2  -1"

#: ../../tutorial/introduction.rst:311
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and"
" *j*, respectively."
msgstr ""
"第一行数字是字符串中索引 0...6 的位置，第二行数字是对应的负数索引位置。*i* 到 *j* 的切片由 *i* 和 *j* 之间所有对应的字符组成。"

#: ../../tutorial/introduction.rst:316
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds.  For example, the length of "
"``word[1:3]`` is 2."
msgstr "对于使用非负索引的切片，如果两个索引都不越界，切片长度就是起止索引之差。例如， ``word[1:3]`` 的长度是 2。"

#: ../../tutorial/introduction.rst:320
msgid "Attempting to use an index that is too large will result in an error::"
msgstr "索引越界会报错："

#: ../../tutorial/introduction.rst:322
msgid ""
">>> word[42]  # the word only has 6 characters\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"
msgstr ""
">>> word[42]  # word 只有 6 个字符\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"IndexError: string index out of range"

#: ../../tutorial/introduction.rst:327
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr "但是，切片会自动处理越界索引："

#: ../../tutorial/introduction.rst:330
msgid ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"
msgstr ""
">>> word[4:42]\n"
"'on'\n"
">>> word[42:]\n"
"''"

#: ../../tutorial/introduction.rst:335
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr "Python 字符串不能修改，是  :term:`immutable` 的。因此，为字符串中某个索引位置赋值会报错："

#: ../../tutorial/introduction.rst:338
msgid ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"
msgstr ""
">>> word[0] = 'J'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment\n"
">>> word[2:] = 'py'\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"TypeError: 'str' object does not support item assignment"

#: ../../tutorial/introduction.rst:347
msgid "If you need a different string, you should create a new one::"
msgstr "要生成不同的字符串，应新建一个字符串："

#: ../../tutorial/introduction.rst:349
msgid ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"
msgstr ""
">>> 'J' + word[1:]\n"
"'Jython'\n"
">>> word[:2] + 'py'\n"
"'Pypy'"

#: ../../tutorial/introduction.rst:354
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "内置函数 :func:`len` 返回字符串的长度："

#: ../../tutorial/introduction.rst:356
msgid ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"
msgstr ""
">>> s = 'supercalifragilisticexpialidocious'\n"
">>> len(s)\n"
"34"

#: ../../tutorial/introduction.rst:363
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"

#: ../../tutorial/introduction.rst:364
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr "字符串是 *序列类型* ，支持序列类型的各种操作。"

#: ../../tutorial/introduction.rst:367
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"

#: ../../tutorial/introduction.rst:368
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr "字符串支持很多变形与查找方法。"

#: ../../tutorial/introduction.rst:371
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"

#: ../../tutorial/introduction.rst:372
msgid "String literals that have embedded expressions."
msgstr "内嵌表达式的字符串字面值。"

#: ../../tutorial/introduction.rst:374
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"

#: ../../tutorial/introduction.rst:375
msgid "Information about string formatting with :meth:`str.format`."
msgstr "使用 :meth:`str.format` 格式化字符串。"

#: ../../tutorial/introduction.rst:377
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"

#: ../../tutorial/introduction.rst:378
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr "这里详述了用 ``%`` 运算符格式化字符串的操作。"

#: ../../tutorial/introduction.rst:385
msgid "Lists"
msgstr "列表"

#: ../../tutorial/introduction.rst:387
msgid ""
"Python knows a number of *compound* data types, used to group together other"
" values.  The most versatile is the *list*, which can be written as a list "
"of comma-separated values (items) between square brackets.  Lists might "
"contain items of different types, but usually the items all have the same "
"type. ::"
msgstr ""
"Python 支持多种 *复合* 数据类型，可将不同值组合在一起。最常用的 *列表* ，是用方括号标注，逗号分隔的一组值。*列表* "
"可以包含不同类型的元素，但一般情况下，各个元素的类型相同："

#: ../../tutorial/introduction.rst:392
msgid ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"
msgstr ""
">>> squares = [1, 4, 9, 16, 25]\n"
">>> squares\n"
"[1, 4, 9, 16, 25]"

#: ../../tutorial/introduction.rst:396
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr "和字符串（及其他内置 :term:`sequence` 类型）一样，列表也支持索引和切片："

#: ../../tutorial/introduction.rst:399
msgid ""
">>> squares[0]  # indexing returns the item\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # slicing returns a new list\n"
"[9, 16, 25]"
msgstr ""
">>> squares[0]  # 索引操作将返回条目\n"
"1\n"
">>> squares[-1]\n"
"25\n"
">>> squares[-3:]  # 切片操作将返回一个新列表\n"
"[9, 16, 25]"

#: ../../tutorial/introduction.rst:406
msgid "Lists also support operations like concatenation::"
msgstr "列表还支持合并操作："

#: ../../tutorial/introduction.rst:408
msgid ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
msgstr ""
">>> squares + [36, 49, 64, 81, 100]\n"
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"

#: ../../tutorial/introduction.rst:411
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr "与 :term:`immutable` 字符串不同, 列表是 :term:`mutable` 类型，其内容可以改变："

#: ../../tutorial/introduction.rst:414
msgid ""
">>> cubes = [1, 8, 27, 65, 125]  # something's wrong here\n"
">>> 4 ** 3  # the cube of 4 is 64, not 65!\n"
"64\n"
">>> cubes[3] = 64  # replace the wrong value\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"
msgstr ""
">>> cubes = [1, 8, 27, 65, 125]  # 这里有点问题\n"
">>> 4 ** 3  # 4 的立方是 64，不是 65！\n"
"64\n"
">>> cubes[3] = 64  # 替换错误的值\n"
">>> cubes\n"
"[1, 8, 27, 64, 125]"

#: ../../tutorial/introduction.rst:421
msgid ""
"You can also add new items at the end of the list, by using the "
":meth:`!list.append` *method* (we will see more about methods later)::"
msgstr "你也可以在通过使用 :meth:`!list.append` *方法*，在列表末尾添加新条目（我们将在后面介绍更多相关的方法）::"

#: ../../tutorial/introduction.rst:424
msgid ""
">>> cubes.append(216)  # add the cube of 6\n"
">>> cubes.append(7 ** 3)  # and the cube of 7\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"
msgstr ""
">>> cubes.append(216)  # 添加 6 的立方\n"
">>> cubes.append(7 ** 3)  # 和 7 的立方\n"
">>> cubes\n"
"[1, 8, 27, 64, 125, 216, 343]"

#: ../../tutorial/introduction.rst:429
msgid ""
"Simple assignment in Python never copies data. When you assign a list to a "
"variable, the variable refers to the *existing list*. Any changes you make "
"to the list through one variable will be seen through all other variables "
"that refer to it.::"
msgstr ""
"Python 中的简单赋值绝不会复制数据。 当你将一个列表赋值给一个变量时，该变量将引用 "
"*现有的列表*。你通过一个变量对列表所做的任何更改都会被引用它的所有其他变量看到。::"

#: ../../tutorial/introduction.rst:434
msgid ""
">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # they reference the same object\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> rgb = [\"Red\", \"Green\", \"Blue\"]\n"
">>> rgba = rgb\n"
">>> id(rgb) == id(rgba)  # 它们指向同一个对象\n"
"True\n"
">>> rgba.append(\"Alph\")\n"
">>> rgb\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"

#: ../../tutorial/introduction.rst:442
msgid ""
"All slice operations return a new list containing the requested elements.  "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr "切片操作返回包含请求元素的新列表。以下切片操作会返回列表的 :ref:`浅拷贝 <shallow_vs_deep_copy>`："

#: ../../tutorial/introduction.rst:446
msgid ""
">>> correct_rgba = rgba[:]\n"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"
msgstr ""
">>> correct_rgba = rgba[:]\n"
">>> correct_rgba[-1] = \"Alpha\"\n"
">>> correct_rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alpha\"]\n"
">>> rgba\n"
"[\"Red\", \"Green\", \"Blue\", \"Alph\"]"

#: ../../tutorial/introduction.rst:453
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr "为切片赋值可以改变列表大小，甚至清空整个列表："

#: ../../tutorial/introduction.rst:456
msgid ""
">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # replace some values\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # now remove them\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # clear the list by replacing all the elements with an empty list\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"
msgstr ""
">>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> letters\n"
"['a', 'b', 'c', 'd', 'e', 'f', 'g']\n"
">>> # 替换一些值\n"
">>> letters[2:5] = ['C', 'D', 'E']\n"
">>> letters\n"
"['a', 'b', 'C', 'D', 'E', 'f', 'g']\n"
">>> # 现在移除它们\n"
">>> letters[2:5] = []\n"
">>> letters\n"
"['a', 'b', 'f', 'g']\n"
">>> # 通过用一个空列表替代所有元素来清空列表\n"
">>> letters[:] = []\n"
">>> letters\n"
"[]"

#: ../../tutorial/introduction.rst:472
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "内置函数 :func:`len` 也支持列表："

#: ../../tutorial/introduction.rst:474
msgid ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"
msgstr ""
">>> letters = ['a', 'b', 'c', 'd']\n"
">>> len(letters)\n"
"4"

#: ../../tutorial/introduction.rst:478
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr "还可以嵌套列表（创建包含其他列表的列表），例如："

#: ../../tutorial/introduction.rst:481
msgid ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"
msgstr ""
">>> a = ['a', 'b', 'c']\n"
">>> n = [1, 2, 3]\n"
">>> x = [a, n]\n"
">>> x\n"
"[['a', 'b', 'c'], [1, 2, 3]]\n"
">>> x[0]\n"
"['a', 'b', 'c']\n"
">>> x[0][1]\n"
"'b'"

#: ../../tutorial/introduction.rst:494
msgid "First Steps Towards Programming"
msgstr "走向编程的第一步"

#: ../../tutorial/introduction.rst:496
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together.  For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ as "
"follows::"
msgstr ""
"当然，我们还能用 Python 完成比二加二更复杂的任务。 例如，我们可以像下面这样写出 `斐波那契数列 "
"<https://en.wikipedia.org/wiki/Fibonacci_sequence>`_ 初始部分的子序列::"

#: ../../tutorial/introduction.rst:501
msgid ""
">>> # Fibonacci series:\n"
">>> # the sum of two elements defines the next\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"
msgstr ""
">>> # 斐波那契数列：\n"
">>> # 前两项之和即下一项的值\n"
">>> a, b = 0, 1\n"
">>> while a < 10:\n"
"...     print(a)\n"
"...     a, b = b, a+b\n"
"...\n"
"0\n"
"1\n"
"1\n"
"2\n"
"3\n"
"5\n"
"8"

#: ../../tutorial/introduction.rst:516
msgid "This example introduces several new features."
msgstr "本例引入了几个新功能。"

#: ../../tutorial/introduction.rst:518
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1.  On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place.  The right-"
"hand side expressions are evaluated  from the left to the right."
msgstr ""
"第一行中的 *多重赋值* ：变量 ``a`` 和 ``b`` 同时获得新值 0 和 1 "
"。最后一行又用了一次多重赋值，体现了，等号右边的所有表达式的值，都是在这一语句对任何变量赋新值之前求出来的——求值顺序为从左到右。"

#: ../../tutorial/introduction.rst:524
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true.  In Python, like in C, any non-zero integer value is "
"true; zero is false.  The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false.  The test used in the example is a simple comparison.  The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
":keyword:`while` 循环只要条件（这里是 ``a < 10``）为真就会一直执行。Python 和 C "
"一样，任何非零整数都为真，零为假。这个条件也可以是字符串或列表类型的值，事实上，任何序列都可以：长度非零就为真，空序列则为假。示例中的判断只是最简单的比较。比较操作符的写法和"
" C 语言一样： ``<`` （小于）、 ``>`` （大于）、 ``==`` （等于）、 ``<=`` （小于等于)、 ``>=`` （大于等于）及 "
"``!=`` （不等于）。"

#: ../../tutorial/introduction.rst:533
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements.  At the interactive prompt, you have to type a tab or "
"space(s) for each indented line.  In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility.  When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line).  Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"*循环体* 是 *缩进的* ：缩进是 Python "
"组织语句的方式。在交互式命令行里，得为每个缩进的行输入空格（或制表符）。使用文本编辑器可以实现更复杂的输入方式；所有像样的文本编辑器都支持自动缩进。交互式输入复合语句时，要在最后输入空白行表示完成（因为解析器不知道哪一行代码是代码块的最后一行）。注意，同一块语句的每一行的缩进相同。"

#: ../../tutorial/introduction.rst:542
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating-point quantities, and strings.  Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
":func:`print` 函数输出给定参数的值。 除了可以以单一的表达式作为参数（比如，前面的计算器的例子），它还能处理多个参数，包括浮点数与字符串。"
" 它输出的字符串不带引号，且各参数项之间会插入一个空格，这样可以实现更好的格式化操作，就像这样::"

#: ../../tutorial/introduction.rst:549
msgid ""
">>> i = 256*256\n"
">>> print('The value of i is', i)\n"
"The value of i is 65536"
msgstr ""
">>> i = 256*256\n"
">>> print('The value of i is', i)\n"
"The value of i is 65536"

#: ../../tutorial/introduction.rst:553
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr "关键字参数 *end* 可以取消输出后面的换行, 或用另一个字符串结尾："

#: ../../tutorial/introduction.rst:556
msgid ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"
msgstr ""
">>> a, b = 0, 1\n"
">>> while a < 1000:\n"
"...     print(a, end=',')\n"
"...     a, b = b, a+b\n"
"...\n"
"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,"

#: ../../tutorial/introduction.rst:565
msgid "Footnotes"
msgstr "备注"

#: ../../tutorial/introduction.rst:566
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted"
" as ``-(3**2)`` and thus result in ``-9``.  To avoid this and get ``9``, you"
" can use ``(-3)**2``."
msgstr ""
"``**`` 比 ``-`` 的优先级更高, 所以 ``-3**2`` 会被解释成 ``-(3**2)`` ，因此，结果是 "
"``-9``。要避免这个问题，并且得到 ``9``, 可以用 ``(-3)**2``。"

#: ../../tutorial/introduction.rst:570
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"与其他语言不同，特殊字符如 ``\\n`` 在单引号（``'...'`` ）和双引号（``\"...\"`` "
"）里的意义一样。这两种引号唯一的区别是，不需要在单引号里转义双引号 ``\"`` （但此时必须把单引号转义成 ``\\'`` ），反之亦然。"

#: ../../tutorial/introduction.rst:21
msgid "# (hash)"
msgstr "# (hash)"

#: ../../tutorial/introduction.rst:21
msgid "comment"
msgstr "注释"