inputoutput.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# jerrychen <jerrychen.ee@gmail.com>, 2016
# Steven Hsu <hsuhaochun@gmail.com>, 2021-2022
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-03 11:11+0800\n"
"PO-Revision-Date: 2022-10-05 10:26+0800\n"
"Last-Translator: Steven Hsu <hsuhaochun@gmail.com>\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/inputoutput.rst:5
msgid "Input and Output"
msgstr "輸入和輸出"

#: ../../tutorial/inputoutput.rst:7
msgid ""
"There are several ways to present the output of a program; data can be "
"printed in a human-readable form, or written to a file for future use. This "
"chapter will discuss some of the possibilities."
msgstr ""
"有數種方式可以顯示程式的輸出；資料可以以人類易讀的形式印出，或是寫入檔案以供"
"未來所使用。這章節會討論幾種不同的方式。"

#: ../../tutorial/inputoutput.rst:15
msgid "Fancier Output Formatting"
msgstr "更華麗的輸出格式"

#: ../../tutorial/inputoutput.rst:17
msgid ""
"So far we've encountered two ways of writing values: *expression statements* "
"and the :func:`print` function.  (A third way is using the :meth:`~io."
"TextIOBase.write` method of file objects; the standard output file can be "
"referenced as ``sys.stdout``. See the Library Reference for more information "
"on this.)"
msgstr ""
"目前為止我們已經學過兩種寫值的方式：*運算式陳述 (expression statements)* 與 :"
"func:`print` 函式。（第三種方法是使用檔案物件的 :meth:`~io.TextIOBase.write` "
"方法；標準輸出的檔案是使用 ``sys.stdout`` 來達成的。詳細的資訊請參考對應的函"
"式庫說明。）"

#: ../../tutorial/inputoutput.rst:22
msgid ""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values. There are several ways to format "
"output."
msgstr ""
"通常你會想要對輸出格式有更多地控制，而不是僅列印出以空格隔開的值。以下是幾種"
"格式化輸出的方式。"

#: ../../tutorial/inputoutput.rst:25
msgid ""
"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "
"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "
"Inside this string, you can write a Python expression between ``{`` and ``}"
"`` characters that can refer to variables or literal values."
msgstr ""
"要使用\\ :ref:`格式化字串文本 (formatted string literals) <tut-f-strings>`，"
"需在字串開始前的引號或連續三個引號前加上 ``f`` 或 ``F``。你可以在這個字串中使"
"用 ``{`` 與 ``}`` 包夾 Python 的運算式，引用變數或其他字面值 (literal "
"values)。"

#: ../../tutorial/inputoutput.rst:32
msgid ""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"
msgstr ""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"

#: ../../tutorial/inputoutput.rst:37
msgid ""
"The :meth:`str.format` method of strings requires more manual effort.  "
"You'll still use ``{`` and ``}`` to mark where a variable will be "
"substituted and can provide detailed formatting directives, but you'll also "
"need to provide the information to be formatted. In the following code block "
"there are two examples of how to format variables:"
msgstr ""
"字串的 :meth:`str.format` method 需要更多手動操作。你還是可以用 ``{`` 和 ``}"
"`` 標示欲替代變數的位置，且可給予詳細的格式指令，但你也需提供要被格式化的資"
"訊。在以下程式碼區塊中，有兩個如何格式化變數的範例："

#: ../../tutorial/inputoutput.rst:46
msgid ""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes  49.67%'"
msgstr ""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes  49.67%'"

#: ../../tutorial/inputoutput.rst:52
msgid ""
"Notice how the ``yes_votes`` are padded with spaces and a negative sign only "
"for negative numbers. The example also prints ``percentage`` multiplied by "
"100, with 2 decimal places and followed by a percent sign (see :ref:"
"`formatspec` for details)."
msgstr ""
"請注意 ``yes_votes`` 如何對於負數用空格和負號填補。該範例還會列出 "
"``percentage`` 乘以 100，並保留 2 位小數且後面跟著一個百分號（有關詳細資訊，"
"請參閱 :ref:`formatspec`）。"

#: ../../tutorial/inputoutput.rst:57
msgid ""
"Finally, you can do all the string handling yourself by using string slicing "
"and concatenation operations to create any layout you can imagine.  The "
"string type has some methods that perform useful operations for padding "
"strings to a given column width."
msgstr ""
"最後，你還可以自己用字串切片 (slicing) 和串接 (concatenation) 操作，完成所有"
"的字串處理，建立任何你能想像的排版格式。字串型別有一些 method，能以給定的欄寬"
"填補字串，這些運算也很有用。"

#: ../../tutorial/inputoutput.rst:62
msgid ""
"When you don't need fancy output but just want a quick display of some "
"variables for debugging purposes, you can convert any value to a string with "
"the :func:`repr` or :func:`str` functions."
msgstr ""
"如果你不需要華麗的輸出，只想快速顯示變數以進行除錯，可以用 :func:`repr` 或 :"
"func:`str` 函式把任何的值轉換為字串。"

#: ../../tutorial/inputoutput.rst:66
msgid ""
"The :func:`str` function is meant to return representations of values which "
"are fairly human-readable, while :func:`repr` is meant to generate "
"representations which can be read by the interpreter (or will force a :exc:"
"`SyntaxError` if there is no equivalent syntax).  For objects which don't "
"have a particular representation for human consumption, :func:`str` will "
"return the same value as :func:`repr`.  Many values, such as numbers or "
"structures like lists and dictionaries, have the same representation using "
"either function.  Strings, in particular, have two distinct representations."
msgstr ""
":func:`str` 函式的用意是回傳一個人類易讀的表示法，而 :func:`repr` 的用意是產"
"生直譯器可讀取的表示法（如果沒有等效的語法，則造成 :exc:`SyntaxError`）。如果"
"物件沒有人類易讀的特定表示法，:func:`str` 會回傳與 :func:`repr` 相同的值。有"
"許多的值，像是數字，或 list 及 dictionary 等結構，使用這兩個函式會有相同的表"
"示法。而字串，則較為特別，有兩種不同的表示法。"

#: ../../tutorial/inputoutput.rst:75
msgid "Some examples::"
msgstr "一些範例： ::"

#: ../../tutorial/inputoutput.rst:77
msgid ""
">>> s = 'Hello, world.'\n"
">>> str(s)\n"
"'Hello, world.'\n"
">>> repr(s)\n"
"\"'Hello, world.'\"\n"
">>> str(1/7)\n"
"'0.14285714285714285'\n"
">>> x = 10 * 3.25\n"
">>> y = 200 * 200\n"
">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"
">>> print(s)\n"
"The value of x is 32.5, and y is 40000...\n"
">>> # The repr() of a string adds string quotes and backslashes:\n"
">>> hello = 'hello, world\\n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world\\n'\n"
">>> # The argument to repr() may be any Python object:\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"\"(32.5, 40000, ('spam', 'eggs'))\""
msgstr ""

#: ../../tutorial/inputoutput.rst:98
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders "
"like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr ""
":mod:`string` 模組包含一個 :class:`~string.Template` class（類別），提供了將"
"值替代為字串的另一種方法。該方法使用 ``$x`` 佔位符號，並以 dictionary 的值進"
"行取代，但對格式的控制明顯較少。"

#: ../../tutorial/inputoutput.rst:107
msgid "Formatted String Literals"
msgstr "格式化的字串文本 (Formatted String Literals)"

#: ../../tutorial/inputoutput.rst:109
msgid ""
":ref:`Formatted string literals <f-strings>` (also called f-strings for "
"short) let you include the value of Python expressions inside a string by "
"prefixing the string with ``f`` or ``F`` and writing expressions as "
"``{expression}``."
msgstr ""
":ref:`格式化的字串文本 <f-strings>`\\ （簡稱為 f-字串），透過在字串加入前綴 "
"``f`` 或 ``F``，並將運算式編寫為 ``{expression}``，讓你可以在字串內加入 "
"Python 運算式的值。"

#: ../../tutorial/inputoutput.rst:114
msgid ""
"An optional format specifier can follow the expression. This allows greater "
"control over how the value is formatted. The following example rounds pi to "
"three places after the decimal::"
msgstr ""
"格式說明符 (format specifier) 是選擇性的，寫在運算式後面，可以更好地控制值的"
"格式化方式。以下範例將 pi 捨入到小數點後三位： ::"

#: ../../tutorial/inputoutput.rst:118
msgid ""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."
msgstr ""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."

#: ../../tutorial/inputoutput.rst:122
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making columns line up. ::"
msgstr ""
"在 ``':'`` 後傳遞一個整數，可以設定該欄位至少為幾個字元寬，常用於將每一欄對"
"齊。 ::"

#: ../../tutorial/inputoutput.rst:125
msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"...     print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd     ==>       4127\n"
"Jack       ==>       4098\n"
"Dcab       ==>       7678"
msgstr ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"...     print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd     ==>       4127\n"
"Jack       ==>       4098\n"
"Dcab       ==>       7678"

#: ../../tutorial/inputoutput.rst:133
msgid ""
"Other modifiers can be used to convert the value before it is formatted. ``'!"
"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "
"applies :func:`repr`::"
msgstr ""
"還有一些修飾符號可以在格式化前先將值轉換過。``'!a'`` 會套用 :func:`ascii`，"
"``'!s'`` 會套用 :func:`str`，``'!r'`` 會套用 :func:`repr`： ::"

#: ../../tutorial/inputoutput.rst:137
msgid ""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."
msgstr ""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."

#: ../../tutorial/inputoutput.rst:143
msgid ""
"The ``=`` specifier can be used to expand an expression to the text of the "
"expression, an equal sign, then the representation of the evaluated "
"expression:"
msgstr ""
"``=`` 說明符可用於將一個運算式擴充為該運算式的文字、一個等號、以及對該運算式"
"求值 (evaluate) 後的表示法："

#: ../../tutorial/inputoutput.rst:152
msgid ""
"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr ""
"更多關於 ``=`` 說明符的資訊請見\\ :ref:`自文件性運算式 (self-documenting "
"expressions) <bpo-36817-whatsnew>`。若要參考這些格式化字串的規格，詳見 :ref:"
"`formatspec` 參考指南。"

#: ../../tutorial/inputoutput.rst:159
msgid "The String format() Method"
msgstr "字串的 format() method"

#: ../../tutorial/inputoutput.rst:161
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr ":meth:`str.format` method 的基本用法如下： ::"

#: ../../tutorial/inputoutput.rst:163
msgid ""
">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"
"We are the knights who say \"Ni!\""
msgstr ""
">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"
"We are the knights who say \"Ni!\""

#: ../../tutorial/inputoutput.rst:166
msgid ""
"The brackets and characters within them (called format fields) are replaced "
"with the objects passed into the :meth:`str.format` method.  A number in the "
"brackets can be used to refer to the position of the object passed into the :"
"meth:`str.format` method. ::"
msgstr ""
"大括號及其內的字元（稱為格式欄位）會被取代為傳遞給 :meth:`str.format` method "
"的物件。大括號中的數字表示該物件在傳遞給 :meth:`str.format` method 時所在的位"
"置。 ::"

#: ../../tutorial/inputoutput.rst:171
msgid ""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"
msgstr ""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"

#: ../../tutorial/inputoutput.rst:176
msgid ""
"If keyword arguments are used in the :meth:`str.format` method, their values "
"are referred to by using the name of the argument. ::"
msgstr ""
"如果在 :meth:`str.format` method 中使用關鍵字引數，可以使用引數名稱去引用它們"
"的值。 ::"

#: ../../tutorial/inputoutput.rst:179
msgid ""
">>> print('This {food} is {adjective}.'.format(\n"
"...       food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."
msgstr ""
">>> print('This {food} is {adjective}.'.format(\n"
"...       food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."

#: ../../tutorial/inputoutput.rst:183
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr "位置引數和關鍵字引數可以任意組合： ::"

#: ../../tutorial/inputoutput.rst:185
msgid ""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"...                                                    other='Georg'))\n"
"The story of Bill, Manfred, and Georg."
msgstr ""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"...                                                    other='Georg'))\n"
"The story of Bill, Manfred, and Georg."

#: ../../tutorial/inputoutput.rst:189
msgid ""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position.  This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys. ::"
msgstr ""
"如果你有一個不想分割的長格式化字串，比較好的方式是按名稱而不是按位置來引用變"
"數。這項操作可以透過傳遞字典 (dict)，並用方括號 ``'[]'`` 使用鍵 (key) 來輕鬆"
"完成。 ::"

#: ../../tutorial/inputoutput.rst:194
msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"...       'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"...       'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

#: ../../tutorial/inputoutput.rst:199
msgid ""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr ""
"用 '**' 符號，把 ``table`` 字典當作關鍵字引數來傳遞，也有一樣的結果。 ::"

#: ../../tutorial/inputoutput.rst:202
msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."
"format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."
"format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"

#: ../../tutorial/inputoutput.rst:206
msgid ""
"This is particularly useful in combination with the built-in function :func:"
"`vars`, which returns a dictionary containing all local variables::"
msgstr ""
"與內建函式 :func:`vars` 組合使用時，這種方式特別實用。該函式可以回傳一個包含"
"所有區域變數的 dictionary： ::"

#: ../../tutorial/inputoutput.rst:209
msgid ""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."
msgstr ""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."

#: ../../tutorial/inputoutput.rst:214
msgid ""
"As an example, the following lines produce a tidily aligned set of columns "
"giving integers and their squares and cubes::"
msgstr "例如，下面的程式碼產生一組排列整齊的欄，列出整數及其平方與立方： ::"

#: ../../tutorial/inputoutput.rst:217
msgid ""
">>> for x in range(1, 11):\n"
"...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"
msgstr ""
">>> for x in range(1, 11):\n"
"...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"

#: ../../tutorial/inputoutput.rst:231
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see :"
"ref:`formatstrings`."
msgstr ""
"關於使用 :meth:`str.format` 進行字串格式化的完整概述，請見\\ :ref:"
"`formatstrings`。"

#: ../../tutorial/inputoutput.rst:236
msgid "Manual String Formatting"
msgstr "手動格式化字串"

#: ../../tutorial/inputoutput.rst:238
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr "下面是以手動格式化完成的同一個平方及立方的表： ::"

#: ../../tutorial/inputoutput.rst:240
msgid ""
">>> for x in range(1, 11):\n"
"...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"...     # Note use of 'end' on previous line\n"
"...     print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"
msgstr ""
">>> for x in range(1, 11):\n"
"...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"...     # 注意前一列使用的 'end'\n"
"...     print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"

#: ../../tutorial/inputoutput.rst:256
msgid ""
"(Note that the one space between each column was added by the way :func:"
"`print` works: it always adds spaces between its arguments.)"
msgstr ""
"（請注意，使用 :func:`print` 讓每欄之間加入一個空格的方法：這種方法總是在其引"
"數間加入空格。）"

#: ../../tutorial/inputoutput.rst:259
msgid ""
"The :meth:`str.rjust` method of string objects right-justifies a string in a "
"field of a given width by padding it with spaces on the left. There are "
"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "
"not write anything, they just return a new string. If the input string is "
"too long, they don't truncate it, but return it unchanged; this will mess up "
"your column lay-out but that's usually better than the alternative, which "
"would be lying about a value. (If you really want truncation you can always "
"add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr ""
"字串物件的 :meth:`str.rjust` method 透過在左側填補空格，使字串以給定的欄寬進"
"行靠右對齊。類似的 method 還有 :meth:`str.ljust` 和 :meth:`str.center`。這些 "
"method 不寫入任何內容，只回傳一個新字串，如果輸入的字串太長，它們不會截斷字"
"串，而是不做任何改變地回傳；雖然這樣會弄亂欄的編排，但這通常還是比另一種情況"
"好，那種情況會讓值變得不正確。（如果你真的想截斷字串，可以加入像 ``x.ljust(n)"
"[:n]`` 這樣的切片運算。）"

#: ../../tutorial/inputoutput.rst:268
msgid ""
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
"the left with zeros.  It understands about plus and minus signs::"
msgstr ""
"另一種 method 是 :meth:`str.zfill`，可在數值字串的左邊填補零，且能識別正負"
"號： ::"

#: ../../tutorial/inputoutput.rst:271
msgid ""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"
msgstr ""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"

#: ../../tutorial/inputoutput.rst:280
msgid "Old string formatting"
msgstr "格式化字串的舊方法"

#: ../../tutorial/inputoutput.rst:282
msgid ""
"The % operator (modulo) can also be used for string formatting. Given "
"``format % values`` (where *format* is a string), ``%`` conversion "
"specifications in *format* are replaced with zero or more elements of "
"*values*. This operation is commonly known as string interpolation. For "
"example::"
msgstr ""
"% 運算子（modulo，模數）也可用於字串格式化。在 ``format % values`` 中（其中 "
"*format* 是個字串），*format* 內的 ``%`` 轉換規格會被 *values* 的零個或多個元"
"素所取代。此運算常被稱為字串插值 (string interpolation)。例如： ::"

#: ../../tutorial/inputoutput.rst:289
msgid ""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."
msgstr ""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."

#: ../../tutorial/inputoutput.rst:293
msgid ""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr "更多資訊請見 :ref:`old-string-formatting`\\ 小節。"

#: ../../tutorial/inputoutput.rst:299
msgid "Reading and Writing Files"
msgstr "讀寫檔案"

#: ../../tutorial/inputoutput.rst:305
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two positional arguments and one keyword argument: ``open(filename, mode, "
"encoding=None)``"
msgstr ""
":func:`open` 回傳一個 :term:`file object`，而它最常使用的兩個位置引數和一個關"
"鍵字引數是：``open(filename, mode, encoding=None)``"

#: ../../tutorial/inputoutput.rst:311
msgid ">>> f = open('workfile', 'w', encoding=\"utf-8\")"
msgstr ">>> f = open('workfile', 'w', encoding=\"utf-8\")"

#: ../../tutorial/inputoutput.rst:318
msgid ""
"The first argument is a string containing the filename.  The second argument "
"is another string containing a few characters describing the way in which "
"the file will be used.  *mode* can be ``'r'`` when the file will only be "
"read, ``'w'`` for only writing (an existing file with the same name will be "
"erased), and ``'a'`` opens the file for appending; any data written to the "
"file is automatically added to the end.  ``'r+'`` opens the file for both "
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
"assumed if it's omitted."
msgstr ""
"第一個引數是一個包含檔案名稱的字串。第二個引數是另一個字串，包含了描述檔案使"
"用方式的幾個字元。*mode* 為 ``'r'`` 時，表示以唯讀模式開啟檔案；為 ``'w'`` "
"時，表示以唯寫模式開啟檔案（已存在的同名檔案會被抹除）；為 ``'a'`` 時，以附加"
"內容為目的開啟檔案，任何寫入檔案的資料會自動被加入到檔案的結尾。``'r+'`` 可以"
"開啟檔案並進行讀取和寫入。*mode* 引數是選擇性的，若省略時會預設為 ``'r'``。"

#: ../../tutorial/inputoutput.rst:327
msgid ""
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
"write strings from and to the file, which are encoded in a specific "
"*encoding*. If *encoding* is not specified, the default is platform "
"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "
"``encoding=\"utf-8\"`` is recommended unless you know that you need to use a "
"different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:"
"`binary mode`. Binary mode data is read and written as :class:`bytes` "
"objects. You can not specify *encoding* when opening file in binary mode."
msgstr ""
"通常，檔案以 :dfn:`text mode` 開啟，意即，從檔案中讀取或寫入字串時，都以特定"
"編碼方式 *encoding* 進行編碼。如未指定 *encoding*，則預設值會取決於系統平台"
"（見 :func:`open`）。因為 UTF-8 是現時的標準，除非你很清楚該用什麼編碼，否則"
"推薦使用 ``encoding=\"utf-8\"``。在 mode 後面加上 ``'b'`` 會以 :dfn:`binary "
"mode`\\ （二進制模式）開啟檔案，二進制模式資料以 :class:`bytes` 物件的形式被"
"讀寫。以二進制模式開啟檔案時不可以指定 *encoding*。"

#: ../../tutorial/inputoutput.rst:337
msgid ""
"In text mode, the default when reading is to convert platform-specific line "
"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``.  When "
"writing in text mode, the default is to convert occurrences of ``\\n`` back "
"to platform-specific line endings.  This behind-the-scenes modification to "
"file data is fine for text files, but will corrupt binary data like that in :"
"file:`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when "
"reading and writing such files."
msgstr ""
"在文字模式 (text mode) 下，讀取時會預設把平台特定的行尾符號（Unix 上為 "
"``\\n``，Windows 上為 ``\\r\\n``）轉換為 ``\\n``。在文字模式下寫入時，預設會"
"把 ``\\n`` 出現之處轉換回平台特定的行尾符號。這種在幕後對檔案資料的修改方式對"
"文字檔案來說沒有問題，但會毀壞像是 :file:`JPEG` 或 :file:`EXE` 檔案中的二進制"
"資料。在讀寫此類檔案時，注意一定要使用二進制模式。"

#: ../../tutorial/inputoutput.rst:345
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  The advantage is that the file is properly closed after its "
"suite finishes, even if an exception is raised at some point.  Using :"
"keyword:`!with` is also much shorter than writing equivalent :keyword:"
"`try`\\ -\\ :keyword:`finally` blocks::"
msgstr ""
"在處理檔案物件時，使用 :keyword:`with` 關鍵字是個好習慣。優點是，當它的套件結"
"束後，即使在某個時刻引發了例外，檔案仍會正確地被關閉。使用 :keyword:`!with` "
"也比寫等效的 :keyword:`try`\\ -\\ :keyword:`finally` 區塊，來得簡短許多： ::"

#: ../../tutorial/inputoutput.rst:351
msgid ""
">>> with open('workfile', encoding=\"utf-8\") as f:\n"
"...     read_data = f.read()\n"
"\n"
">>> # We can check that the file has been automatically closed.\n"
">>> f.closed\n"
"True"
msgstr ""
">>> with open('workfile', encoding=\"utf-8\") as f:\n"
"...     read_data = f.read()\n"
"\n"
">>> # 我們可以檢查確認該檔案已經自動被關閉。\n"
">>> f.closed\n"
"True"

#: ../../tutorial/inputoutput.rst:358
msgid ""
"If you're not using the :keyword:`with` keyword, then you should call ``f."
"close()`` to close the file and immediately free up any system resources "
"used by it."
msgstr ""
"如果你沒有使用 :keyword:`with` 關鍵字，則應呼叫 ``f.close()`` 關閉檔案，可以"
"立即釋放被它所使用的系統資源。"

#: ../../tutorial/inputoutput.rst:363
msgid ""
"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "
"``f.close()`` **might** result in the arguments of ``f.write()`` not being "
"completely written to the disk, even if the program exits successfully."
msgstr ""
"呼叫 ``f.write()`` 時，若未使用 :keyword:`!with` 關鍵字或呼叫 ``f.close()``，"
"即使程式成功退出，也\\ **可能**\\ 導致 ``f.write()`` 的引數沒有被完全寫入硬"
"碟。"

#: ../../tutorial/inputoutput.rst:371
msgid ""
"After a file object is closed, either by a :keyword:`with` statement or by "
"calling ``f.close()``, attempts to use the file object will automatically "
"fail. ::"
msgstr ""
"不論是透過 :keyword:`with` 陳述式，或呼叫 ``f.close()`` 關閉一個檔案物件之"
"後，嘗試使用該檔案物件將會自動失效。 ::"

#: ../../tutorial/inputoutput.rst:375
msgid ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ValueError: I/O operation on closed file."
msgstr ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ValueError: I/O operation on closed file."

#: ../../tutorial/inputoutput.rst:385
msgid "Methods of File Objects"
msgstr "檔案物件的 method"

#: ../../tutorial/inputoutput.rst:387
msgid ""
"The rest of the examples in this section will assume that a file object "
"called ``f`` has already been created."
msgstr "本節其餘的範例皆假設一個名為 ``f`` 的檔案物件已被建立。"

#: ../../tutorial/inputoutput.rst:390
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string (in text mode) or bytes object (in binary "
"mode). *size* is an optional numeric argument.  When *size* is omitted or "
"negative, the entire contents of the file will be read and returned; it's "
"your problem if the file is twice as large as your machine's memory. "
"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "
"binary mode) are read and returned. If the end of the file has been reached, "
"``f.read()`` will return an empty string (``''``).  ::"
msgstr ""
"要讀取檔案的內容，可呼叫 ``f.read(size)``，它可讀取一部份的資料，並以字串（文"
"字模式）或位元組串物件（二進制模式）形式回傳。*size* 是個選擇性的數字引數。"
"當 *size* 被省略或為負數時，檔案的全部內容會被讀取並回傳；如果檔案是機器記憶"
"體容量的兩倍大時，這會是你的問題。否則，最多只有等同於 *size* 數量的字元（文"
"字模式）或 *size* 數量的位元組串（二進制模式）會被讀取及回傳。如果之前已經到"
"達檔案的末端，``f.read()`` 會回傳空字串（``''``）。 ::"

#: ../../tutorial/inputoutput.rst:399
msgid ""
">>> f.read()\n"
"'This is the entire file.\\n'\n"
">>> f.read()\n"
"''"
msgstr ""
">>> f.read()\n"
"'This is the entire file.\\n'\n"
">>> f.read()\n"
"''"

#: ../../tutorial/inputoutput.rst:404
msgid ""
"``f.readline()`` reads a single line from the file; a newline character "
"(``\\n``) is left at the end of the string, and is only omitted on the last "
"line of the file if the file doesn't end in a newline.  This makes the "
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
"end of the file has been reached, while a blank line is represented by "
"``'\\n'``, a string containing only a single newline.  ::"
msgstr ""
"``f.readline()`` 從檔案中讀取單獨一行；換行字元（``\\n``）會被留在字串的結"
"尾，只有當檔案末端不是換行字元時，它才會在檔案的最後一行被省略。這種方式讓回"
"傳值清晰明確；只要 ``f.readline()`` 回傳一個空字串，就表示已經到達了檔案末"
"端，而空白行的表示法是 ``'\\n'``，也就是只含一個換行字元的字串。 ::"

#: ../../tutorial/inputoutput.rst:411
msgid ""
">>> f.readline()\n"
"'This is the first line of the file.\\n'\n"
">>> f.readline()\n"
"'Second line of the file\\n'\n"
">>> f.readline()\n"
"''"
msgstr ""
">>> f.readline()\n"
"'This is the first line of the file.\\n'\n"
">>> f.readline()\n"
"'Second line of the file\\n'\n"
">>> f.readline()\n"
"''"

#: ../../tutorial/inputoutput.rst:418
msgid ""
"For reading lines from a file, you can loop over the file object. This is "
"memory efficient, fast, and leads to simple code::"
msgstr ""
"想從檔案中讀取多行時，可以對檔案物件進行迴圈。這種方法能有效地使用記憶體、快"
"速，且程式碼簡潔： ::"

#: ../../tutorial/inputoutput.rst:421
msgid ""
">>> for line in f:\n"
"...     print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"
msgstr ""
">>> for line in f:\n"
"...     print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"

#: ../../tutorial/inputoutput.rst:427
msgid ""
"If you want to read all the lines of a file in a list you can also use "
"``list(f)`` or ``f.readlines()``."
msgstr ""
"如果你想把一個檔案的所有行讀進一個 list 裡，可以用 ``list(f)`` 或 ``f."
"readlines()``。"

#: ../../tutorial/inputoutput.rst:430
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"the number of characters written. ::"
msgstr ""
"``f.write(string)`` 把 *string* 的內容寫入檔案，並回傳寫入的字元數。 ::"

#: ../../tutorial/inputoutput.rst:433
msgid ""
">>> f.write('This is a test\\n')\n"
"15"
msgstr ""
">>> f.write('This is a test\\n')\n"
"15"

#: ../../tutorial/inputoutput.rst:436
msgid ""
"Other types of objects need to be converted -- either to a string (in text "
"mode) or a bytes object (in binary mode) -- before writing them::"
msgstr ""
"寫入其他類型的物件之前，要先把它們轉換為字串（文字模式）或位元組串物件（二進"
"制模式）： ::"

#: ../../tutorial/inputoutput.rst:439
msgid ""
">>> value = ('the answer', 42)\n"
">>> s = str(value)  # convert the tuple to string\n"
">>> f.write(s)\n"
"18"
msgstr ""
">>> value = ('the answer', 42)\n"
">>> s = str(value)  # 將元組轉換成字串\n"
">>> f.write(s)\n"
"18"

#: ../../tutorial/inputoutput.rst:444
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file represented as number of bytes from the beginning of the file when "
"in binary mode and an opaque number when in text mode."
msgstr ""
"``f.tell()`` 回傳一個整數，它給出檔案物件在檔案中的當前位置，在二進制模式下表"
"示為檔案開始至今的位元組數，在文字模式下表示為一個意義不明的數字。"

#: ../../tutorial/inputoutput.rst:448
msgid ""
"To change the file object's position, use ``f.seek(offset, whence)``.  The "
"position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *whence* argument.  A *whence* value of 0 "
"measures from the beginning of the file, 1 uses the current file position, "
"and 2 uses the end of the file as the reference point.  *whence* can be "
"omitted and defaults to 0, using the beginning of the file as the reference "
"point. ::"
msgstr ""
"使用 ``f.seek(offset, whence)`` 可以改變檔案物件的位置。位置計算方法是從一個"
"參考點增加 *offset* 的偏移量；參考點則由引數 *whence* 來選擇。當 *whence* 值"
"為 0 時，表示使用檔案開頭，1 表示使用當前的檔案位置，2 表示使用檔案末端作為參"
"考點。*whence* 可省略，其預設值為 0，即以檔案開頭作為參考點。 ::"

#: ../../tutorial/inputoutput.rst:455
msgid ""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5)      # Go to the 6th byte in the file\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2)  # Go to the 3rd byte before the end\n"
"13\n"
">>> f.read(1)\n"
"b'd'"
msgstr ""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5)      # 跳到檔案中的第六個位元組\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2)  # 跳到結尾前的第三個位元組\n"
"13\n"
">>> f.read(1)\n"
"b'd'"

#: ../../tutorial/inputoutput.rst:467
msgid ""
"In text files (those opened without a ``b`` in the mode string), only seeks "
"relative to the beginning of the file are allowed (the exception being "
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
"*offset* value produces undefined behaviour."
msgstr ""
"在文字檔案（開啟時模式字串未加入 ``b`` 的檔案）中，只允許以檔案開頭為參考點進"
"行尋找（但 ``seek(0, 2)`` 尋找檔案最末端是例外），且只有從 ``f.tell()`` 回傳"
"的值，或是 0，才是有效的 *offset* 值。其他任何 *offset* 值都會產生未定義的行"
"為。"

#: ../../tutorial/inputoutput.rst:473
msgid ""
"File objects have some additional methods, such as :meth:`~io.IOBase.isatty` "
"and :meth:`~io.IOBase.truncate` which are less frequently used; consult the "
"Library Reference for a complete guide to file objects."
msgstr ""
"檔案物件還有一些附加的 method，像是較不常使用的 :meth:`~io.IOBase.isatty` "
"和 :meth:`~io.IOBase.truncate`；檔案物件的完整指南詳見程式庫參考手冊。"

#: ../../tutorial/inputoutput.rst:481
msgid "Saving structured data with :mod:`json`"
msgstr "使用 :mod:`json` 儲存結構化資料"

#: ../../tutorial/inputoutput.rst:485
msgid ""
"Strings can easily be written to and read from a file.  Numbers take a bit "
"more effort, since the :meth:`~io.TextIOBase.read` method only returns "
"strings, which will have to be passed to a function like :func:`int`, which "
"takes a string like ``'123'`` and returns its numeric value 123.  When you "
"want to save more complex data types like nested lists and dictionaries, "
"parsing and serializing by hand becomes complicated."
msgstr ""
"字串可以簡單地從檔案中被寫入和讀取。數字則稍嫌麻煩，因為 :meth:`~io."
"TextIOBase.read` method 只回傳字串，這些字串必須傳遞給像 :func:`int` 這樣的函"
"式，它接受 ``'123'`` 這樣的字串，並回傳數值 123。當你想儲存像是巢狀 list 和 "
"dictionary（字典）等複雜的資料類型時，手動剖析 (parsing) 和序列化 "
"(serializing) 就變得複雜。"

#: ../../tutorial/inputoutput.rst:492
msgid ""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) <https://json."
"org>`_.  The standard module called :mod:`json` can take Python data "
"hierarchies, and convert them to string representations; this process is "
"called :dfn:`serializing`.  Reconstructing the data from the string "
"representation is called :dfn:`deserializing`.  Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr ""
"相較於讓使用者不斷地編寫和除錯程式碼才能把複雜的資料類型儲存到檔案，Python 支"
"援一個普及的資料交換格式，稱為 `JSON (JavaScript Object Notation) <https://"
"json.org>`_。標準模組 :mod:`json` 可接收 Python 資料階層，並將它們轉換為字串"
"表示法；這個過程稱為 :dfn:`serializing`\\ （序列化）。從字串表示法中重建資料"
"則稱為 :dfn:`deserializing`\\ （反序列化）。在序列化和反序列化之間，表示物件"
"的字串可以被儲存在檔案或資料中，或通過網路連接發送到遠端的機器。"

#: ../../tutorial/inputoutput.rst:503
msgid ""
"The JSON format is commonly used by modern applications to allow for data "
"exchange.  Many programmers are already familiar with it, which makes it a "
"good choice for interoperability."
msgstr ""
"JSON 格式經常地使用於現代應用程式的資料交換。許多程序設計師早已對它耳熟能詳，"
"使它成為提升互操作性 (interoperability) 的好選擇。"

#: ../../tutorial/inputoutput.rst:507
msgid ""
"If you have an object ``x``, you can view its JSON string representation "
"with a simple line of code::"
msgstr ""
"如果你有一個物件 ``x``，只需一行簡單的程式碼即可檢視它的 JSON 字串表示法： ::"

#: ../../tutorial/inputoutput.rst:510
msgid ""
">>> import json\n"
">>> x = [1, 'simple', 'list']\n"
">>> json.dumps(x)\n"
"'[1, \"simple\", \"list\"]'"
msgstr ""
">>> import json\n"
">>> x = [1, 'simple', 'list']\n"
">>> json.dumps(x)\n"
"'[1, \"simple\", \"list\"]'"

#: ../../tutorial/inputoutput.rst:515
msgid ""
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
"dump`, simply serializes the object to a :term:`text file`.  So if ``f`` is "
"a :term:`text file` object opened for writing, we can do this::"
msgstr ""
":func:`~json.dumps` 函式有一個變體，稱為 :func:`~json.dump`，它單純地將物件序"
"列化為 :term:`text file`。因此，如果 ``f`` 是一個為了寫入而開啟的 :term:"
"`text file` 物件，我們可以這樣做： ::"

#: ../../tutorial/inputoutput.rst:519
msgid "json.dump(x, f)"
msgstr "json.dump(x, f)"

#: ../../tutorial/inputoutput.rst:521
msgid ""
"To decode the object again, if ``f`` is a :term:`binary file` or :term:`text "
"file` object which has been opened for reading::"
msgstr ""
"若 ``f`` 是一個已開啟、可讀取的 :term:`binary file` 或 :term:`text file` 物"
"件，要再次解碼物件的話： ::"

#: ../../tutorial/inputoutput.rst:524
msgid "x = json.load(f)"
msgstr "x = json.load(f)"

#: ../../tutorial/inputoutput.rst:527
msgid ""
"JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening "
"JSON file as a :term:`text file` for both of reading and writing."
msgstr ""
"JSON 檔案必須以 UTF-8 格式編碼。在開啟 JSON 檔案以作為一個可讀取與寫入的 :"
"term:`text file` 時，要用 ``encoding=\"utf-8\"``。"

#: ../../tutorial/inputoutput.rst:530
msgid ""
"This simple serialization technique can handle lists and dictionaries, but "
"serializing arbitrary class instances in JSON requires a bit of extra "
"effort. The reference for the :mod:`json` module contains an explanation of "
"this."
msgstr ""
"這種簡單的序列化技術可以處理 list 和 dictionary，但要在 JSON 中序列化任意的 "
"class（類別）實例，則需要一些額外的工作。:mod:`json` 模組的參考資料包含對此的"
"說明。"

#: ../../tutorial/inputoutput.rst:536
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - pickle 模組"

#: ../../tutorial/inputoutput.rst:538
msgid ""
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
"serialization of arbitrarily complex Python objects.  As such, it is "
"specific to Python and cannot be used to communicate with applications "
"written in other languages.  It is also insecure by default: deserializing "
"pickle data coming from an untrusted source can execute arbitrary code, if "
"the data was crafted by a skilled attacker."
msgstr ""
"與 :ref:`JSON <tut-json>` 不同，*pickle* 是一種允許對任意的複雜 Python 物件進"
"行序列化的協定。因此，它為 Python 所特有，不能用於與其他語言編寫的應用程式溝"
"通。在預設情況，它也是不安全的：如果資料是由手段高明的攻擊者精心設計，將這段"
"來自於不受信任來源的 pickle 資料反序列化，可以執行任意的程式碼。"

#: ../../tutorial/inputoutput.rst:301
msgid "built-in function"
msgstr "built-in function（內建函式）"

#: ../../tutorial/inputoutput.rst:301
msgid "open"
msgstr "open"

#: ../../tutorial/inputoutput.rst:301
msgid "object"
msgstr "object（物件）"

#: ../../tutorial/inputoutput.rst:301
msgid "file"
msgstr "file（檔案）"

#: ../../tutorial/inputoutput.rst:483
msgid "module"
msgstr "module（模組）"

#: ../../tutorial/inputoutput.rst:483
msgid "json"
msgstr "json"