# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

# 99 <wh2099@pm.me>, 2026

# Freesand Leo <yuqinju@163.com>, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-03-09 14:44+0000\n"

"PO-Revision-Date: 2025-09-16 00:02+0000\n"

"Last-Translator: Freesand Leo <yuqinju@163.com>, 2026\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 use the \"Copy\" button (it appears in the upper-right corner when "

"hovering over or tapping a code example), which strips prompts and omits "

"output, to copy and paste the input lines into your interpreter."

msgstr "你可以使用 \"Copy\" 按钮（它会在悬停或点击代码示例时显示于右上角），它会去除提示符并省略输出，以将输入行复制粘贴到你的解释器。"

#: ../../tutorial/introduction.rst:22

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:30

msgid "Some examples::"

msgstr "示例如下："

#: ../../tutorial/introduction.rst:32

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:41

msgid "Using Python as a Calculator"

msgstr "Python 用作计算器"

#: ../../tutorial/introduction.rst:43

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:50

msgid "Numbers"

msgstr "数字"

#: ../../tutorial/introduction.rst:52

msgid ""

"The interpreter acts as a simple calculator: you can type an expression into"

" 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:58

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:67

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:71

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:75

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:85

msgid ""

"With Python, it is possible to use the ``**`` operator to calculate powers "

"[#]_::"

msgstr "Python 用 ``**`` 运算符计算乘方 [#]_："

#: ../../tutorial/introduction.rst:87

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:92

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:95

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:100

msgid ""

"If a variable is not \"defined\" (assigned a value), trying to use it will "

"give you an error::"

msgstr "如果变量未定义（即，未赋值），使用该变量会提示错误："

#: ../../tutorial/introduction.rst:103

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:108

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:111

msgid ""

">>> 4 * 3.75 - 1\n"

"14.0"

msgstr ""

">>> 4 * 3.75 - 1\n"

"14.0"

#: ../../tutorial/introduction.rst:114

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:118

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:127

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:131

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:141

msgid "Text"

msgstr "文本"

#: ../../tutorial/introduction.rst:143

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:149

msgid ""

">>> 'spam eggs' # single quotes\n"

"'spam eggs'\n"

">>> \"Paris rabbit got your back :)! Yay!\" # double quotes\n"

"'Paris rabbit got your back :)! Yay!'\n"

">>> '1975' # digits and numerals enclosed in quotes are also strings\n"

"'1975'"

msgstr ""

">>> 'spam eggs' # 单引号\n"

"'spam eggs'\n"

">>> \"Paris rabbit got your back :)! Yay!\" # 双引号\n"

"'Paris rabbit got your back :)! Yay!'\n"

">>> '1975' # 引号中的数字也是字符串\n"

"'1975'"

#: ../../tutorial/introduction.rst:158

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:161

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:172

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:176

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:183

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:187

msgid ""

">>> print('C:\\this\\name') # here \\t means tab, \\n means newline\n"

"C: his\n"

"ame\n"

">>> print(r'C:\\this\\name') # note the r before the quote\n"

"C:\\this\\name"

msgstr ""

">>> print('C:\\this\\name') # 这里 \\t 表示制表符，\\n 表示换行符\n"

"C: his\n"

"ame\n"

">>> print(r'C:\\this\\name') # 请注意引号前的 r\n"

"C:\\this\\name"

#: ../../tutorial/introduction.rst:193

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:198

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:204

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:215

msgid ""

"Strings can be concatenated (glued together) with the ``+`` operator, and "

"repeated with ``*``::"

msgstr "字符串可以用 ``+`` 合并（粘到一起），也可以用 ``*`` 重复："

#: ../../tutorial/introduction.rst:218

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:222

msgid ""

"Two or more *string literals* (i.e. the ones enclosed between quotes) next "

"to each other are automatically concatenated. ::"

msgstr "相邻的两个或多个 *字符串字面值* （引号标注的字符）会自动合并："

#: ../../tutorial/introduction.rst:225

msgid ""

">>> 'Py' 'thon'\n"

"'Python'"

msgstr ""

">>> 'Py' 'thon'\n"

"'Python'"

#: ../../tutorial/introduction.rst:228

msgid ""

"This feature is particularly useful when you want to break long strings::"

msgstr "拼接分隔开的长字符串时，这个功能特别实用："

#: ../../tutorial/introduction.rst:230

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:235

msgid ""

"This only works with two literals though, not with variables or "

"expressions::"

msgstr "这项功能只能用于两个字面值，不能用于变量或表达式："

#: ../../tutorial/introduction.rst:237

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:249

msgid ""

"If you want to concatenate variables or a variable and a literal, use "

"``+``::"

msgstr "合并多个变量，或合并变量与字面值，要用 ``+``："

#: ../../tutorial/introduction.rst:251

msgid ""

">>> prefix + 'thon'\n"

"'Python'"

msgstr ""

">>> prefix + 'thon'\n"

"'Python'"

#: ../../tutorial/introduction.rst:254

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:258

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:264

msgid ""

"Indices may also be negative numbers, to start counting from the right::"

msgstr "索引还支持负数，用负数索引时，从右边开始计数："

#: ../../tutorial/introduction.rst:266

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:273

msgid "Note that since -0 is the same as 0, negative indices start from -1."

msgstr "注意，-0 和 0 一样，因此，负数索引从 -1 开始。"

#: ../../tutorial/introduction.rst:275

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:278

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:283

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:286

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:293

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:296

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:301

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:306

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:312

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:317

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:321

msgid "Attempting to use an index that is too large will result in an error::"

msgstr "索引越界会报错："

#: ../../tutorial/introduction.rst:323

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:328

msgid ""

"However, out of range slice indexes are handled gracefully when used for "

"slicing::"

msgstr "但是，切片会自动处理越界索引："

#: ../../tutorial/introduction.rst:331

msgid ""

">>> word[4:42]\n"

"'on'\n"

">>> word[42:]\n"

"''"

msgstr ""

">>> word[4:42]\n"

"'on'\n"

">>> word[42:]\n"

"''"

#: ../../tutorial/introduction.rst:336

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:339

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:348

msgid "If you need a different string, you should create a new one::"

msgstr "要生成不同的字符串，应新建一个字符串："

#: ../../tutorial/introduction.rst:350

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:355

msgid "The built-in function :func:`len` returns the length of a string::"

msgstr "内置函数 :func:`len` 返回字符串的长度："

#: ../../tutorial/introduction.rst:357

msgid ""

">>> s = 'supercalifragilisticexpialidocious'\n"

">>> len(s)\n"

"34"

msgstr ""

">>> s = 'supercalifragilisticexpialidocious'\n"

">>> len(s)\n"

"34"

#: ../../tutorial/introduction.rst:364

msgid ":ref:`textseq`"

msgstr ":ref:`textseq`"

#: ../../tutorial/introduction.rst:365

msgid ""

"Strings are examples of *sequence types*, and support the common operations "

"supported by such types."

msgstr "字符串是 *序列类型* ，支持序列类型的各种操作。"

#: ../../tutorial/introduction.rst:368

msgid ":ref:`string-methods`"

msgstr ":ref:`string-methods`"

#: ../../tutorial/introduction.rst:369

msgid ""

"Strings support a large number of methods for basic transformations and "

"searching."

msgstr "字符串支持很多变形与查找方法。"

#: ../../tutorial/introduction.rst:372

msgid ":ref:`f-strings`"

msgstr ":ref:`f-strings`"

#: ../../tutorial/introduction.rst:373

msgid "String literals that have embedded expressions."

msgstr "内嵌表达式的字符串字面值。"

#: ../../tutorial/introduction.rst:375

msgid ":ref:`formatstrings`"

msgstr ":ref:`formatstrings`"

#: ../../tutorial/introduction.rst:376

msgid "Information about string formatting with :meth:`str.format`."

msgstr "使用 :meth:`str.format` 格式化字符串。"

#: ../../tutorial/introduction.rst:378

msgid ":ref:`old-string-formatting`"

msgstr ":ref:`old-string-formatting`"

#: ../../tutorial/introduction.rst:379

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:386

msgid "Lists"

msgstr "列表"

#: ../../tutorial/introduction.rst:388

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:393

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:397

msgid ""

"Like strings (and all other built-in :term:`sequence` types), lists can be "

"indexed and sliced::"

msgstr "和字符串（及其他内置 :term:`sequence` 类型）一样，列表也支持索引和切片："

#: ../../tutorial/introduction.rst:400

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:407

msgid "Lists also support operations like concatenation::"

msgstr "列表还支持合并操作："

#: ../../tutorial/introduction.rst:409

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:412

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:415

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:422

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:425

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:430

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:435

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:443

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:447

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:454

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:457

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:473

msgid "The built-in function :func:`len` also applies to lists::"

msgstr "内置函数 :func:`len` 也支持列表："

#: ../../tutorial/introduction.rst:475

msgid ""

">>> letters = ['a', 'b', 'c', 'd']\n"

">>> len(letters)\n"

"4"