Работа с файлами

Оператор with

Заранее задать finally (например, закрыть открытый файл, даже если были исключения)
протокол контекстного менеджера
- .__enter__() / .__exit__(exc_type, exc_val, exc_tb)
```
   1 class CM:
   2     def __init__(self, val = None):
   3         self.val = val
   4 
   5     def __enter__(self):
   6         print(">>>")
   7 
   8     def __exit__(self, *args):
   9         print("<<<",*(c for c in args if c), sep="/", end=">>>\n")
  10         return self.val
  11 
  12 with CM(True) as f:
  13     print("Working")
  14     raise SyntaxError("шhат?")
  15     print("Not working")
  16 
  17 print("Done")
```
- →
```
Working
<<</<class 'SyntaxError'>/шhат?/<traceback object at 0x7f5fe5bac500>>>>
Done
```
- Если .__exit__() возвращает пустой объект (в примере можно передать конструктору False), исключения, возникшие при выходе из контекста, распространяются на уровень выше (в примере — не ловятся)

Далее см. contextlib.html

Байтовые структуры

Тип bytes — как str, только байты
- Ой, не совсем ☺:
```
   1 >>> a = b'weqrtwert'
   2 >>> a[4]
   3 116
   4 
```
- Часто прилетают пр работе с функциями из Си, сетевыми протоколами и др. данными, за которые Питон отвечать не хочет
- (в Python2 все такими было, кое-где может встретиться legacy)
Тип bytearray
- Изменяемый bytes
```
   1 >>> b = bytearray(range(65,72))
   2 >>> b
   3 bytearray(b'ABCDEFG')
   4 >>> b[3]
   5 68
   6 >>> b[2] ^= 0o40
   7 >>> b
   8 bytearray(b'ABcDEFG')
   9 
```

Bytearray нужен не очень часто:

это по сути список однобайтовых целых без одного лишнего уровня косвенности (хранятся сами целые, а не объекты Python)
есть либо NumPy, либо array

бНОПНЯ

Как преобразовать из str в bytes и обратно?

Понятие кодировки. Unicode, UTF* и прочее
- Кодировка: соответствие некоторого числа конкретному символу (например, описанному в Unicode)
- Тысячи их
- UTF-8: то ли один байт, то ли два (то ли три, то ли четыре)
- Однобайтные кодировки: без указания кодировки нельзя понять, что написано
```
   1 >>> txt = "Вопрос"
   2 >>> print(*map(hex, map(ord, txt)))
   3 0x412 0x43e 0x43f 0x440 0x43e 0x441
   4 >>> txt.encode()
   5 b'\xd0\x92\xd0\xbe\xd0\xbf\xd1\x80\xd0\xbe\xd1\x81'
   6 >>> locale.getdefaultlocale()
   7 ('ru_RU', 'UTF-8')
   8 >>> txt.encode('UTF-8')
   9 b'\xd0\x92\xd0\xbe\xd0\xbf\xd1\x80\xd0\xbe\xd1\x81'
  10 >>> txt.encode('WINDOWS-1251')
  11 b'\xc2\xee\xef\xf0\xee\xf1'
  12 >>> txt.encode('KOI8-R')
  13 b'\xf7\xcf\xd0\xd2\xcf\xd3'
  14 >>> txt.encode('WINDOWS-1251').decode('KOI8-R')
  15 'бНОПНЯ'
  16 
```
- Представление строк внутри Python: т. н. «питоний unicode» (двухбайтовый UTF-16)
  - Если в строке все символы из ASCII, она хранится побайтово, а если нет — в Unicode, но это абсолютно прозрачно, кроме размера:
    1 >>> sys.getsizeof("qwe") 2 52 3 >>> sys.getsizeof("qwer") 4 53 5 >>> sys.getsizeof("qwert") 6 54 7 >>> sys.getsizeof("qwertЫ") 8 86 9 >>> sys.getsizeof("qwertЫs") 10 88 11 >>> sys.getsizeof("qwertЫsя") 12 90 13
Список всех поддерживаемых кодировок

Не всякие кодировки полны:"Вопрос".encode("koi8-r").decode("latin3")

Устарела ли? Нет! бНОПНЯ живёт и процветает в Windows, например.

Просто файлы

В tutorial

open(), r/w/a и т. п.
.read()/.write()/.readline()
файл как итератор, .readlines()
.seek(),.tell()
текстовые и двоичные: "b"/"t"
- locale и getdefaultlocale()
- Непременное перекодирование текстовых файлов из локальной кодировки в Unicode и обратно.
- .seek() / .tell() не текстовых файлах
файл как контекстный менеджер, with, зачем нужно (автозакрытие, обработка возникших исключений)

Отдельная тема: файлы в операционной системе, sys.path, pathlib и т. д. — слишком много и не про язык, не будем туда ходить.

Но если видите sys.path — скорее всего пример устарел, сейчас модно pathlib (кроссплатформенно и более высокоуровнево)

Стандартный ввод-вывод

Как обычно, sys.stdin, sys.stdout и sys.stderr — это файлы стандартного ввода, вывода и вывода ошибок соответственно
К ним можно применять файловые операции (даже .seek(), но это только если соответствующий файл — это файл, а не терминал или конвейер (.seekable())
- Например, sys.stdout.write(что_то_там) сконвертирует в строку и запишет на стандартный вывод всё что_то_там (не добавляя перевод строки, разумеется)
Это текстовые файлы
Двоичные аналоги — sys.stdin.buffer, sys.stdout.buffer и sys.stderr.buffer
- Например, можно написать так: b = sys.stdin.buffer.readline(), при этом в b окажется объект типа bytes

Файловые объекты

Более высокий уровень абстракции — io (в действительности более низкий)

Поток
StringIO / BytesIO — память как файл, StringIO().getvalue()

Типизированные файлы

В просто файлы записываются только строки или байты. А если надо записать float, причём не в виде строки?

Сериализация

Чтение и запись объектов Python

pickle
- pickle.dumps(obj) / pickle.dump(obj, file)
- pickle.loads(bytes_object) / pickle.load(file)

Пример:

   1 >>> import pickle
   2 >>> pickle.dumps(0x14131211)
   3 b'\x80\x04\x95\x06\x00\x00\x00\x00\x00\x00\x00J\x11\x12\x13\x14.'
   4 >>> pickle.dumps(0x14131211)[-5:]
   5 b'\x11\x12\x13\x14.'
   6 >>> du = pickle.dumps(123.123e20)
   7 >>> du
   8 b'\x80\x04\x95\n\x00\x00\x00\x00\x00\x00\x00GD\x84\xdb\x9b\xe5\x05\x1cP.'
   9 >>> ud = pickle.loads(du)
  10 >>> ud
  11 1.23123e+22
  12 >>> F = open("serialized", "bw")
  13 >>> pickle.dump(100500, F)
  14 >>> pickle.dump([1, "WER", None], F)
  15 >>> pickle.dump(b"QWWER", F)
  16 >>> F.close()
  17 >>> F = open("serialized", "br")
  18 >>> pickle.load(F)
  19 100500
  20 >>> pickle.load(F)
  21 [1, 'WER', None]
  22 >>> pickle.load(F)
  23 b'QWWER'
  24

Сериализация экземпляра класса:

сериализация / десериализация основана на интроспекции экземпляра
⇒ поля класса и методы не сериализуются
⇒ при десериализации обычно не вызывается .__init__()
- вызывается .__new__() соответствующего класса
- восстанавливаетя .__dict__ и/или .__slots__

⇒ сам класс должен быть!

   1 >>> class C:
   2 ...     CField = 100500
   3 ...     def __init__(self, val):
   4 ...         print("Truly create")
   5 ...         self.val = val
   6 >>> c = C(123)
   7 Truly create
   8 >>> c.loc = "QWE"
   9 >>> s = pickle.dumps(c)
  10 >>> s
  11 b'\x80\x04\x95.\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x01C\x94\x93\x94)\x81\x94}\x94(\x8c\x03val\x94K{\x8c\x03loc\x94\x8c\x03QWE\x94ub.'
  12 >>> d = pickle.loads(s)
  13 >>> d.CField
  14 100500
  15 >>> C.CField=42
  16 >>> d.CField
  17 42
  18 >>> d.val
  19 123
  20 >>> d.loc
  21 'QWE'

Соответствие типов не проверяется (только имя). Если процедура десериализации не перегружена, подойдёт даже пустой класс:
```
   1 >>> class C: pass
   2 >>> e = pickle.loads(s)
   3 >>> e.val
   4 123
   5 >>> e.loc
   6 'QWE'
   7 >>> e.CField
   8 Traceback (most recent call last):
   9   File "<stdin>", line 1, in <module>
  10 AttributeError: 'C' object has no attribute 'CField'
  11 
  12 'C' object has no attribute 'CField'
```
небезопасно, т. к. потенциально можно исполнить произвольный код, напиханный злоумышленником

Структуры типа Си

Что мешает записать / считать представление объекта в памяти — это и будет в точности его контент?

Правильный ответ: всё можно, «но есть нюансы» ☺

struct

Format Characters
Остроконечники и тупоконечники (порядок байтов в слове), sys.byteorder
Выравнивание
Простой пример:
```
   1 >>> struct.pack("IhBi", 100500, 32100, 200, -6)
   2 b'\x94\x88\x01\x00d}\xc8\x00\xfa\xff\xff\xff'
   3 
```
- \x94\x88\x01\x00 → 100500
- d} → 32100 (0x7d64)
- \xc8 → это 200
- \x00 → выравнивание до чётного адреса (на некоторых архитектурах — до адреса, кратного размеру целого)
- \xfa\xff\xff\xff → -6

Пример: заголовок PNG (возможно, не успеем)

   1 import struct
   2 import zlib
   3 import sys
   4 
   5 HEADER = "8B"
   6 CHUNK = "!I4s"
   7 CRC = "!I"
   8 IHDR = "!IIBBBBB"
   9 
  10 def readpack(fmt, fle):
  11     return struct.unpack(fmt, fle.read(struct.calcsize(fmt)))
  12 
  13 payload = b''
  14 with open(sys.argv[1], "br") as f:
  15     png = readpack(HEADER, f)
  16     print(*map(hex, png))
  17     while (chunk := readpack(CHUNK, f))[1] != b"IEND":
  18         print(*chunk)
  19         data = f.read(chunk[0])
  20         crc = readpack(CRC, f)
  21         if chunk[1] == b"IHDR":
  22             w, h, bpp, col, comp, filt, i = struct.unpack(IHDR, data)
  23             print(f"{w}×{h}, {bpp=}, {col=}, {comp=}, {filt=}, {i=}")
  24         elif chunk[1] == b"IDAT":
  25             payload += data
  26 
  27 print(len(payload), w, h, w*h)
  28 payload = zlib.decompress(payload)
  29 print(len(payload), w, h, w*h)

Базы данных и dict-like итерфейс

dbm

Идея: интерфейс словаря (ключ:значение) + быстрый поиск под капотом

   1 >>> import dbm
   2 >>> F = dbm.open("data.db", "c")
   3 >>> F["qwe"] = "rty"
   4 >>> F["asd"] = "zxcv"
   5 >>> F["qerw"] = "werw"
   6 >>> F["123"] = "123"
   7 >>>
   8 >>> F["asd"]
   9 b'zxcv'
  10 >>> F[b"asd"]
  11 b'zxcv'
  12 >>> F["Ы"] = "Ы"
  13 >>> F["Ы"]
  14 b'\xd0\xab'
  15 >>> F.close()
  16 >>> F = dbm.open("data.db", "r")
  17 >>> F["qerw"]
  18 b'werw'
  19 >>> k = F.firstkey()
  20 >>> k
  21 b'\xd0\xab'
  22 >>> while k:
  23 ...     print(F[k])
  24 ...     k = F.nextkey(k)
  25 ...
  26 b'\xd0\xab'
  27 b'rty'
  28 b'zxcv'
  29 b'werw'
  30 b'123'
  31

Файлы с известной структурой

Тысячи их, часть поддерживают файловый протокол, часть — нет
Пример: gzip, tarfile
Пример: zipfile, zipapp
…

Д/З

Ввод для некоторых задач нельзя сделать с клавиатуры — там могут быть произвольные байты. Тем не менее, в программе можно воспользоваться sys.stdin.buffer, а тестировать так:

  … python3 программа.py < нетекстовый_файл

Собственно, задание:

Прощёлкать примеры с файлами в Tutorial, а также примеры по pickle и struct

EJudge: EasyBnopnya 'Небольшая бНОПНЯ'

Текст романа Л. Н. Толстого «Анна Каренина» (именно этот файл) был перекодирован в KOI8-R. Полученный файл несколько раз без ошибок перекодировали из одной случайно выбранной однобайтовой кодировки в другую, затем обрезали несколько начальных и конечных строк. Написать программу, которая восстанавливает текст фрагмента, если известно, что в нём встречается фамилия «Левин».

Список кодировок: KOI8-R, CP1251, CP866, MACCYRILLIC, ISO-8859-5, CP855 (это всё варианты кириллицы)
Заранее сгенерированные таблицы (кроме списка всех символов из книги, если это потребуется) в этой программе использовать нельзя
Приведён не настоящий пример, а его шестнадцатеричный дамп

Input:

00000000  20 20 20 20 20 2d 20 bd  c8 e1 20 c8 96 20 e4 9f  |     - ... .. ..|
00000010  20 20 e0 e4 9f 20 20 f2  e3 e5 e0 e1 96 e4 2c 20  |  ...  ......., |
00000020  20 c8 9f 20 20 93 e4 e1  20 20 c8 96 9f 90 91 96  | ..  ...  ......|
00000030  f6 96 83 96 c8 c8 9f f2  e4 e2 2c 20 20 c8 96 91  |..........,  ...|
00000040  96 e6 f4 e4 96 83 e2 c8  9f f2 e4 e2 0a 90 9f 83  |................|
00000050  9f 81 96 c8 f4 f1 2c 20  2d 20 f2 83 fc e6 e1 83  |......, - ......|
00000060  20 ba 96 9c f4 c8 20 20  f4 20 20 85 9f e4 96 83  | .....  .  .....|
00000070  20 20 90 9f f2 90 96 e6  c8 9f 20 20 9f e4 9f 94  |  ........  ....|
00000080  e4 f4 3b 20 20 c8 9f 20  20 cb e4 96 90 e1 c8 20  |..;  ..  ...... |
00000090  20 af 91 e3 e1 f6 e2 f4  e0 0a 90 9f f6 9f dc 9c  | ...............|
000000a0  e1 83 20 96 86 9f 2e 0a  20 20 20 20 20 2d 20 ba  |.. .....     - .|
000000b0  96 9c f4 c8 21 20 2d 20  f2 e3 e1 dc e1 83 20 cb  |....! - ...... .|
000000c0  e4 96 90 e1 c8 20 af 91  e3 e1 f6 e2 f4 e0 2c 20  |..... ........, |
000000d0  f4 20 20 ba 96 9c f4 c8  20 20 dc e1 c7 96 e4 f4  |.  .....  ......|
000000e0  83 2c 20 20 e0 e4 9f 20  20 e5 20 20 c8 96 86 9f  |.,  ...  .  ....|
000000f0  20 20 c8 e1 0a                                    |  ...|

Output:

     - Она не то  что  скучает,  но  эта  неопределенность,  нерешительность
положения, - слышал Левин  и  хотел  поспешно  отойти;  но  Степан  Аркадьич
подозвал его.
     - Левин! - сказал Степан Аркадьич, и  Левин  заметил,  что  у  него  на

EJudge: ZipInfo 'Размер архива'

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

Input:
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Output:

3 44

EJudge: GitParse 'Разбор Git-объекта'
Написать программу, которая читает со стандартного ввода двоичный файл и интерпретирует его как Git-объект (ещё одна ссылка). Для объектов разного типа должна выводиться следующая информация:
- pack: (Pack-file, обычно имеет расширение .pack): версия и количество объектов
- index: (Индекс версии 2, расширение .idx): размер (255 запись в fanout table)
- Объект из репозитория (который можно распаковать zlib)
  - blob: размер
  - tree: список файлов в дереве вида «идентификатор права имя» (в столбик)
  - tag: имя
  - commit: идентификатор
  - неизвестный объект репозитория: тип размер
- неизвестный файл: unknown:
Input:
```
(см. ссылку на архив в полном условии задачи)
```
Output:
```
commit: 74e95bdf495ee67e5ee21434043ce9b899c8317b
tree:
  f6035fb0029fd1a94cb18cabc23db44abfa61243 40000 Dir
  a29d440222a303eb8f9efb49af7e3dd56c0f5bf4 100644 файло
tree:
  2e42b9ea36935331674d4b58657187616cc099ce 100644 file
blob: 33
tag: top
commit: e668987a5e1ae2f38a7289e8260e0d3a437d5fcf
tree:
  a29d440222a303eb8f9efb49af7e3dd56c0f5bf4 100644 файло
blob: 11
unknown:
index: 4
unknown:
pack: 2 4
```

LecturesCMC/PythonIntro2023/11_Files (последним исправлял пользователь FrBrGeorge 2023-11-28 18:37:49)