Ввод и вывод

7.1.1. Форматированные строковые литералы

Форматированные строковые литералы (сокращённо f-строки) позволяют включать значения выражений Python в строку: для этого перед строкой ставят f или F, а выражения записывают в виде {expression}.

После выражения можно указать необязательную спецификацию формата. Она позволяет точнее управлять форматированием значения. В следующем примере число пи округляется до трёх знаков после десятичной точки:

>>> import math
>>> print(f'The value of pi is approximately {math.pi:.3f}.')
The value of pi is approximately 3.142.

Если после ':' указать целое число, соответствующее поле будет иметь минимальную ширину в заданное количество символов. Это удобно для выравнивания столбцов.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print(f'{name:10} ==> {phone:10d}')
...
Sjoerd     ==>       4127
Jack       ==>       4098
Dcab       ==>       7678

Для преобразования значения перед форматированием можно использовать и другие модификаторы. '!a' применяет функцию ascii(), '!s' — функцию str(), а '!r' — функцию repr():

>>> animals = 'eels'
>>> print(f'My hovercraft is full of {animals}.')
My hovercraft is full of eels.
>>> print(f'My hovercraft is full of {animals!r}.')
My hovercraft is full of 'eels'.

Спецификатор = можно использовать, чтобы развернуть выражение в текст самого выражения, знак равенства, а затем представление вычисленного выражения:

>>> bugs = 'roaches'
>>> count = 13
>>> area = 'living room'
>>> print(f'Debugging {bugs=} {count=} {area=}')
Debugging bugs='roaches' count=13 area='living room'

Подробнее о спецификаторе = см. в разделе самодокументирующиеся выражения. Описание этих спецификаций формата см. в справочнике по мини-языку спецификаций формата.

7.1.2. Метод format() строк

Базовый способ использования метода str.format() выглядит так:

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!"

Скобки и символы внутри них (так называемые поля формата) заменяются объектами, переданными методу 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.

Если строка формата очень длинная и вы не хотите разбивать её на части, удобно ссылаться на форматируемые переменные по имени, а не по позиции. Для этого достаточно передать словарь и использовать квадратные скобки '[]' для доступа к ключам.

>>> 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 в качестве именованных аргументов с помощью обозначения **.

>>> 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(), которая возвращает словарь со всеми локальными переменными:

>>> table = {k: str(v) for k, v in vars().items()}
>>> message = " ".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])
>>> print(message.format(**table))
__name__: __main__; __doc__: None; __package__: None; __loader__: ...

Например, следующие строки создают аккуратно выровненные столбцы с целыми числами, их квадратами и кубами:

>>> 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

Полный обзор форматирования строк с помощью str.format() см. в разделе Синтаксис строк формата.

7.1.3. Форматирование строк вручную

Вот та же таблица квадратов и кубов, отформатированная вручную:

>>> 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

(Обратите внимание, что пробел между столбцами добавляется особенностью работы функции 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'

7.1.4. Старое форматирование строк

Для форматирования строк также можно использовать оператор % (остаток от деления). Если задано format % values (где format — строка), спецификации преобразования % в format заменяются нулём или несколькими элементами из values. Эта операция обычно называется интерполяцией строк. Например:

>>> import math
>>> print('The value of pi is approximately %5.3f.' % math.pi)
The value of pi is approximately 3.142.

Дополнительную информацию можно найти в разделе Форматирование строк в стиле printf.

7.2.1. Методы файловых объектов

В остальных примерах этого раздела предполагается, что файловый объект с именем f уже создан.

Чтобы прочитать содержимое файла, вызовите f.read(size). Этот метод считывает некоторое количество данных и возвращает их в виде строки (в текстовом режиме) или объекта bytes (в двоичном режиме). Аргумент size — необязательный числовой аргумент. Если size не задан или отрицателен, будет прочитано и возвращено всё содержимое файла; если файл вдвое больше объёма памяти вашего компьютера, это уже ваша проблема. В противном случае будет прочитано и возвращено не более size символов (в текстовом режиме) или size байтов (в двоичном режиме). Если достигнут конец файла, 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(string) записывает содержимое string в файл и возвращает количество записанных символов.

>>> f.write('This is a test\n')
15

Перед записью объекты других типов необходимо преобразовать в строку (в текстовом режиме) или объект bytes (в двоичном режиме):

>>> value = ('the answer', 42)
>>> s = str(value)  # convert the tuple to string
>>> f.write(s)
18

f.tell() возвращает целое число, указывающее текущую позицию файлового объекта: в двоичном режиме это количество байтов от начала файла, а в текстовом режиме — непрозрачное значение.

Чтобы изменить позицию файлового объекта, используйте f.seek(offset, whence). Позиция вычисляется как сумма offset и точки отсчёта, которая выбирается аргументом whence. Значение whence, равное 0, задаёт отсчёт от начала файла; 1 — от текущей позиции в файле; 2 — от конца файла. Аргумент whence можно опустить; по умолчанию он равен 0, то есть точкой отсчёта служит начало файла.

>>> 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(0, 2)), а допустимыми значениями offset являются только значения, возвращённые методом f.tell(), или ноль. Любое другое значение offset приводит к неопределённому поведению.

У файловых объектов есть и другие методы, например isatty() и truncate(), которые используются реже; полное руководство по файловым объектам см. в Справочнике по библиотеке.

7.2.2. Сохранение структурированных данных с помощью json

Строки легко записывать в файл и считывать из него. С числами немного сложнее, поскольку метод read() возвращает только строки. Их нужно передать такой функции, как int(), которая принимает строку вроде '123' и возвращает числовое значение 123. Когда требуется сохранить более сложные типы данных, например вложенные списки и словари, ручной разбор и сериализация становятся непростой задачей.

Вместо того чтобы заставлять пользователей постоянно писать и отлаживать код для сохранения сложных типов данных в файлах, Python позволяет использовать популярный формат обмена данными JSON (JavaScript Object Notation). Стандартный модуль json преобразует иерархии данных Python в строковое представление; этот процесс называется сериализацией. Восстановление данных из строкового представления называется десериализацией. Между сериализацией и десериализацией строковое представление объекта может быть сохранено в файле или данных либо отправлено по сетевому соединению на удалённый компьютер.

Если у вас есть объект x, его строковое представление в формате JSON можно посмотреть с помощью простой строки кода:

>>> import json
>>> x = [1, 'simple', 'list']
>>> json.dumps(x)
'[1, "simple", "list"]'

Другой вариант функции dumps(), называемый dump(), просто сериализует объект в текстовый файл. Поэтому, если f — это объект текстового файла, открытый для записи, можно сделать следующее:

json.dump(x, f)

Чтобы снова декодировать объект, если f — это объект двоичного файла или текстового файла, открытый для чтения:

x = json.load(f)

Этот простой способ сериализации подходит для списков и словарей, но для сериализации произвольных экземпляров классов в JSON потребуются дополнительные усилия. Объяснение можно найти в справочнике по модулю json.