# Copyright (C) 2001-2024, Python Software Foundation # This file is distributed under the same license as the Python package. # # Translators: # Liang-Bo Wang , 2016 # Ching-Hao Liu , 2018 # Steven Hsu , 2022 msgid "" msgstr "" "Project-Id-Version: Python 3.13\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2025-07-14 07:39+0000\n" "PO-Revision-Date: 2022-10-16 03:20+0800\n" "Last-Translator: Steven Hsu \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 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 "" "直譯器如同一台簡單的計算機：你可以輸入一個 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 \"\", line 1, in \n" "NameError: name 'n' is not defined" msgstr "" ">>> n # 嘗試存取未定義的變數\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \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 " "`, 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) `，並使用 ``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:\\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: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 ` for more information and workarounds." msgstr "" "原始字串有一個微妙的地方：原始字串可能不會以奇數個 ``\\`` 字元結尾；請參閱" "\\ :ref:`常見問答集 `\\ 來了解更多資訊" "和解決方法。" #: ../../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 \"\", line 1\n" " prefix 'thon'\n" " ^^^^^^\n" "SyntaxError: invalid syntax\n" ">>> ('un' * 3) 'ium'\n" " File \"\", line 1\n" " ('un' * 3) 'ium'\n" " ^^^^^\n" "SyntaxError: invalid syntax" msgstr "" ">>> prefix = 'Py'\n" ">>> prefix 'thon' # 無法串接變數和字串字面值\n" " File \"\", line 1\n" " prefix 'thon'\n" " ^^^^^^\n" "SyntaxError: invalid syntax\n" ">>> ('un' * 3) 'ium'\n" " File \"\", 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 \"\", line 1, in \n" "IndexError: string index out of range" msgstr "" ">>> word[42] # 這只有六個字母\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \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 \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment\n" ">>> word[2:] = 'py'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment" msgstr "" ">>> word[0] = 'J'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \n" "TypeError: 'str' object does not support item assignment\n" ">>> word[2:] = 'py'\n" "Traceback (most recent call last):\n" " File \"\", line 1, in \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` *方法* " "(method)（我們稍後會看到更多方法的說明）： ::" #: ../../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 " "` of the list::" msgstr "" "所有切片操作都會回傳一個新的 list ，包含要求的元素。這意謂著以下這個切片回傳" "了原本 list 的\\ :ref:`淺複製 `： ::" #: ../../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 "也可以對 slice 賦值，這能改變 list 的大小，甚至是清空一個 list： ::" #: ../../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" ">>> # 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" ">>> # 透過將所有元素替換為空串列的方式來清空串列\n" ">>> letters[:] = []\n" ">>> letters\n" "[]" #: ../../tutorial/introduction.rst:473 msgid "The built-in function :func:`len` also applies to lists::" msgstr "內建的函式 :func:`len` 亦可以作用在 list 上： ::" #: ../../tutorial/introduction.rst:475 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:479 msgid "" "It is possible to nest lists (create lists containing other lists), for " "example::" msgstr "也可以嵌套多層 list （建立 list 包含其他 list），例如： ::" #: ../../tutorial/introduction.rst:482 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:495 msgid "First Steps Towards Programming" msgstr "初探程式設計的前幾步" #: ../../tutorial/introduction.rst:497 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 `_ as " "follows::" msgstr "" "當然，我們可以用 Python 來處理比 2 加 2 更複雜的工作。例如，我們可以印出\\ `" "費氏數列 `_\\ 的首幾項序列： ::" #: ../../tutorial/introduction.rst:502 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:517 msgid "This example introduces several new features." msgstr "這例子引入了許多新的特性。" #: ../../tutorial/introduction.rst:519 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。在最後一行" "同樣的賦值再被使用了一次，示範了等號的右項運算 (expression) 會先被計算 " "(evaluate)，賦值再發生。右項的運算式由左至右依序被計算。" #: ../../tutorial/introduction.rst:525 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 語言，任何非零的整數值為真 (true)；零為假 (false)。條" "件可以是字串、list、甚至是任何序列型別；任何非零長度的序列為真，空的序列即為" "假。本例子使用的條件是個簡單的比較。標準的比較運算子 (comparison operators) " "使用如同 C 語言一樣的符號：``<``\\ （小於）、``>``\\ （大於）、``==``\\ （等" "於）、``<=``\\ （小於等於）、``>=``\\ （大於等於）以及 ``!=``\\ （不等於）。" #: ../../tutorial/introduction.rst:534 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 中用來關連一群陳述式。在互動式提示字元" "中，你必須在迴圈內的每一行一開始鍵入 tab 或者（數個）空白來維持縮排。實務上，" "你會先在文字編輯器中準備好比較複雜的輸入；多數編輯器都有自動縮排的功能。當一" "個複合陳述式以互動地方式輸入，必須在結束時多加一行空行來代表結束（因為語法剖" "析器無法判斷你何時輸入複合陳述的最後一行）。注意在一個縮排段落內的縮排方式與" "數量必須維持一致。" #: ../../tutorial/introduction.rst:543 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:550 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:554 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:557 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:566 msgid "Footnotes" msgstr "註解" #: ../../tutorial/introduction.rst:567 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:571 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:20 msgid "# (hash)" msgstr "# (hash)" #: ../../tutorial/introduction.rst:20 msgid "comment" msgstr "comment（註解）"