Простой Python — страница 30 из 66

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

Существует множество форматов, которые можно различить по следующим особенностям.

• Разделитель, символ вроде табуляции ('\t'), запятой (',') или вертикальной черточки ('|'). Это пример формата со значениями, разделенными запятой, (CSV).

• Символы '<' и '>', окружающие теги. Примеры включают в себя XML и HTML.

• Знаки препинания. Примером является JavaScript Object Notation (JSON).

• Выделение пробелами. Примером является YAML (что в зависимости от источника может означать YAML Ain’t Markup Language — «Не язык разметки», вам придется исследовать его самостоятельно).

• Прочие файлы, например конфигурационные.

Каждый из этих форматов структурированных файлов может быть считан и записан с помощью как минимум одного модуля Python.

CSV

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

• Некоторые файлы имеют альтернативные разделители вместо запятой: самыми популярными являются '|' и '\t'.

• Некоторые файлы имеют управляющие последовательности. Если символ-разделитель встречается внутри поля, все поле может быть окружено символами кавычек или же перед ним будет находиться управляющая последовательность.

• Файлы имеют разные символы конца строк. В Unix используется '\n', в Microsoft — '\r \n', а Apple раньше применяла символ '\r', но теперь перешла на использование '\n'.

• В первой строке могут содержаться названия колонок.

Для начала взглянем, как читать и записывать список строк, каждая из которых содержит список колонок:

>>> import csv
>>> villains = [
…·····['Doctor', 'No'],
…·····['Rosa', 'Klebb'],
…·····['Mister', 'Big'],
…·····['Auric', 'Goldfinger'],
·····['Ernst', 'Blofeld'],
…·····]
>>> with open('villains', 'wt') as fout:··# менеджер контекста
…·····csvout = csv.writer(fout)
…·····csvout.writerows(villains)

Этот код создает пять записей:

Doctor,No
Rosa,Klebb
Mister,Big
Auric,Goldfinger
Ernst,Blofeld

Теперь попробуем считать их обратно:

>>> import csv
>>> with open('villains', 'rt') as fin:··# менеджер контекста
…·····cin = csv.reader(fin)
…·····villains = [row for row in cin]··# Здесь используется включение списка
…
>>> print(villains)
[['Doctor', 'No'], ['Rosa', 'Klebb'], ['Mister', 'Big'],
['Auric', 'Goldfinger'], ['Ernst', 'Blofeld']]

Подумайте немного о включениях списка (в любой момент вы можете обратиться к разделу «Включения» главы 4, чтобы вспомнить синтаксис). Мы воспользовались структурой, созданной функцией reader(). Она услужливо создала в объекте cin ряды, которые мы можем извлечь с помощью цикла for.

Используя функции reader() и writer() с их стандартными опциями, мы получим колонки, которые разделены запятыми, и ряды, разделенные символами перевода строки.

Данные могут иметь формат списка словарей, а не списка списков. Снова считаем файл villains, в этот раз используя новую функцию DictReader() и указывая имена колонок:

>>> import csv
>>> with open('villains', 'rt') as fin:
…·····cin = csv.DictReader(fin, fieldnames=['first', 'last'])
…·····villains = [row for row in cin]
…
>>> print(villains)
[{'last': 'No', 'first': 'Doctor'},
{'last': 'Klebb', 'first': 'Rosa'},
{'last': 'Big', 'first': 'Mister'},
{'last': 'Goldfinger', 'first': 'Auric'},
{'last': 'Blofeld', 'first': 'Ernst'}]

Перепишем CSV-файл с помощью новой функции DictWriter(). Мы также вызовем функцию writeheader(), чтобы записать начальную строку, содержащую имена колонок, в CSV-файл:

import csv
villains = [
····{'first': 'Doctor', 'last': 'No'},
····{'first': 'Rosa', 'last': 'Klebb'},
····{'first': 'Mister', 'last': 'Big'},
····{'first': 'Auric', 'last': 'Goldfinger'},
····{'first': 'Ernst', 'last': 'Blofeld'},
····]
with open('villains', 'wt') as fout:
····cout = csv.DictWriter(fout, ['first', 'last'])
····cout.writeheader()
····cout.writerows(villains)

Этот код создает файл villains со строкой заголовка:

first,last
Doctor,No
Rosa,Klebb
Mister,Big
Auric,Goldfinger
Ernst,Blofeld

Теперь считаем его обратно. Опуская аргумент fieldnames в вызове DictReader(), мы указываем функции использовать значения первой строки файла (first, last) как имена колонок и соответствующие ключи словаря:

>>> import csv
>>> with open('villains', 'rt') as fin:
…·····cin = csv.DictReader(fin)
…·····villains = [row for row in cin]
…
>>> print(villains)
[{'last': 'No', 'first': 'Doctor'},
{'last': 'Klebb', 'first': 'Rosa'},
{'last': 'Big', 'first': 'Mister'},
{'last': 'Goldfinger', 'first': 'Auric'},
{'last': 'Blofeld', 'first': 'Ernst'}]

XML

Файлы с разделителями охватывают только два измерения: ряды (строки) и колонки (поля внутри строк). Если вы хотите обмениваться структурами данных между программами, вам нужен способ кодировать иерархии, последовательности, множества и другие структуры с помощью текста.

XML является самым известным форматом разметки, который можно применять в этом случае. Для разделения данных он использует теги, как показано в следующем примере (файл menu.xml):

··
····breakfast burritos
····pancakes
··
··
····hamburger
··
··
····spaghetti
··

Рассмотрим основные характеристики формата XML.

• Теги начинаются с символа <. В этом примере использованы теги menu, breakfast, lunch, dinner и item.

• Пробелы игнорируются.

• Обычно после начального тега вроде

следует остальной контент, а затем соответствующий конечный тег вроде .

• Теги могут быть вложены в другие теги на любой глубине. В этом примере теги item являются потомками тегов breakfast, lunch и dinner, которые, в свою очередь, являются потомками тега menu.

• Внутри стартового тега могут встретиться опциональные атрибуты. В этом примере price является опциональным атрибутом тега item.

• Теги могут содержать значения. В этом примере каждый тег item имеет значение вроде pancakes у второго элемента тега breakfast.

• Если у тега с именем thing нет значений или потомков, он может быть оформлен как единственный тег путем включения прямого слеша прямо перед закрывающей угловой скобкой (), вместо того чтобы использовать начальный и конечный теги и .

• Место размещения данных — атрибуты, значения или теги-потомки — является в какой-то мере произвольным. Например, мы могли бы написать последний тег item как .

XML часто используется в каналах данных и сообщениях и имеет подформаты вроде RSS и Atom. В некоторых отраслях, например в области бизнеса, имеются специализированные форматы XML (http://bit.ly/xml-finance).

Сверхгибкость формата XML вдохновила многих людей на создание библиотек для Python, каждая из которых отличается от других подходом и возможностями.

Самый простой способ проанализировать XML в Python — использовать библиотеку ElementTree. Рассмотрим небольшую программу, которая анализирует файл menu.xml и выводит на экран некоторые теги и атрибуты:

>>> import xml.etree.ElementTree as et
>>> tree = et.ElementTree(file='menu.xml')
>>> root = tree.getroot()
>>> root.tag
'menu'
>>> for child in root:
…·····print('tag:', child.tag, 'attributes:', child.attrib)
·····for grandchild in child:
…·········print('\ttag:', grandchild.tag, 'attributes:', grandchild.attrib)
…
tag: breakfast attributes: {'hours': '7-11'}
····tag: item attributes: {'price': '$6.00'}
····tag: item attributes: {'price': '$4.00'}
tag: lunch attributes: {'hours': '11-3'}
····tag: item attributes: {'price': '$5.00'}
tag: dinner attributes: {'hours': '3-10'}
····tag: item attributes: {'price': '8.00'}
>>> len(root)·····# количество разделов menu
3
>>> len(root[0])··# количество элементов breakfast
2

Для каждого элемента вложенных списков tag — это строка тега, а attrib — это словарь его атрибутов. Библиотека ElementTree имеет множество других способов поиска данных, организованных в формате XML, модификации этих данных и даже записи XML-файлов. Все детали изложены в документации библиотеки ElementTree (http://bit.ly/elementtree).

Среди других библиотек для работы с XML в Python можно отметить следующие:

• xml.dom. The Document Object Model (DOM), знакомая разработчикам на JavaScript, представляет веб-документы как иерархические структуры. Этот модуль загружает XML-файл в память целиком и позволяет вам получать доступ ко всем его частям;

• xml.sax. Simple API for XML, или SAX, разбирает XML на ходу, поэтому он не загружает в память сразу весь документ. Он может стать хорошим выбором, если вам нужно обработать очень большие потоки XML.

HTML

Огромные объемы данных сохраняются в формате гипертекстового языка разметки (Hypertext Markup Language, HTML), это основной формат документов в сети Интернет. Проблема заключается в том, что значительная часть этих документов не соответствует правилам формата HTML, поэтому его трудно разобрать. Помимо этого, большая часть HTML предназначена для того, чтобы форматировать выводимую информацию, а не обмениваться данными. Поскольку эта глава предназначена для того, чтобы описать относительно хорошо определенные форматы данных, я вынес рассмотрение HTML в главу 9.

JSON

JavaScript Object Notation (JSON) (http://www.json.org/) стал очень популярным форматом обмена данными, вышедшим за пределы языка JavaScript. Формат JSON является частью языка JavaScript и часто содержит легальный с точки зрения Python синтаксис. Он хорошо подходит Python, что делает его хорошим выбором при определении формата данных для обмена между программами. Вы увидите множество примеров использования JSON при веб-разработке в главе 9.

В отличие от XML, для которого написано множество модулей, для JSON существует всего один модуль с простым именем json. Эта программа кодирует (выгружает) данные в строку JSON и декодирует (загружает) строку JSON обратно. В следующем примере мы создадим структуру данных, содержащую данные из предыдущего примера, где описывался формат XML:

>>> menu = \
… {
… "breakfast": {
…·········"hours": "7-11",
…·········"items": {
…·················"breakfast burritos": "$6.00",
…·················"pancakes": "$4.00"
…·················}
…·········},
… "lunch": {
…·········"hours": "11-3",
…·········"items": {
…·················"hamburger": "$5.00"
…·················}
…·········},
… "dinner": {
…·········"hours": "3-10",
…·········"items": {
…·················"spaghetti": "$8.00"
…·················}
…·········}
… }
.

Далее закодируем структуру данных (menu) в строку JSON (menu_json) с помощью функции dumps():

>>> import json
>>> menu_json = json.dumps(menu)
>>> menu_json
'{"dinner": {"items": {"spaghetti": "$8.00"}, "hours": "3-10"},
"lunch": {"items": {"hamburger": "$5.00"}, "hours": "11-3"},
"breakfast": {"items": {"breakfast burritos": "$6.00", "pancakes":
"$4.00"}, "hours": "7-11"}}'

А теперь превратим строку JSON menu_json обратно в структуру данных (menu2) с помощью функции loads():

>>> menu2 = json.loads(menu_json)
>>> menu2
{'breakfast': {'items': {'breakfast burritos': '$6.00', 'pancakes':
'$4.00'}, 'hours': '7-11'}, 'lunch': {'items': {'hamburger': '$5.00'},
'hours': '11-3'}, 'dinner': {'items': {'spaghetti': '$8.00'}, 'hours': '3-10'}}

menu и menu2 являются словарями с одинаковыми ключами и значениями. Как всегда, в случае обычных словарей порядок, в котором вы получаете ключи, различается.

Вы можете получить исключение, пытаясь закодировать или декодировать некоторые объекты, включая такие объекты, как datetime (этот вопрос детально рассматривается в разделе «Календари и часы» главы 10), как показано здесь:

>>> import datetime
>>> now = datetime.datetime.utcnow()
>>> now
datetime.datetime(2013, 2, 22, 3, 49, 27, 483336)
>>> json.dumps(now)
Traceback (most recent call last):
#… (deleted stack trace to save trees)
TypeError: datetime.datetime(2013, 2, 22, 3, 49, 27, 483336) is not JSON serializable
>>>

Это может случиться, поскольку стандарт JSON не определяет типы даты или времени — он ожидает, что вы укажете ему, как с ними работать. Вы можете преобразовать формат datetime во что-то, что JSON понимает, вроде строки или значения времени epoch (его мы рассмотрим в главе 10):

>>> now_str = str(now)
>>> json.dumps(now_str)
'"2013-02-22 03:49:27.483336"'
>>> from time import mktime
>>> now_epoch = int(mktime(now.timetuple()))
>>> json.dumps(now_epoch)
'1361526567'

Если значение datetime встретится между нормальными сконвертированными типами данных, может быть неприятно выполнять такие особые преобразования. Вы можете изменить то, как JSON будет закодирован, с помощью наследования, что описано в разделе «Наследование» главы 6. Документация JSON для Python содержит пример такого переопределения для комплексных чисел, что также заставляет JSON притвориться мертвым. Напишем переопределение для datetime:

>>> class DTEncoder(json.JSONEncoder):
…·····def default(self, obj):
…·········# isinstance() checks the type of obj
…·········if isinstance(obj, datetime.datetime):
…·············return int(mktime(obj.timetuple()))
…·········# else it's something the normal decoder knows:
…·········return json.JSONEncoder.default(self, obj)
…
>>> json.dumps(now, cls=DTEncoder)
'1361526567'

Новый класс DTEncoder является подклассом, или классом-потомком, класса JSONEncoder. Нам нужно лишь переопределить его метод default(), добавив обработку datetime. Наследование гарантирует, что все остальное будет обработано родительским классом.

Функция isinstance() проверяет, является ли объект obj объектом класса datetime.datetime. Поскольку в Python все является объектом, функция isinstance() работает везде:

>>> type(now)
>>> isinstance(now, datetime.datetime)
True
>>> type(234)
>>> isinstance(234, int)
True
>>> type('hey')
>>> isinstance('hey', str)
True

Для JSON и других структурированных текстовых форматов вы можете загрузить файл в память и разместить его в структуре данных, не зная о самих структурах заранее. Далее вы можете с помощью функции isinstance() пройти по структурам и соответствующим типам методам, чтобы проверить их значения. Например, если один из элементов является словарем, вы можете извлечь его содержимое с помощью функций keys(), values() и items().

YAML

Как и JSON, YAML (http://www.yaml.org/) имеет ключи и значения, но обрабатывает большее количество типов данных, включая дату и время. Стандартная библиотека Python не содержит модулей, работающих с YAML, поэтому вам нужно установить стороннюю библиотеку yaml (http://pyyaml.org/wiki/PyYAML). Функция load() преобразует строку в формате YAML к данным Python, а функция dump() предназначена для противоположного действия.

Следующий YAML-файл, mcintyre.yaml, содержит информацию о канадском поэте Джеймсе Макинтайре (James McIntyre), в том числе два его стихотворения:

name:
··first: James
··last: McIntyre
dates:
··birth: 1828-05-25
··death: 1906-03-31
details:
··bearded: true
··themes: [cheese, Canada]
books:
··url: http://www.gutenberg.org/files/36068/36068-h/36068-h.htm
poems:
··— title: 'Motto'
····text: |
······Politeness, perseverance and pluck,
······To their possessor will bring good luck.
··— title: 'Canadian Charms'
····text: |
······Here industry is not in vain,
······For we have bounteous crops of grain,
······And you behold on every field
······Of grass and roots abundant yield,
······But after all the greatest charm
······Is the snug home upon the farm,
······And stone walls now keep cattle warm.

Значения вроде true, false, on и off преобразуются в булевы переменные. Целые числа и строки преобразуются в их эквиваленты в Python. Для прочего синтаксиса создаются списки и словари:

>>> import yaml
>>> with open('mcintyre.yaml', 'rt') as fin:
>>>·····text = fin.read()
>>> data = yaml.load(text)
>>> data['details']
{'themes': ['cheese', 'Canada'], 'bearded': True}
>>> len(data['poems'])
2

Создаваемые структуры данных совпадают со структурами YAML-файла, которые в данном случае имеют глубину более одного уровня. Вы можете получить заголовок второго стихотворения с помощью следующей ссылки:

>>> data['poems'][1]['title']
'Canadian Charms'

PyYAML может загружать объекты Python из строк, и это опасно. Используйте метод safe_load() вместо метода load(), если импортируете данные в формате YAML, которым не доверяете. А лучше всегда используйте метод safe_load(). Прочтите статью War is peace (http://nedbatchelder.com/blog/201302/war_is_peace.html), чтобы узнать о том, как незащищенная загрузка YAML скомпрометировала платформу Ruby on Rails.

Безопасность

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

Например, в следующем фрагменте XML-файла, состоящем из миллиарда усмешек, страница «Википедии» определяет десять вложенных сущностей, каждая из которых распространяется на более низкий уровень десять раз, порождая в сумме один миллиард сущностей:

]>
&lol9;

Плохая новость: миллиард усмешек подорвет работоспособность всех XML-библиотек, упомянутых в предыдущем разделе. На ресурсе Defused XML (https://bitbucket.org/tiran/defusedxml) эта и другие атаки перечислены наряду с уязвимостями библиотек Python. Перейдя по этой ссылке, вы увидите, как изменять настройки многих библиотек так, чтобы избежать этих проблем. Вы также можете использовать библиотеку defusedxml как внешний интерфейс безопасности для других библиотек:

>>> # insecure:
>>> from xml.etree.ElementTree import parse
>>> et = parse(xmlfile)
>>> # protected:
>>> from defusedxml.ElementTree import parse
>>> et = parse(xmlfile)

Конфигурационные файлы

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

Здесь мы используем стандартный модуль configparser, который обрабатывает файлы с расширением. ini, характерные для Windows. Такие файлы имеют разделы, содержащие определения ключ = значение. Так выглядит минимальный файл settings.cfg:

[english]
greeting = Hello
[french]
greeting = Bonjour
[files]
home = /usr/local
# simple interpolation:
bin = %(home)s/bin

А так выглядит код, который позволяет считать его и разместить в структурах данных:

>>> import configparser
>>> cfg = configparser.ConfigParser()
>>> cfg.read('settings.cfg')
['settings.cfg']
>>> cfg
>>> cfg['french']
>>> cfg['french']['greeting']
'Bonjour'
>>> cfg['files']['bin']
'/usr/local/bin'

Доступны и другие опции, включая более мощную интерполяцию. Обратитесь к документации configparser (http://bit.ly/configparser). Если вам нужно более двух уровней вложенности, попробуйте использовать YAML или JSON.

Другие форматы обмена данными

Такие бинарные форматы обмена данными, как MsgPack (http://msgpack.org/), Protocol Buffers (https://code.google.com/p/protobuf/), Avro (http://avro.apache.org/docs/current/), Thrift (http://thrift.apache.org/), обычно компактнее и быстрее, чем XML или JSON. Поскольку они бинарные, ни один из них не может быть изменен человеком, вооружившимся текстовым редактором.

Сериализация с помощью pickle

Сохранение структур данных в файл называется сериализацией. Форматы вроде JSON могут требовать наличия пользовательских преобразователей для сериализации всех типов данных программы, написанной на Python. Python предоставляет модуль pickle, позволяющий сохранить и восстановить любой объект в специальном бинарном формате.

Помните, как JSON сошел с ума, когда встретил объект datetime? Для pickle это не проблема:

>>> import pickle
>>> import datetime
>>> now1 = datetime.datetime.utcnow()
>>> pickled = pickle.dumps(now1)
>>> now2 = pickle.loads(pickled)
>>> now1
datetime.datetime(2014, 6, 22, 23, 24, 19, 195722)
>>> now2
datetime.datetime(2014, 6, 22, 23, 24, 19, 195722)

pickle работает также с вашими собственными классами и объектами. Мы определим небольшой класс, который называется Tiny и возвращает слово 'tiny', когда он используется как строка:

>>> import pickle
>>> class Tiny():
…·····def __str__(self):
…········return 'tiny'
…
>>> obj1 = Tiny()
>>> obj1
<__main__.Tiny object at 0x10076ed10>
>>> str(obj1)
'tiny'
>>> pickled = pickle.dumps(obj1)
>>> pickled
b'\x80\x03c__main__\nTiny\nq\x00)\x81q\x01.'
>>> obj2 = pickle.loads(pickled)
>>> obj2
<__main__.Tiny object at 0x10076e550>
>>> str(obj2)
'tiny'

pickled — это обработанная pickle бинарная строка, созданная из объекта obj1. Мы преобразовали ее в объект obj2, чтобы сделать копию объекта obj1. Используйте функцию dump(), чтобы pickle сохранил данные в файл, и функцию load(), чтобы pickle загрузил данные из файла.

Поскольку pickle может создавать объекты Python, к нему применимы предупреждения о безопасности, которые были рассмотрены ранее. Не загружайте в pickle данные, которым не доверяете.

Структурированные бинарные файлы