python_pd/05_files/04_json.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": [
    "# Модуль ```json```\n",
    "\n",
    "Формат данных ```json``` был основан на нотации языка JavaScript для обмена данными."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "source": [
    "Модуль ```json``` поддерживает несколько функций для сериализации (кодирование) и десериализации (декодирование) данных. Сериализация или кодирование это преобразование Python объектов в строку. Для такой сериализации предусмотрена функция ```json.dumps```, которая принимает Python объект и возвращает строку. Аналогом этой функции выступает функция ```json.dump```. Она принимает объект и файл для записи этого объекта. Десериализация или декодирование это обратная сериализации операция. Она преобразует строку в Python объекты. Для десериализации модуль ```json``` предоставляет две функции ```json.loads``` и ```json.load``` аналогичных ```json.dumps``` и ```json.dump``` соответственно.\n",
    "\n",
    "Не все объекты Python могут быть сериализованы в ```json``` формат. Например, списки и кортежи сериализуются в виде массивов, а множества и комплексные числа не поддерживают сериализацию \"из коробки\". Некоторые объекты, такие как ```None```, сериализуются в аналогичные, приближенные к используемым в JavaScript. В таблице соотнесены Python типы и формат их сериализации.\n",
    "\n",
    "| Тип данных    | Объект после сериализации |\n",
    "|---------------|---------------------------|\n",
    "| ```int```     | ```int```                 |\n",
    "| ```float```   | ```float```               |\n",
    "| ```complex``` | Не поддерживается         |\n",
    "| ```list```    | Массив                    |\n",
    "| ```tuple```   | Массив                    |\n",
    "| ```dict```    | Объект                    |\n",
    "| ```set```     | Не поддерживается         |\n",
    "| ```True```    | ```true```                |\n",
    "| ```False```   | ```false```               |\n",
    "| ```None```    | ```null```                |"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Целое число в json: 42\nЧисло с плавающей точкой в json: 42.0\nСписок в json: [1, 2, 3]\nКортеж в json: [1, 2, 3]\nСловарь в json: {\"1\": \"a\", \"2\": \"b\"}\nTrue в json: true\nFalse в json: false\nNone в json: null\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3]\n",
    "t = tuple(l)\n",
    "d = {1: 'a', 2: 'b'}\n",
    "\n",
    "print(f'Целое число в json: {json.dumps(42)}')\n",
    "print(f'Число с плавающей точкой в json: {json.dumps(42.)}')\n",
    "print(f'Список в json: {json.dumps(l)}')\n",
    "print(f'Кортеж в json: {json.dumps(t)}')\n",
    "print(f'Словарь в json: {json.dumps(d)}')\n",
    "print(f'True в json: {json.dumps(True)}')\n",
    "print(f'False в json: {json.dumps(False)}')\n",
    "print(f'None в json: {json.dumps(None)}')"
   ]
  },
  {
   "source": [
    "При преобразовании некоторых объектов в ```json``` формат стоит помнить некоторые особенности. Например, ключи словарей в формате ```json``` всегда имеют строковый тип. Это приводит к тому, что любые Python объекты будут преобразованы в строку для записи в ```json```. Это повлияет и на обратный процесс - десериализацию."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Результат сериализации: {\"1\": \"a\", \"2.2\": \"b\", \"false\": [1, 2, 3], \"null\": true}\nРезультат десериализации: {'1': 'a', '2.2': 'b', 'false': [1, 2, 3], 'null': True}\n"
     ]
    }
   ],
   "source": [
    "d = {1: 'a', 2.2: 'b', False: [1, 2, 3], None: True}\n",
    "res = json.dumps(d)\n",
    "print(f'Результат сериализации: {res}')\n",
    "print(f'Результат десериализации: {json.loads(res)}')"
   ]
  },
  {
   "source": [
    "В связи с тем, что ```list``` и ```tuple``` неразличимы в формате ```json```, то при обратном преобразовании будет всегда получаться ```list```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Целое число из json: 1\nЧисло с плавающей точкой из json: 1.5\nСписок из json: [1, 2, 3]\nСловарь из json: {'1': 'a', '2': 'b'}\nTrue из json: True\nFalse из json: False\nNone из json: None\n"
     ]
    }
   ],
   "source": [
    "print(f'Целое число из json: {json.loads(\"1\")}')\n",
    "print(f'Число с плавающей точкой из json: {json.loads(\"1.5\")}')\n",
    "print(f'Список из json: {json.loads(\"[1, 2, 3]\")}')\n",
    "\n",
    "s = '{\"1\": \"a\", \"2\": \"b\"}'\n",
    "print(f'Словарь из json: {json.loads(s)}')\n",
    "print(f'True из json: {json.loads(\"true\")}')\n",
    "print(f'False из json: {json.loads(\"false\")}')\n",
    "print(f'None из json: {json.loads(\"null\")}')"
   ]
  },
  {
   "source": [
    "Для настройки сериализации функции ```json.dumps``` и ```json.dump``` принимают ряд необязательных аргументов, например:\n",
    "- ```ensure_ascii``` - экранирование не ascii символов, по умолчанию True (все не ascii символы будут преобразованы в байты);\n",
    "- ```indent``` - отсутп, по умолчанию сериализация происходит в строку;\n",
    "- ```check_circular``` - проверка циклических ссылок в контейнерах;\n",
    "- ```separators``` - разделители в массивах и словарях.\n",
    "- и другие."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "{\n    \"place_id\": 204078161,\n    \"osm_id\": 520248509,\n    \"boundingbox\": [\n        \"56.0035966\",\n        \"56.0049951\",\n        \"92.770395\",\n        \"92.7736184\"\n    ],\n    \"lat\": \"56.00429815\",\n    \"lon\": \"92.77089628097374\",\n    \"type\": \"university\",\n    \"importance\": 0.42099999999999993,\n    \"address\": {\n        \"house_number\": \"79\",\n        \"road\": \"Свободный проспект\",\n        \"suburb\": \"Октябрьский район\",\n        \"city_district\": \"Октябрьский район\",\n        \"city\": \"Красноярск\",\n        \"county\": \"городской округ Красноярск\",\n        \"state\": \"Красноярский край\",\n        \"region\": \"Сибирский федеральный округ\",\n        \"postcode\": \"660000\",\n        \"country\": \"Россия\",\n        \"country_code\": \"ru\"\n    }\n}\n"
     ]
    }
   ],
   "source": [
    "address = {\n",
    "    'place_id': 204078161, \n",
    "    'osm_id': 520248509, \n",
    "    'boundingbox': ['56.0035966', '56.0049951', '92.770395', '92.7736184'], \n",
    "    'lat': '56.00429815', \n",
    "    'lon': '92.77089628097374', \n",
    "    'type': 'university', \n",
    "    'importance': 0.42099999999999993, \n",
    "    'address': {\n",
    "        'house_number': '79', \n",
    "        'road': 'Свободный проспект', \n",
    "        'suburb': 'Октябрьский район', \n",
    "        'city_district': 'Октябрьский район', \n",
    "        'city': 'Красноярск', \n",
    "        'county': 'городской округ Красноярск', \n",
    "        'state': 'Красноярский край', \n",
    "        'region': 'Сибирский федеральный округ', \n",
    "        'postcode': '660000', \n",
    "        'country': 'Россия', \n",
    "        'country_code': 'ru'\n",
    "    }\n",
    "}\n",
    "res = json.dumps(address, ensure_ascii=False, indent=4)\n",
    "print(f'{res}')"
   ]
  },
  {
   "source": [
    "Для записи и чтения из файла используйте функции ```json.dump``` и ```json.load``` соответственно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('data.json', 'w') as f:\n",
    "    json.dump(address, f)"
   ]
  },
  {
   "source": [
    "Помимо всех вышеперечисленных базовых функций можно реализовать собственный сериализатор и десериализатор формата ```json```. Для этого модуль ```json``` предоставляет базовые класса ```json.JSONEncoder``` и ```json.JSONDecoder```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Официальный сайт json](https://www.json.org/json-ru.html)\n",
    "- [Документация к модулю ```json```](https://docs.python.org/3/library/json.html)\n",
    "- [Working With JSON Data in Python](https://realpython.com/python-json/)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}