7. Вход и выход¶

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

Formatted string literals (для краткости также называемые f-строками) позволяют включать значения выражений Python в строку, добавляя к строке префикс f или F и записывая выражения в виде {expression}.

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

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

Смотрите self-documenting expressions для получения дополнительной информации о заданном формате =. Для получения информации об этих спецификациях формата смотрите справочное руководство для Мини-язык спецификации формата.

7.1.2. Метод String 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() используются ключевые слова arguments, то ссылка на их значения производится с использованием имени аргумента.

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

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

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

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

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

Оператор % (по модулю) также может использоваться для форматирования строк. При заданном 'string' % values экземпляры % в string заменяются нулем или более элементов 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), который считывает некоторое количество данных и возвращает их в виде строки (в текстовом режиме) или байтового объекта (в двоичном режиме). размер - необязательный числовой аргумент. Если значение 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

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

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

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

Чтобы изменить положение файлового объекта, используйте f.seek(offset, whence). Положение вычисляется путем добавления offset к опорной точке; опорная точка выбирается с помощью аргумента where. Значение where, равное 0, отсчитывается от начала файла, 1 использует текущее положение файла, а 2 использует конец файла в качестве точки отсчета. where может быть опущено и по умолчанию равно 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)), и единственными допустимыми значениями смещения являются те, которые были возвращены из f.tell(), или равны нулю. Любое другое значение offset приводит к неопределенному поведению.

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

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

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

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

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

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

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

json.dump(x, f)

Чтобы снова расшифровать объект, если f является binary file или text file объектом, который был открыт для чтения:

x = json.load(f)

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