# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-10-11 20:40+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh \n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.17.0\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 ""
" : * * :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
#, python-brace-format
msgid ""
"To use :ref:`formatted string literals `, 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:` `\\ , ``f``"
" ``F`` . , ``{`` ``}`` , "
" ."
#: ../../tutorial/inputoutput.rst:32
#, python-brace-format
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
#, python-brace-format
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` . ``{`` "
" ``}``\\ , , . "
" :"
#: ../../tutorial/inputoutput.rst:46
#, python-brace-format
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 ""
#: ../../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 ""
", , "
" . ."
#: ../../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` . , , "
" . , ."
#: ../../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 ""
">>> 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"
">>> # repr() :\n"
">>> hello = 'hello, world\\n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world\\n'\n"
">>> # repr() :\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"\"(32.5, 40000, ('spam', 'eggs'))\""
#: ../../tutorial/inputoutput.rst:98
#, fuzzy
msgid ""
"The :mod:`string` module contains support for a simple templating "
"approach based upon regular expressions, via :class:`string.Template`. "
"This offers yet another way to substitute values into strings, using "
"placeholders like ``$x`` and replacing them with values from a "
"dictionary. This syntax is easy to use, although it offers much less "
"control for formatting."
msgstr ""
":mod:`string` :class:`~string.Template` "
" . ``$x``\\ , "
" ."
#: ../../tutorial/inputoutput.rst:115
msgid "Formatted String Literals"
msgstr " "
#: ../../tutorial/inputoutput.rst:117
#, python-brace-format
msgid ""
":ref:`Formatted string literals ` (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- ) ``f`` ``F`` "
" ``{expression}``\\ ."
#: ../../tutorial/inputoutput.rst:122
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 ""
" . . "
" ."
#: ../../tutorial/inputoutput.rst:126
#, python-brace-format
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:130
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:133
#, python-brace-format
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:141
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:145
#, python-brace-format
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:151
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 ""
#: ../../tutorial/inputoutput.rst:160
msgid ""
"See :ref:`self-documenting expressions ` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr ""
"``=`` :ref:` `\\ . "
" :ref:`formatspec`\\ ."
#: ../../tutorial/inputoutput.rst:167
msgid "The String format() Method"
msgstr " format() "
#: ../../tutorial/inputoutput.rst:169
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr ":meth:`str.format` ::"
#: ../../tutorial/inputoutput.rst:171
#, python-brace-format
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:174
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` . "
" :meth:`str.format` . ::"
#: ../../tutorial/inputoutput.rst:179
#, python-brace-format
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:184
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` , . ::"
#: ../../tutorial/inputoutput.rst:187
#, python-brace-format
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:191
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr " ::"
#: ../../tutorial/inputoutput.rst:193
#, python-brace-format
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:197
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 ""
" , . "
" ``'[]'`` . ::"
#: ../../tutorial/inputoutput.rst:202
#, python-brace-format
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:207
msgid ""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr "``**`` ``table`` . ::"
#: ../../tutorial/inputoutput.rst:210
#, python-brace-format
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:214
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` ::"
#: ../../tutorial/inputoutput.rst:217
#, python-brace-format
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:222
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:225
#, python-brace-format
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:239
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see"
" :ref:`formatstrings`."
msgstr ":meth:`str.format` :ref:`formatstrings` ."
#: ../../tutorial/inputoutput.rst:244
msgid "Manual String Formatting"
msgstr " "
#: ../../tutorial/inputoutput.rst:246
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr " ::"
#: ../../tutorial/inputoutput.rst:248
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:264
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:267
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` . "
" :meth:`str.ljust` :meth:`str.center` . "
", . , , ; "
" , . ( , "
" , ``x.ljust(n)[:n]`` .)"
#: ../../tutorial/inputoutput.rst:276
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 ""
" , :meth:`str.zfill`. 0 . "
"::"
#: ../../tutorial/inputoutput.rst:279
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:288
msgid "Old string formatting"
msgstr " "
#: ../../tutorial/inputoutput.rst:290
#, python-format
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 ""
"% () . ``format % values``\\ "
"(*format*\\ ), *format*\\ ``%`` 0 *values* "
". (interpolation) . ::"
#: ../../tutorial/inputoutput.rst:297
#, python-format
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:301
msgid "More information can be found in the :ref:`old-string-formatting` section."
msgstr " :ref:`old-string-formatting` ."
#: ../../tutorial/inputoutput.rst:307
msgid "Reading and Writing Files"
msgstr " "
#: ../../tutorial/inputoutput.rst:313
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:` ` , "
" : ``open(filename, mode, encoding=None)``"
#: ../../tutorial/inputoutput.rst:319
msgid ">>> f = open('workfile', 'w', encoding=\"utf-8\")"
msgstr ">>> f = open('workfile', 'w', encoding=\"utf-8\")"
#: ../../tutorial/inputoutput.rst:326
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:335
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:345
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 ""
" , ( ``\\n``, ``\\r\\n``) "
" ``\\n`` . , ``\\n`` "
" . , :file:`JPEG` "
":file:`EXE` . ."
#: ../../tutorial/inputoutput.rst:353
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:359
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:366
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:371
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 ""
":keyword:`!with` ``f.close()``\\ ``f.write()``\\ "
" ``f.write()``\\ **** ."
#: ../../tutorial/inputoutput.rst:379
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:383
msgid ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
"ValueError: I/O operation on closed file."
msgstr ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
" File \"\", line 1, in \n"
"ValueError: I/O operation on closed file."
#: ../../tutorial/inputoutput.rst:393
msgid "Methods of File Objects"
msgstr " "
#: ../../tutorial/inputoutput.rst:395
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:398
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:407
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:412
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:419
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:426
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:429
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:435
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(f)`` ``f.readlines()`` ."
#: ../../tutorial/inputoutput.rst:438
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:441
msgid ""
">>> f.write('This is a test\\n')\n"
"15"
msgstr ""
">>> f.write('This is a test\\n')\n"
"15"
#: ../../tutorial/inputoutput.rst:444
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:447
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:452
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:456
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:463
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) # 6 \n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2) # 3 \n"
"13\n"
">>> f.read(1)\n"
"b'd'"
#: ../../tutorial/inputoutput.rst:475
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)`` ), *offset* "
"``f.tell()`` 0. *offset* ."
#: ../../tutorial/inputoutput.rst:481
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 ""
" :meth:`~io.IOBase.isatty` :meth:`~io.IOBase.truncate` "
" , ; ."
#: ../../tutorial/inputoutput.rst:489
msgid "Saving structured data with :mod:`json`"
msgstr ":mod:`json` "
#: ../../tutorial/inputoutput.rst:493
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` "
" . :func:`int` , ``'123'`` "
" 123 . , "
" ."
#: ../../tutorial/inputoutput.rst:500
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) "
"`_. 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 ""
" , `JSON "
"(JavaScript Object Notation) `_ "
" . :mod:`json` ; "
" :dfn:` (serializing)` . :dfn:` "
" (deserializing)` . , "
" ."
#: ../../tutorial/inputoutput.rst:511
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 . , "
" ."
#: ../../tutorial/inputoutput.rst:515
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:518
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:523
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.dump`\\ :func:`~json.dumps` :term:` "
"` . ``f`` :term:` ` "
", ::"
#: ../../tutorial/inputoutput.rst:527
msgid "json.dump(x, f)"
msgstr "json.dump(x, f)"
#: ../../tutorial/inputoutput.rst:529
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:` `\\ "
":term:` ` ::"
#: ../../tutorial/inputoutput.rst:532
msgid "x = json.load(f)"
msgstr "x = json.load(f)"
#: ../../tutorial/inputoutput.rst:535
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 ""
#: ../../tutorial/inputoutput.rst:538
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 ""
" , JSON "
" . :mod:`json` ."
#: ../../tutorial/inputoutput.rst:544
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - "
#: ../../tutorial/inputoutput.rst:546
msgid ""
"Contrary to :ref:`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 ` , *pickle* "
". . "
": , "
"."
#: ../../tutorial/inputoutput.rst:104
msgid "formatted string literal"
msgstr " "
#: ../../tutorial/inputoutput.rst:104
msgid "interpolated string literal"
msgstr " "
#: ../../tutorial/inputoutput.rst:104
msgid "string"
msgstr ""
#: ../../tutorial/inputoutput.rst:104
msgid "formatted literal"
msgstr " "
#: ../../tutorial/inputoutput.rst:104
msgid "interpolated literal"
msgstr " "
#: ../../tutorial/inputoutput.rst:104
msgid "f-string"
msgstr "f-"
#: ../../tutorial/inputoutput.rst:104
msgid "fstring"
msgstr "f"
#: ../../tutorial/inputoutput.rst:309
msgid "built-in function"
msgstr " "
#: ../../tutorial/inputoutput.rst:309
msgid "open"
msgstr "open"
#: ../../tutorial/inputoutput.rst:309
msgid "object"
msgstr ""
#: ../../tutorial/inputoutput.rst:309
msgid "file"
msgstr ""
#: ../../tutorial/inputoutput.rst:491
msgid "module"
msgstr ""
#: ../../tutorial/inputoutput.rst:491
msgid "json"
msgstr "json"