.. _tut-io:
******************************************
Input and Output input and output
******************************************
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.
There are several ways to express program output Result; data can be printed to human-readable form or written to a file for later use. This chapter discusses several alternative methods.
.. _tut-formatting:
Fancier Output Formatting Play with the output format
================================== ==============
So far we've encountered two ways of writing values: *expression statements* and
the :keyword:`print` statement. (A third way is using the :meth:`write` method
of file objects; the standard output file can be referenced as ``sys.stdout``.
See the Library Reference for more information on this.)
We have two very different The output value methods: *expression statement* and :keyword:`print` statement. (The third type of access
is to use the :meth:`write` method of the file object. For standard file output, please refer to
``sys.stdout``. For details, please refer to the library reference manual.)
.. index:: module: string
Often you'll want more control over the formatting of your output than simply
printing space-separated values. There are two ways to format your output; the
first way is to do all the string handling yourself ; using string slicing and
concatenation operations you can create any layout you can imagine. The
standard module :mod:`string` contains some useful operations for padding
strings to a given column width; these will be discussed shortly. The second
way is to use the :meth:`str.format` method.
Perhaps you often want to do some more complex control over the output format than simply printing the space delimiter. There are
two ways to format the output. The first is that you control the entire string, and you can use character cutting and concatenation operations to create any output form you want. The standard module :mod:`string` includes a number of operations that are useful when filling strings into given columns. We'll discuss this later.
The second method is to use the :meth:`str.format` method.
One question remains, of course: how do you convert values to strings? Fortunately,
Python has ways to convert any value to a string: pass it to the :func:`repr`
or :func:`str ` functions.
Of course, there is another question, how to convert the value into a string? Fortunately, Python has a way to convert any
value to a string: pass it into the :func:`repr` or :func:`str` function.
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 not 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 and
floating point numbers, in particular, have two distinct representations.
function:func: `str` is used to convert the value into a form suitable for human reading, and :func:`repr` is converted into a form readable by the interpreter (if there is no equivalent syntax, a :exc:`SyntaxError will occur `Exception) If an object does not have a human-readable interpretation form, :func:`str` will return a value equivalent to :func:`repr`. Many types, such as numerical values or structures such as linked lists and dictionaries, have a unified interpretation method for each function. Strings and
floating point numbers have unique interpretation methods.
Some examples:
The following are some examples::
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>> /7.0)
'0.14285714285714285'
>>> t; s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print s
The value of x is 32.5, and y is 40000...
>>> # The repr() of a string adds string quotes and backslashes:
... hello = 'hello, world/n'
>>> hellos = repr(hello)
>>> print hellos
'hello, world/n'
>>> # The argument to repr() may be any Python object:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
Here are two ways to write a table of squares and cubes:
有两种方式可以写平方和立方表 ::
>>> for x in range(1, 11):
... print repr(x).rjust(2), repr(x*x).rjust(3),
... # Note trailing comma on previous line
... print repr(x*x*x).rjust(4)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1,11):
... print '{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x)
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
(Note that in the first example, one space between each column was added by the
way :keyword:`print` works: it always adds spaces between its arguments.)
（注意第一个例子， :keyword:`print` 在每列之间加了一个空格，它总是在参
数间加入空格。）
This example demonstrates the :meth:`rjust` method of string objects, which
right-justifies a string in a field of a given width by padding it with spaces
on the left. There are similar methods :meth:`ljust` and :meth:`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]``.)
以上是一个 :meth:`rjust` 方法的演示，它把字符串输出到一列，并通过向左
侧填充空格来使其右对齐。类似的方法还有 :meth:`ljust` 和 :meth:`center`
。这些函数只是输出新的字符串，并不改变什么。如果输出的字符串太长，它们也不会截断
它，而是原样输出，这会使你的输出格式变得混乱，不过总强过另一种选择（截
断字符串），因为那样会产生错误的输出值。（如果你确实需要截断它，可以使
用切割操作，例如： ``x.ljust( n)[:n]`` 。）
There is another method, :meth:`zfill`, which pads a numeric string on the left
with zeros. It understands about plus and minus signs:
还有另一个方法， :meth:`zfill` 它用于向数值的字符串表达左侧填充 0。该
函数可以正确理解正负号 ::
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
Basic usage of the :meth:`str.format` method looks like this:
方法 :meth:`str.format` 的基本用法如下 ::
>>> print 'We are the {} who say "{}!"'.format('knights', 'Ni')
We are the knights who say "Ni!"
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 refers to the position of the object passed into the
:meth:`~str.format` method. :
大括号和其中的字符会被替换成传入 :meth:`~str.format` 的参数。大括号中
的数值指明使用传入 :meth:`~str.format` 方法的对象中的哪一个 ::
>>> print '{0} and {1}'.format('spam', 'eggs')
spam and eggs
>>> print '{1} and {0} '.format('spam', 'eggs')
eggs and spam
If keyword arguments are used in the :meth:`~str.format` method, their values
are referred to by using the name of the argument. :
If you use keyword arguments when calling :meth:`~str.format`, you can reference the
value by the parameter name::
>>> print 'This {food} is { adjective}.'.format(
... food='spam', adjective='absolutely horrible')
This spam is absolutely horrible.
Positional and keyword arguments can be arbitrarily combined:
Positioning and keywords Parameters can be used in combination::
>>> print 'The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
... ='Georg')
The story of Bill, Manfred, and Georg.
``'!s'`` (apply :func:`str`) and ``'!r'`` (apply :func: `repr`) can be used to
convert the value before it is formatted. :
``'!s'`` (applies to:func:`str` ) and ``'!r'`` (applies to: func:`repr` ) can
convert the value before formatting. ::
>>> import math
>>> print 'The value of PI is approximately {}.'.format(math.pi)
The value of PI is approximately 3.14159265359.
>>> print 'The value of PI is approximately {!r}.'.format(math.pi)
The value of PI is approximately 3.141592653589793.
An optional ``':'`` and format specifier can follow the field name. This allows
greater control over how the value is formatted. The following example
truncates Pi to three places after the decimal. ` and format directives. This allows for deeper
control over the formatting of values. The following example converts Pi to three digits of precision. ::
>>> import math
>>> print 'The value of PI is approximately {0:.3f}.'.format(math.pi)
The value of PI is approximately 3.142.
Passing an integer after the ``':'`` will cause that field to be a minimum
number of characters wide. This is useful for making tables pretty. :
``'' after the field :'`` Adding an integer after it will limit the minimum width of the field, which is very useful when beautifying tables. ::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print '{0:10} ==> {1:10d}'.format(name, phone)
... 7678
Sjoerd ==> 4127
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:
If you have a really long format string and don't want to split it. It would be nice if you could refer to the
formatted variable by name instead of position. There is a simple way to pass in a dictionary and access its keys using
brackets::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print ('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
... 'Dcab: {0[Dcab]: d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
This could also be done by passing the table as keyword arguments with the '**'
notation. Use the '**' flag to pass this dictionary as a keyword argument. ::
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: {Jack:d}; Sjoerd : {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table)
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
This is particularly useful in combination with the new built-in: func:`vars`
function, which returns a dictionary containing all local variables.
This approach works very well in combination with the new built-in function :func:`vars`. This function returns a dictionary containing all local variables.
For a complete overview of string formatting with :meth:`str.format`, see
:ref:`formatstrings`.
For a complete overview of string formatting with :meth:`str.format`, see
:ref:`formatstrings` .
Old string formatting Old string formatting
---------------------------------------- -----
The ``%`` operator can also be used for string formatting. It interprets the
left argument much like a :cfunc:`sprintf`/ -style format string to be applied
to the right argument, and returns the string resulting from this formatting
operation. For example:
operator ``%`` can also be used for string formatting. It parses the left argument in a way similar to :cfunc:`sprintf`, applies the right argument to it, and gets the string generated by the formatting operation, for example::
>>> import math
> >> print 'The value of PI is approximately %5.3f.' % math.pi
The value of PI is approximately 3.142.
Since :meth:`str.format` is quite new, a lot of Python code still uses the ``%``
operator. However, because this old style of formatting will eventually be
removed from the language, :meth:`str.format` should generally be used.
because :meth: `str.format` is still very new, and a lot of Python code still uses the ``%`` operator.
However, since the old formatting methods will eventually be removed from the language,
:meth:`str.format` should be used whenever possible.
More information can be found in the :ref:`string-formatting` section.
Further information can be found in the :ref:`string-formatting` section.
.. _tut-files:
Reading and Writing Files Reading and Writing Files
================================ ===============
.. index::
builtin: open
object: file
:func:`open` returns a file object, and is most commonly used with two
arguments: ``open(filename, mode)``.
Function:func:`open` returns the file object. Common usage requires two parameters:
``open(filename, mode)`` .
::
>>> f = open('/tmp/workfile', 'w')
>>> print f
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.
The first parameter is a string identifying the file name. The second parameter is a character string consisting of a limited number of letters, describing how the file will be used. Optional *modes* are: ``'r'``, this option makes the file read-only;
``'w'``, this option makes the file write-only (for files with the same name, this operation makes the original file overwritten); ``'a'``,
This option opens the file in append mode; ``'r+'``, this option opens the file in read-write mode;
*mode* parameter is optional. If not specified, defaults to ``'r'`` mode.
On Windows, ``'b'`` appended to the mode opens the file in binary mode, so there
are also modes like ``'rb'``, ``'wb'``, and `` 'r+b'``. Python on Windows makes
a distinction between text and binary files; the end-of-line characters in text
files are automatically altered slightly when data is read or written. This
behind- the-scenes modification to file data is fine for ASCII text files, but
it'll 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. On Unix,
it doesn't hurt to append a ``'b'`` to the mode, so you can use it
platform-independently for all binary files.
On Windows On the platform, the ``'b'`` mode opens the file in binary mode, so there may
be similar to ``'rb'``, ``'wb'``, ``'r+b'`` Wait for the combination of modes. There is a difference between text files and binary files on the Windows platform. When reading and writing text files, line terminators are automatically added to the end of the lines. This kind of backstage fucking
The operation method has no problem with ASCII text files, but it will cause damage when operating binary
files such as JPEG or .EXE. When operating these files, be sure to open them in binary mode. On
Unix, it is also harmless to add a ``'b'`` mode, so you can use it platform-independently in all binary file processing.
.. _tut-filemethods:
Methods of File Objects File object methods
---------------------------------- ----------
The rest of the examples in this section will assume that a file object called
``f`` has already been created.
The examples in this section are all default file objects ``f`` has been created.
To read a file's contents, call ``f.read(size)``, which reads some quantity of
data and returns it as a string. *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* bytes are read and returned. If the end of
the file has been reached, ``f.read()`` will return an empty string (``""``).
To read the file content, you need to call ``f.read( size)``, this method reads a certain amount of data and returns its content in the form of a character string. *size* is an optional value that specifies the length of the string. If
size is not specified or is specified as a negative number, the entire file will be read and returned. Problems arise when the file size is twice
times the current machine memory. On the contrary, data will be read and returned as large as possible.
If the end of the file is reached, f.read() will return an empty string ("").
::
>>> f.read()
'This is the entire file./n'
>>> f.read()
''
`` 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.
``f.readline()`` reads a single line from the file, and a newline is automatically added to the end of the string character
( ``/n`` ), this operation will be ignored only if the last line of the file does not end with a newline character.
This way there will be no confusion about the return value. If ``f.readline()`` returns an empty string, it means
that the end of the file has been reached. If it is a blank line, it will be described as ` `'/n`` , a string containing only newlines. ::
>>> f.readline()
'This is the first line of the file./n'
>>> f.readline()
'Second line of the file/n'
>>> f.readline()
''
``f.readlines()`` returns a list containing all the lines of data in the file.
If given an optional parameter *sizehint*, it reads that many bytes from the
file and enough more to complete a line, and returns the lines from that. This
is often used to allow efficient reading of a large file by lines, but without
having to load the entire file in memory. Only complete lines will be returned.
f.readlines() returns a list containing all the data lines in the file. If the
*sizehint* parameter is given, more than one line of bits will be read in and multiple lines of text will be returned. This feature
is typically used to efficiently read large line files, avoiding the need to read the entire file into memory. This operation only returns complete rows. ::
>>> f.readlines()
['This is the first line of the file./n', 'Second line of the file/n']
An alternative approach to reading lines is to loop over the file object. This is easy to remember, fast and the code is simpler::
>>> for line in f:
print line,
This is the first line of the file.
Second line of the file
The alternative approach is simpler but does not provide as fine-grained
control. Since the two approaches manage line buffering differently, they
should not be mixed.
This approach is simple but does not provide complete control of the operation. Because the two methods manage buffers in different ways, they cannot be mixed.
``f.write(string)`` writes the contents of *string* to the file, returning
``None``.
``f.write(string)`` 将 *string* 的内容写入文件，返回 ``None`` 。 ::
>>> f.write('This is a test/n')
To write something other than a string, it needs to be converted to a string
first:
如果需要写入字符串以外的数据，就要先把这些数据转换为字符串。 ::
>>> value = ('the answer', 42)
>>> s = str(value)
>>> f.write(s)
``f.tell()`` returns an integer giving the file object's current position in the
file, measured in bytes from the beginning of the file. To change the file
object's position, use ``f.seek(offset, from_what)``. The position is computed
from adding *offset* to a reference point; the reference point is selected by
the *from_what* argument. A *from_what* 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. *from_what* can be omitted and defaults to 0, using the
beginning of the file as the reference point.
``f.tell()`` 返回一个整数，代表文件对象在文件中的指针位置，该数值计量了自文
件开头到指针处的比特数。需要改变文件对象指针话话，使用
``f.seek(offset,from_what)`` 。指针在该操作中从指定的引用位置移动 *offset*
比特，引用位置由 *from_what* 参数指定。 *from_what* 值为 0 表示自文件
起始处开始，1 表示自当前文件指针位置开始，2 表示自文件末尾开始。 *from_what* 可以
忽略，其默认值为零，此时从文件头开始。 ::
>>> f = open('/tmp/workfile', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5) # Go to the 6th byte in the file
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # Go to the 3rd byte before the end
>>> f.read(1)
'd'
When you're done with a file, call ``f.close()`` to close it and free up any
system resources taken up by the open file. After calling ``f.close()``,
attempts to use the file object will automatically fail.
文件使用完后，调用 ``f.close()`` 可以关闭文件，释放打开文件后占用的系统资源。
调用 ``f.close()`` 之后，再调用文件对象会自动引发错误。 ::
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "
ValueError: I/O operation on closed file
It is good practice to use the :keyword:`with` keyword when dealing with file
objects. This has the advantage that the file is properly closed after its
suite finishes, even if an exception is raised on the way. It is also much
shorter than writing equivalent :keyword:`try`/ -/ :keyword:`finally` blocks
用关键字 :keyword:`with` 处理文件对象是个好习惯。它的先进之处在于文件
用完后会自动关闭，就算发生异常也没关系。它是 :keyword:`try`/ -/
:keyword:`finally` 块的简写。 ::
>>> with open('/tmp/workfile', 'r') as f:
... read_data = f.read()
>>> f.closed
True
File objects have some additional methods, such as :meth:`~file.isatty` and
:meth:`~file.truncate` which are less frequently used; consult the Library
Reference for a complete guide to file objects.
文件对象还有一些不太常用的附加方法，比如 :meth:`~file.isatty` 和 :meth:`~file.truncate` 在库参
考手册中有文件对象的完整指南。
.. _tut-pickle:
The :mod:`pickle` Module :mod:`pickle` 模块
------------------------------------------------
.. index:: module: pickle
Strings can easily be written to and read from a file. Numbers take a bit more
effort, since the :meth:`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. However, when you want to save more complex
data types like lists, dictionaries, or class instances, things get a lot more
complicated.
We can easily read and write strings in files. Numerical values require a little more trouble, because the :meth:`read`
method will only return a string. It should be passed into a method like :func:`int`, and then the
``'123 Characters like '`` are converted to the corresponding value 123. However, things become more complicated when you need to save more complex data types, such as lists, dictionaries, and class instances.
Rather than have users be constantly writing and debugging code to save
complicated data types, Python provides a standard module called :mod:`pickle`.
This is an amazing module that can take almost any Python object (even some
forms of Python code!), and convert it to a string representation; this process
is called :dfn:`pickling`. Reconstructing the object from the string
representation is called :dfn:`unpickling`. Between pickling and unpickling,
the string representing the object may have been stored in a file or data, or
sent over a network connection to some distant machine.
Fortunately, users do not have to write and debug to save complex data types themselves. code. Python provides
a standard module called :mod:`pickle`. This is an amazing module that can express almost any
Python object (even some Python code snippets!) as a string, a process called
encapsulation ( :dfn:`pickling` ). Reconstructing an object from a string expression is called unpickling ( :dfn:`unpickling` ). Objects in the encapsulated state can be stored in files or objects, and can also be transferred between remote machines through the network.
If you have an object ``x``, and a file object ``f`` that's been opened for
writing, the simplest way to pickle the object takes only one line of code
If you have an object ``x``, a file object ``f`` opened in write mode, the simplest
method to encapsulate an object only requires one line of code::
pickle.dump(x, f)
To unpickle the object again, if ``f`` is a file object which has been opened
for reading
If ``f`` is a file object opened in read mode, you can reload and unpack this object::
x = pickle.load(f)
(There are other variants of this, used when pickling many objects or when you
don't want to write the pickled data to a file; consult the complete
documentation for : mod:`pickle` in the Python Library Reference.)
(If you don’t want to write the packed data to a file, there are some other variations available. The complete
:mod:`pickle` documentation can be found in the Python Library Reference. manual).
:mod:`pickle` is the standard way to make Python objects which can be stored and
reused by other programs or by a future invocation of the same program; the
technical term for this is a :dfn:` persistent` object. Because :mod:`pickle` is
so widely used, many authors who write Python extensions take care to ensure
that new data types such as matrices can be properly pickled and unpickled.
:mod:` pickle` is a standard way of storing Python objects for later use by other programs or itself. Providing
this set of technologies is a :dfn:`persistent` object. Because :mod:`pickle` is widely used, many Python extension authors pay great attention to whether new data types like matrices are suitable for packaging and unpacking.
The above is the basic tutorial of Python 2.7: input and output content. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
