python_pd/05_files/06_pickle.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Модуль ```pickle```\n",
    "\n",
    "Модуль ```pickle``` реализует двоичные протоколы для сериализации и десериализации Python объектов. «Маринование» - это процесс, посредством которого Python объекты преобразуется в поток байтов, а «размаринование» - это обратная операция, посредством которой поток байтов (из двоичного файла или байтового объекта) преобразуется обратно в объекты.\n",
    "\n",
    "Протокол, используемый в ```pickle```, не просто записывает байты в файл или строку, он записывает дополнительную метаинформацию о типе объекта. Без этого будет невозможна десериализация этого байтового представления."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle"
   ]
  },
  {
   "source": [
    "Интерфейс, предоставляемый модулем ```pickle```, схож с интерфейсом модуля ```json```. Вот краткое описание:\n",
    "- ```dump(obj, file)``` - функция сериализации объекта ```obj``` в бинарный файл ```file```; \n",
    "- ```dumps(obj)``` - функция сериализации объекта ```obj``` в бинарную строку;\n",
    "- ```load(file)``` - функция десериализации объекта из бинарного файла ```file```;\n",
    "- ```loads(data)``` - функция десериализации объекта из бинарной строки ```data```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# подготовим данные для сериализации\n",
    "d_1 = 'бнопня'\n",
    "d_2 = 196.\n",
    "d_3 = {\n",
    "    'foo': [1, 2, 3],\n",
    "    'bar': ('a', 'b', 'c'),\n",
    "    'baz': {True, False, None},\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "type(serialized_str) = <class 'bytes'>\n<class 'str'> -> b'\\x80\\x04\\x95\\x10\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\x0c\\xd0\\xb1\\xd0\\xbd\\xd0\\xbe\\xd0\\xbf\\xd0\\xbd\\xd1\\x8f\\x94.'\n<class 'float'> -> b'\\x80\\x04\\x95\\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00G@h\\x80\\x00\\x00\\x00\\x00\\x00.'\n<class 'dict'> -> b'\\x80\\x04\\x956\\x00\\x00\\x00\\x00\\x00\\x00\\x00}\\x94(\\x8c\\x03foo\\x94]\\x94(K\\x01K\\x02K\\x03e\\x8c\\x03bar\\x94\\x8c\\x01a\\x94\\x8c\\x01b\\x94\\x8c\\x01c\\x94\\x87\\x94\\x8c\\x03baz\\x94\\x8f\\x94(\\x89\\x88N\\x90u.'\n"
     ]
    }
   ],
   "source": [
    "# сериализация\n",
    "serialized_str = pickle.dumps(d_1)\n",
    "serialized_float = pickle.dumps(d_2)\n",
    "serialized_dict = pickle.dumps(d_3)\n",
    "\n",
    "print(f'{type(serialized_str) = }')\n",
    "\n",
    "print(f'{type(d_1)} -> {serialized_str}')\n",
    "print(f'{type(d_2)} -> {serialized_float}')\n",
    "print(f'{type(d_3)} -> {serialized_dict}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Десериализация строки: бнопня\nДесериализация числа: 196.0\nДесериализация словаря: {'foo': [1, 2, 3], 'bar': ('a', 'b', 'c'), 'baz': {False, True, None}}\n"
     ]
    }
   ],
   "source": [
    "# десериализация\n",
    "\n",
    "print(f'Десериализация строки: {pickle.loads(serialized_str)}')\n",
    "print(f'Десериализация числа: {pickle.loads(serialized_float)}')\n",
    "print(f'Десериализация словаря: {pickle.loads(serialized_dict)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# не самый красивый способ создать функцию с двумя параметрами\n",
    "def constructor_with_two_args(name, k):\n",
    "    # болванка\n",
    "    def bar(a, b):\n",
    "        pass\n",
    "    # копирование всех нужных атрибутов\n",
    "    bar.__name__ = name\n",
    "    for attr_name, v in k.items():\n",
    "        setattr(bar, attr_name, v)\n",
    "    # возврат новой/старой функции\n",
    "    return bar\n",
    "\n",
    "class MyPickler(pickle.Pickler):\n",
    "    def reducer_override(self, obj):\n",
    "        if getattr(obj, \"__name__\", None) == \"foo\":\n",
    "            return constructor_with_two_args, (obj.__name__, \n",
    "                                               {'__doc__': obj.__doc__, '__code__': obj.__code__})\n",
    "        else:\n",
    "            return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "baz = <function constructor_with_two_args.<locals>.bar at 0x0000016EE1F035E0>\na + b = 3\n"
     ]
    }
   ],
   "source": [
    "import io\n",
    "\n",
    "def foo(a, b):\n",
    "    \"\"\"Функция-подопытный\"\"\"\n",
    "    print(f'{a + b = }')\n",
    "\n",
    "# будем писать в байтовый поток\n",
    "f = io.BytesIO()\n",
    "# создаем собственный сериализатор/десериализатор\n",
    "pickler = MyPickler(f)\n",
    "\n",
    "# дампим функцию в бинарный поток\n",
    "pickler.dump(foo)\n",
    "\n",
    "# для чистоты эксперимента удалим функцию\n",
    "del foo\n",
    "\n",
    "# размаринуем функцию\n",
    "baz = pickle.loads(f.getvalue())\n",
    "\n",
    "print(f'{baz = }')\n",
    "\n",
    "baz(1, 2)  # Алоха!"
   ]
  },
  {
   "source": [
    "# Сравнение ```pickle``` и других протоколов сериализации и десериализации\n",
    "\n",
    "Для понимания отличий маринования от прочих протоколов рассмотрим небольшое сравнение (выдержка из документации).\n",
    "\n",
    "## ```pickle``` vs ```marshal```\n",
    "\n",
    "В Python реализован еще один модуль для двоичной сериализации и десериализации ```marshal```. Это более низкоуровневый протоко по сравнению с ```pickle```. Его использование не рекомендуется, а предназначение заключается в поддержке файлов ```.pyc```.\n",
    "\n",
    "- Модуль ```pickle``` позволяет отслеживать уже сериализованные объекты. Это позволяет легко работать с объектами содержащими рекурсивные ссылки. Модуль ```marshal``` этого не умеет и при попытке сериализовать объект с циклическими ссылками есть высокая вероятность сломать интерпретатор.\n",
    "- Модуль ```pickle``` умеет работать с пользовательскими типами данных (классами), при условии, что его объявление находится в той же области видимости. ```marshal``` не имеет такой функциональности. \n",
    "- В связи с тем, что ```marshal``` предназначен сугубо для внутреннего использования, переносимость между разными версиями интерпретатора не гарантируется.\n",
    "\n",
    "## ```pickle``` vs ```json```\n",
    "\n",
    "- ```json``` - это **текстовый** формат, а ```pickle``` - это двоичный формат;\n",
    "- ```json``` удобочитаем, а ```pickle``` - нет; \n",
    "- ```json``` совместим и широко используется вне экосистемы Python, в то время как ```pickle``` специфичен для Python; \n",
    "- ```json``` по умолчанию может представлять только ограниченное количество **встроенных** типов Python и не может сериализовать пользовательские классы;\n",
    "- ```pickle``` может обрабатывать чрезвычайно большое количество типов Python (многие из них автоматически, благодаря умному использованию средств самоанализа Python; поддержка сложных типов может быть добавлена путем реализации конкретного API);\n",
    "- в отличие от ```pickle```, десериализация ненадежного ```json``` сама по себе не создает уязвимости выполнения произвольного кода."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "Дополнительно стандартная библиотека Python содержит модуль ```shelve```, который использует ```pickle``` для реализации простейшей DBM-подобной базы данных. Структура такой базы данных представлена в Python как объект типа ```dict```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Документация по модулю ```pickle```](https://docs.python.org/3/library/pickle.html)\n",
    "- [Документация по модулю ```shelve```](https://docs.python.org/3/library/shelve.html#module-shelve)\n",
    "- [Пример динамического создания функции в Python](https://gist.github.com/dhagrow/d3414e3c6ae25dfa606238355aea2ca5)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}