Ввод и вывод
Ознакомить пользователя с выводом программы можно различными способами — данные могут быть выведены в читаемом виде или записаны в файл для последующего использования. Часть возможностей будет обсуждена в этой главе.
Удобное форматирование вывода
На данный момент мы выяснили два способа вывода значений: операторные выражения (expression statements) и функция print(). (Третий способ — использование метода write() объектов файлов; на файл стандартного вывода можно сослаться как на sys.stdout.
Более подробную информацию по этому пункту смотрите в Справочнике по библиотеке.)
Часто возникает желание иметь больший контроль над форматированием вывода, чем обычная печать значений разделённых пробелами. Есть два способа форматирования вашего вывода. Первый способ — выполнять самостоятельно всю работу над строками: используя срезы строк и конкатенацию вы можете создать любой шаблон, какой пожелаете. Тип string содержит много полезных операций для выравнивания строк по определённой ширине колонки (скоро мы их кратко рассмотрим). Второй способ — использование форматированных строковых литералов, или метода str.format().
Модуль string содержит класс Template, который предоставляет ещё один способ подстановки значений в строки.
Остаётся, конечно, один вопрос: каким образом конвертировать значения в строки? К счастью, в Python есть два способа для преобразования любого значения в строку — это функции repr() и str().
Предназначение функции str() — возврат значений в довольно-таки читабельной форме; в отличие от repr(), чьё назначение — генерирование форм, которые могут быть прочитаны интерпретатором (или вызовут ошибку SyntaxError, если эквивалентного синтаксиса не существует). Для тех объектов, у которых нет формы для человеческого прочтения функция str() возвратит такое же значение, как и repr(). У многих значений, таких как числа или структуры, вроде списков и словарей, одинаковая форма для обеих функций. Строки и числа с плавающей точкой, в частности, имеют по две разных формы.
Несколько примеров:
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> 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'))"
Вот два способа вывести таблицу квадратов и кубов:
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # Note use of 'end' 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
(Обратите внимание, что в первом примере единичные пробелы между колонками добавлены функцией print(): она всегда вставляет пробелы между своими параметрами.)
Этот пример демонстрирует работу метода строковых объектов str.rjust(), выравнивающего строку по правому краю в поле переданной ширины, отступая пробелами слева. Имеются также похожие методы str.ljust() и str.center(). Эти методы не выводят ничего, они лишь возвращают новую строку. Если строка на входе чересчур длинная, то они не усекают её, а возвращают без изменения; это испортит вашу столбцовую разбивку, но обычно это лучше, чем альтернатива, которая бы наврала о значении. (Если вам действительно хочется сделать обрезку, то всегда можно добавить операцию среза,
например: x.ljust(n)[:n].)
Есть другой метод — str.zfill(), который заполняет нулями пространство слева от числовой строки. Он распознаёт знаки плюс и минус:
>>> '12'.zfill(5) '00012' >>> '-3.14'.zfill(7) '-003.14' >>> '3.14159265359'.zfill(5) '3.14159265359'
Основной способ применения метода str.format() выглядит так:
>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"
Скобки с символами внутри (их называют полями форматирования (format fields)) заменяются на объекты, переданные методу str.format(). Номер в скобках обозначает позицию объекта в списке параметров, переданных методу str.format().
>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam
Если в методе str.format() используются именованные параметры, можно ссылаться на их значения, используя имя соответствующего аргумента.
>>> print('This {food} is {adjective}.'.format(
... food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.
Позиционные и именованные параметры можно произвольно совмещать:
>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
other='Georg'))
The story of Bill, Manfred, and Georg.
‘!a’ (применяет ascii()), ‘!s’ (применяет str()) и ‘!r’
(применяет repr()) могут быть использованы для преобразования значения до его форматирования:
>>> contents = 'eels'
>>> print('My hovercraft is full of {}.'.format(contents))
My hovercraft is full of eels.
>>> print('My hovercraft is full of {!r}.'.format(contents))
My hovercraft is full of 'eels'.
После имени поля может следовать необязательный спецификатор формата ‘:’. Это позволяет лучше управлять тем, как форматируются значения. Следующий
пример оставляет у числа Пи только три цифры после десятичного разделителя.
>>> import math
>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))
The value of PI is approximately 3.142.
После спецификатора ‘:’ можно указать число —
минимальную ширину поля, выраженную в количестве символов. Это удобно
использовать для создания красивых таблиц:
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
... print('{0:10} ==> {1:10d}'.format(name, phone))
...
Jack ==> 4098
Dcab ==> 7678
Sjoerd ==> 4127
Если ваша строка с форматами очень длинна, а вы не хотите разбивать её на подстроки, было бы неплохо если бы вы могли ссылаться на переменные, предназначенные для форматирования, не по позиции, а по имени. Это можно сделать, просто передав словарь и используя квадратные скобки ‘[]’ для доступа к ключам.
>>> 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
Тоже самое можно сделать, передав словарь именованных параметров, используя нотацию «**»:
>>> 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
В частности, такой приём удобно использовать в сочетании со встроенной функцией vars(), которая возвращает словарь с локальными переменными.
Подробное описание форматирования строк с применением метода str.format() описано в разделе Синтаксис строк форматирования.
Форматирование строк в старом стиле
Для форматирования строк можно использовать и операцию %. Она интерпретирует левый операнд как строку форматирования в стиле sprintf, которую следует применить к правому операнду, и возвращает строку, получившуюся в результате этого преобразования. Например:
>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.
Больше информации можно найти в разделе Операции форматирования строк в старом стиле.
Чтение и запись файлов
Функция open() возвращает объект файла и в большинстве случаев используется с двумя аргументами: open(имя_файла, режим).
>>> f = open('workfile', 'w')
Первый параметр — строка, содержащая имя файла. Второй — другая строка, содержащая несколько символов, описывающих способ использования файла. Значение параметра режим может быть символом 'r', если файл будет открыт только для чтения, 'w' — открыт только для записи (существующий файл с таким же именем будет стёрт) и 'a' — файл открыт для добавления: любые данные, записанные в файл автоматически добавляются в конец. 'r+' открывает файл и для чтения, и для записи. Параметр режим необязателен: если он опущен — предполагается, что он равен 'r'.
В обычном случае файлы открываются в текстовом режиме (text mode) — это значит что вы читаете из файла и записываете в файл строки в определённой кодировке. Если кодировка не указана явно, то используется кодировка по умолчанию, которая зависит от платформы (см. open()). Если добавить к режиму файла символ ‘b’, файл открывается в двоичном режиме (binary mode):
теперь данные считываются и записываются в виде двоичных объектов. Этот режим следует использовать для всех файлов, которые не содержат текст.
При использовании текстового режима, все окончания строк, по умолчанию, специфичные для платформы (\n в Unix, \r\n в Windows) усекаются до символа \n, при чтении из файла. При записи в текстовом режиме, по умолчанию вхождения \n конвертируются обратно в окончания строк, специфичные для платформы. Эти закулисные
изменения в файловых данных корректно работают в случае текстовых
файлов, но испортят двоичные данные в файлах вроде JPEG или EXE. Внимательно следите за тем, чтобы использовать двоичный режим при чтении и записи таких файлов.
Методы файловых объектов
В примерах ниже подразумевается, что заранее создан файловый объект с именем f.
Чтобы прочитать содержимое файла, вызовите f.read(размер) — функция читает некоторое количество данных и возвращает их в виде строки или байтового объекта. размер — необязательный числовой параметр. Если размер
опущен или отрицателен, будет прочитано и возвращено всё содержимое
файла; если файл по величине в два раза больше оперативной памяти вашего
компьютера, то решение этой проблемы остаётся на вашей совести. В
противном случае, будет прочитано и возвращено максимум размер байт.
Если был достигнут конец файла, f.read() вернёт пустую строку ('').
>>> f.read() 'This is the entire file.\n' >>> f.read() ''
f.readline() читает одну строку из файла; символ новой строки (\n)
остаётся в конце прочитанной строки и отсутствует при чтении последней
строки файла только если файл не оканчивается пустой строкой. За счёт
этого возращаемое значение становится недвусмысленным: если f.readline() возвращает пустую строку — достигнут конец файла, в то же время незаполненная строка, представленная посредством '\n', содержит лишь символ новой строки.
>>> f.readline() 'This is the first line of the file.\n' >>> f.readline() 'Second line of the file\n' >>> f.readline() ''
Для чтения строк из файла можно перебрать файловый объект в цикле. Он быстр, рационально использует память и имеет простой код в результате:
>>> for line in f: ... print(line, end='') ... This is the first line of the file. Second line of the file
Если вы хотите прочитать все строки из файла в список, вы также можете использовать list(f) или f.readlines().
f.write(строка) записывает содержимое строки в файл и возвращает количество записанных байтов.
>>> f.write('This is a test\n')
15
Чтобы записать в файл нечто отличное от строки, предварительно это нечто нужно в строку сконвертировать:
>>> value = ('the answer', 42)
>>> s = str(value) # convert the tuple to string
>>> f.write(s)
18
f.tell() возвращает целое, представляющее собой текущую позицию в файле
Чтобы изменить позицию объекта-файла, используйте f.seek(смещение, откуда). Позиция вычисляется прибавлением смещения к точке отсчёта; точка отсчёта выбирается из параметра откуда. Значение 0 параметра откуда отмеряет смещение от начала файла, значение 1 применяет текущую позицию в файле, а значение 2 в качестве точки отсчёта использует конец файла.
>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # Go to the 6th byte in the file
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # Go to the 3rd byte before the end
13
>>> f.read(1)
b'd'
При работе с текстовыми файлами (открытыми без символа b в строке режима), выполнять позиционирование (seek) позволяется только от начала файла (за исключением прокрутки в конец файла с использованием seek(0, 2)) и только те значения смещение допустимы, что возвращаются от f.tell() или 0. Любые другие значения offset производят неопределенное поведение.
Когда вы закончили все действия над файлом, вызовите f.close()
чтобы закрыть его и освободить все системные ресурсы, использованные
при открытии этого файла. Все попытки использовать объект-файл после
вызова f.close() приведут к возникновению исключения.
>>> f.close() >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: I/O operation on closed file
Считается хорошей манерой использовать ключевое слово
>>> with open('workfile', 'r') as f:
... read_data = f.read()
>>> f.closed
True
У объектов-файлов есть ещё несколько дополнительных методов, таких как isatty() и truncate(), которые используются не так часто; обратитесь к Справочнику по библиотеке для более полного обзора по файловым объектам.
Сохранение структурированных данных с json
Строки могут быть легко записаны и прочитаны из файла. Числа требуют немного большего усилия, потому что методо read() возвращает только строки, которые придется передать функции типа int(), которая принимает строку типа '123' и возвращает ее числовое значение 123. Если вы хотите сохранить более сложные типы данных типа списков и словарей, парсинг и сериализация вручную усложняется.
Вместо того, чтобы принуждать пользователей постоянно писать и отлаживать код для сохранения сложных типов данных в файлы, Python позволяет вам использовать популярный формат обмена данными, называемый JSON (JavaScript Object Notation). Стандарный модуль под названием json может брать на входе иерархии данных Python-а, и преобразовывать их в строковые представления; этот процесс называется сериализацией. Восстановление данных из строкового представления называется десериализацией. Между сериализацией и десериализацией строка, представляющией объект, может быть сохранена в файле или в данных, или быть послана по сетевому соединению на некоторую удаленную машину.
Замечание
Формат JSON часто используется современными приложениями для обмена данными. Многи программисты уже знакомы с ним, что делает его хорошим выбором ради совместимости.
Если у вас есть объект x, вы можете посмотреть его строковое представление с помощью простой строчки кода:
>>> json.dumps([1, 'simple', 'list']) '[1, "simple", "list"]'
Другой вариант функкции dumps(), называемый dump(), просто сериализует объект в текстовый файл. Так что если f это
объект текстовый файл, открытый для записи, мы можем сделать это:
json.dump(x, f)
Для декодирования объекта обратно, если f это объект текстовый файл, открытый для чтения:
x = json.load(f)
Это простая техника сериализации может обрабатывать списки и словари, но сериализация проивольных экземпляров классов в JSON требует немного дополнительных усилий. Справка по модулю json содержит объяснение этого.
Смотрите также
pickle - модуль "засолки"
Вопреки JSON, pickle есть протокол, который позволяет сериализацию сколь угодно сложных объектов Python. Как таковой, он специфичен для Python и не может быть использован для коммуникации с приложениями, написанными на других языках. Он также небезопасен по умолчанию: десериализация данных pickle, поступающих из ненадежного источника может выполнить произвольный код, если данные были смастерены опытным злоумышленником.