# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

# Liang-Bo Wang <[email protected]>, 2016

# Ching-Hao Liu <[email protected]>, 2018

# Steven Hsu <[email protected]>, 2022

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-03-09 00:19+0000\n"

"PO-Revision-Date: 2022-10-16 03:20+0800\n"

"Last-Translator: Steven Hsu <[email protected]>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=1; plural=0;\n"

"X-Generator: Poedit 3.1.1\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 ""

"在下面的例子中，輸入與輸出的區別在於有無提示字元（prompt，: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 中的註"

"解 (comments) 由 hash 字元 ``#`` 開始一直到該行結束。註解可以從該行之首、空白"

"後、或程式碼之後開始，但不會出現在字串文本 (string literal) 之中。hash 字元在"

"字串文本之中時仍視為一 hash 字元。因為註解只是用來說明程式而不會被 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 "數字 (Number)"

#: ../../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 ""

"直譯器如同一台簡單的計算機：你可以輸入一個 expression（運算式），它會寫出該式"

"的值。Expression 的語法可以使用：運算子 ``+``、``-``、``*`` 和 ``/`` 可以用來"

"執行運算；括號 ``()`` 可以用來分群。例如： ::"

#: ../../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 ""

"除法 (``/``) 永遠回傳一個 float。如果要做 :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 中，計算冪次 (powers) 可以使用 ``**`` 運算子 [#]_： ::"

#: ../../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 ""

"如果一個變數未被「定義 (defined)」（即變數未被賦值），試著使用它時會出現一個"

"錯誤： ::"

#: ../../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 ""

"浮點數的運算有完善的支援，運算子 (operator) 遇上混合的運算元 (operand) 時會把"

"整數的運算元轉換為浮點數： ::"

#: ../../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:`複數 (complex numbers) <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` 型別表示，即所謂的「字串 (strings)」）和"

"數字。這包括字元 \"``!``\"、單詞 \"``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 ""

"如果你不希望字元前出現 ``\\`` 就被當成特殊字元時，可以改使用 *raw string*，在"

"第一個包圍引號前加上 ``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 表示 tab，\\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-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 ""

"字串可以使用 ``+`` 運算子連接 (concatenate)，並用 ``*`` 重複該字串的內容： ::"

#: ../../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 ""

"兩個以上相鄰的字串文本（*string literal*，即被引號包圍的字串）會被自動連接起"

"來： ::"

#: ../../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 ""

"字串可以被「索引 *indexed*」(下標，即 subscripted)，第一個字元的索引值為 0。"

"沒有獨立表示字元的型別；一個字元就是一個大小為 1 的字串： ::"

#: ../../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 ""

"除了索引外，字串亦支援「切片 *slicing*」。索引用來拿到單獨的字元，而切片則可"

"以讓你拿到一個子字串 (substring)： ::"

#: ../../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 ""

"切片索引 (slice indices) 有很常用的預設值，省略起點索引值時預設為 0，而省略第"

"二個索引值時預設整個字串被包含在 slice 中： ::"

#: ../../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 ""

"這裡有個簡單記住 slice 是如何運作的方式。想像 slice 的索引值指著字元們之間，"

"其中第一個字元的左側邊緣由 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* 的 slice 包含了標示 *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 ""

"對非負數的索引值而言，一個 slice 的長度等於其索引值之差，如果索引值落在字串邊"

"界內。例如，``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] # 這只有六個字母\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 "然而，超出範圍的索引值在 slice 中會被妥善的處理： ::"

#: ../../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 "字串是 *sequence 型別*\\ 的範例之一，並支援該型別常用的操作。"

#: ../../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 "字串支援非常多種基本轉換和搜尋的 method（方法）。"

#: ../../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` 字串格式化 (string formatting) 的資訊。"

#: ../../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 "List（串列）"

#: ../../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 理解數種複合型資料型別，用來組合不同的數值。當中最多樣變化的型別為 "

"*list*，可以寫成一系列以逗號分隔的數值（稱之元素，即 item），包含在方括號之"

"中。List 可以包合不同型別的元素，但通常這些元素會有相同的型別： ::"

#: ../../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` 型別），list 可以被索引和切片 "

"(slice)： ::"

#: ../../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 "List 對支援如接合 (concatenation) 等操作： ::"

#: ../../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`，list 是 :term:`mutable` 型別，即改變 list 的"

"內容是可能的： ::"

#: ../../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 ""

"你也可以在 list 的最後加入新元素，透過使用 :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 中的簡單賦值永遠不會複製資料。當你將 list 指派給變數時，該變數會參照"

"\\ *現有 list*。任何透過一個變數對 list 所做的更改都將能夠透過參照該變數的所"

"有其他變數看到。 ::"

#: ../../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 ""

"所有切片操作都會回傳一個新的 list ，包含要求的元素。這意謂著以下這個切片回傳"

"了原本 list 的\\ :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\"]"