Форматированный ввод/вывод

Форматированный ввод/вывод.

В Питоне вы можете считывать данные либо с клавиатуры, либо с файла и выводить на монитор или также в файл. Разницы для программиста между файлом и дисплеем нет никакой(они представлены в виде потока байт). В файле обычно нужно сохранять те значения, которые можно впоследствие вновь использовать.

Форматированный ввод/вывод – это совокупность операций, обеспечивающая ввод/вывод высокого уровня переменных с применением определённого формата ввода/вывода.

В Питоне имеется несколько способов форматированного ввода/вывода. Самый простой из них – оператор print, печатающий переменные и строковые константы, применяя формат по умолчанию. Другой простой способ вывода данных на дисплей – функция str(), которая выводит любую переменную, используя также формат по умолчанию. Есть также функция repr(), которая выводит данные в машинном(неформатированном) виде. Некоторые типы переменных, которые не могут должным образом отформатироваться функцией str(), обрабатываются схоже с repr(). Пример использования функций str() и repr():

>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> `s`#Такое выражение значит то же, что и repr(s)
"'Hello, world.'"#Машинный формат
>>> str(0.1)#Переменная с точкой
'0.1'
>>> `0.1`# repr(0.1)
'0.10000000000000001'#Ошибка округления чисел с точкой
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'Значение x равно' + `x` + ', а y равен ' + `y` + '...'#Использование операций склеивания 

... #строк для форматирования
>>> print s
Значение x равно 32.5, а y равен 40000...
>>> #Заключение переменных в кавычки работает для всех типов данных
... p = [x, y] 
>>> ps = repr(p)
>>> ps 
'[32.5, 40000]'
>>> # Окружение строки дополнительными кавычками
... hello = 'hello, world\n'
>>> hellos = `hello`
>>> print hellos
'hello, world\n'
>>> # Можно заключать в кавычки и константные списки
... `x, y, ('Linux', 'BSD')`
"(32.5, 40000, ('Linux', 'BSD'))"

Для форматированного вывода удобно использовать выравнивание по краю. Для этой цели в Питоне предусмотрены следующие функции модуля string: string.rjust(), string.ljust() и string.center(). Эти функции возвращают выровненную строку по правому и левому краю, а также по центру до определённого количества символов. Они принимают два параметра: саму строку и количество символов, зарезервированных под строку(если строка длинее, то она выводится как есть, а для удаления лишних символов воспользуйтесь “string.ljust(x, n)[0:n]#”). На примере это выглядит так:

>>> import string
>>> for x in range(1, 11):
...     print string.rjust(`x`, 2), string.rjust(`x*x`, 3),
...     # В предыдущем операторе print была поставлена в конце запятая, перевода строки нет:
...     print string.rjust(`x*x*x`, 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 со строкой формата, аналогичной Си:

>>> for x in range(1,11):
...     print '%2d %3d %4d' % (x, x*x, x*x*x)# %d означает целое число
... 

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

Очевидно, что число после символа процента определяет количество символов для выравнивания. Спецификатор после процента обозначает тип числа:

%d

Целое число

%f

Число с точкой

%s

Строка

%c

Символ

%e

Число в научном формате

Функция string.zfill() возвращает строку, дополненную нулями слева, если её длина меньше заданной. string.zfill(строка, заданная_ширина):

>>> import string
>>> string.zfill('12', 5)
'00012'
>>> string.zfill('-3.14', 7)
'-003.14'
>>> string.zfill('3.14159265359', 5)
'3.14159265359'

Если использовать оператор print, то можно для той же цели использовать конструкцию “%ширина_поля.число_знаков_после_запятой”:

>>> import math
>>> print 'Значение числа Пи приблизительно  %5.3f.' % math.pi
Значение числа Пи приблизительно 3.142.

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

>>> table = {'Иван': 4127, 'Жека': 4098, 'Илья': 7678}
>>> for name, phone in table.items():
...     print '%-10s ==> %10d' % (name, phone)
... 

Иван      ==>       4098
Жека      ==>       7678
Илья       ==>       4127

Для оператора print можно передавать аргументы не по порядку в строке формата, а по именам переменных, описанных в строке формата следующим образом “%(имя_переменной)тип_переменной”:

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Операции с файлами.

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

Метод open(имя, режим). Открывает файловый объект для последующего оперирования с ним. Функция принимает два параметра: строку, содержащую путь к файлу(может быть абсолютным или относительным текущего каталога или переменной окружения PATH) и режимом открытия файла. Режим открытия файла определяет допустимые операции доступа к файлу:

w	Открыть файл для записи. Если такой файл уже существует, то его содержимое исчезает(если это возможно).
r	Открыть файл только для чтения.
a	Открыть файл для добавления, т.е. записи в конец файла. Предыдущее содержимое файла сохраняется.
r+	Открыть файл для записи/чтения, содержимое файла сохраняется.
w+	Открыть файл для записи/чтения, содержимое файла исчезает(см w).
r+b	Открыть двоичный (если такие файлы поддерживаются операционной системой) файл для записи/чтения, содержимое файла сохраняется.
w+b	Открыть двоичный файл для записи/чтения, содержимое файла исчезает(см w).
rb	Открыть двоичный файл только для чтения.
wb	Открыть двоичный файл для записи. Если такой файл уже существует, то его содержимое исчезает(если это возможно).

Двоичные файлы обеспечивают более быстрый доступ к данным, но бывают не переносимы и, к тому же, их сложно редактировать и просматривать. Текстовые файлы применимы в большинстве случаев, так как они переносимы, легко просматриваются и редактируются, но они медленнее двоичных и могут отображать корректно только символы набора ASCII.

>>> f=open('/tmp/workfile', 'w')
>>> print f
<open file '/tmp/workfile', mode 'w' at 80a0960>

Метод read([число_байт]). Данный метод читает из файла, открытого для чтения число байтов, указанных в качестве аргумента. Если метод вызывается без параметров, то читается весь файл, если файл был прочитан до конца(встретился символ EOF), то метод read() возвращает пустую строку:
```
>>> f.read()
'This is the entire file.\n'
>>> f.read()
''
```
Метод readline() читает одну строку файла до символа перевода строки(включая сам символ \n). Если строка состоит только из символа перевода строки, то метод readline() возвращает пустую строку. Если в конце файла нет пустой строки с символом \n, то возвращаемый результат неопределён(этого допускать нельзя):
```
>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''
```
Метод readlines([размер_строки]) читает все строки файла в список. Читаются только законченные строки. Необязательный параметр размер_строки дополняет читает строку, и если она меньше указанной длины читает дальше, до достижения указанного числа символов, такой приём эффективен для чтения очень больших файлов построчно без необходимости размещения его в памяти:
```
>>> f.readlines()
['This is the first line of the file.\n', 'Second line of the file\n']
```
Метод write(строка) пишет в файл указанную строку, ничего при этом не возвращая:
```
>>> f.write('This is a test\n')
```
Метод seek(на_сколько_байт[, откуда]) перемещает указатель текущего положения файла на заданное количество байт от позиции, указанной вторым аргументом:

0(по умолчанию)	1	2
начало файла	текущая позиция в файле	конец файла

При этом, число байт для перемещения может быть как положительным, так и отрицательным(назад).

Метод tell() возвращает текущую позицию в файле:

>>> f=open('/tmp/workfile', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5)     # Переход к шестому байту от начала
>>> f.read(1)
'5'
>>> f.seek(-3, 2) # Переход к третьему байту до конца файла
>>> f.read(1)
'd'

Метод close() закрывает объект файла, перенося все сделанные в нём изменения на диск, возвращая ресурсы операционной системе. Обязательно закрывайте все файлы, сто больше не используете, т.к. не закрытый файл может привести к потере данных. После закрытия обращение к объекту файла автоматически вызывает ошибку

Модуль pickle

Для чтения/записи в файл используются строки. То есть вам необходимо прежде чем записать что-либо в файл преобразовать это что-то в строку. С числовыми значениями всё легко: в модуле string есть множество функций для преобразования чисел в строки и строк в числа(например, строка в целое “string.atoi()”). Но как быть со сложными объектами: списками, например. Для этой цели в Питоне существует особый модуль: pickle, который может преобразовать в строку любой объект(даже некоторый формат кода самого Питона!) и записать его в файл. При этом при помощи модуля pickle можно выполнить обратную операцию из строки, генерированной pickle, в переменную(модуль сам распознает её тип). Причём, функционирование модуля pickle одинаково в любой реализации Питона, поэтому использование подобного механизма способствует переносимости кода и помогает повторно использовать какие-либо сложные объекты. Пример использования модуля pickle(полное описание я пока не перевёл):

pickle.dump(x, f)#Выгрузка содержимого x в файл f
x = pickle.load(f)#Загрузка x из файла f.

Назад | Содержание | Вперед