Как анализировать JSON с помощью Python как профессионал

Эй друг! JSON сегодня повсюду. Независимо от того, создаете ли вы веб-сервисы, собираете данные или взаимодействуете с API, вполне вероятно, что в какой-то момент вам придется анализировать JSON в Python.

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

Обновление формата JSON

Давайте начнем с быстрого ознакомления с синтаксисом и структурой JSON.

JSON означает нотацию объектов JavaScript. Он стал универсальным стандартом для сериализации и передачи данных через Интернет.

По Statista, более 70% разработчиков регулярно работают с API JSON.

JSON представляет данные в виде пар ключ/значение:

{
  "name": "John",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "San Francisco" 
  }
}

Он состоит из:

• Объекты – Неупорядоченные коллекции пар ключ/значение, обозначаемые { }
• Массивы – Упорядоченные коллекции, обозначаемые [ ]
• Основные - Всегда строка
• Значение – Может быть строкой, числом, логическим значением, нулем, объектом или массивом.

Этот простой синтаксис упрощает чтение и анализ JSON как для людей, так и для машин.

Теперь давайте углубимся в методы анализа JSON в Python!

Анализ строк JSON

Самая распространенная задача синтаксического анализа JSON — взять необработанную строку JSON и преобразовать ее в словарь Python.

встроенный в Python json модуль предоставляет простые методы для решения этой проблемы:

json.loads () – Анализирует строку JSON, возвращая объект Python

import json

json_str = ‘{"name": "John", "age": 30}‘
data = json.loads(json_str)

print(data[‘name‘]) # John

json.dumps () – Сериализует объект Python в строку JSON.

data = {
  ‘name‘: ‘John‘,
  ‘age‘: 30
}

json_str = json.dumps(data) 

print(json_str) 
# {"name": "John", "age": 30}

Ассоциация json.loads() метод анализирует JSON и преобразует его в собственные структуры данных Python. Он позволяет легко выполнять сериализацию из строки в dict, list, str, int и т. д.

Однако это вызовет json.decoder.JSONDecodeError если JSON недействителен. Поэтому обязательно оберните его в try/Exception.

Ассоциация json.dumps() метод делает обратное, кодируя объекты Python как строки JSON. Это полезно для вывода данных или их передачи в другие системы.

Чтение и анализ файлов JSON

Помимо строк, мы можем использовать json модуль для загрузки и анализа файлов JSON.

Этот файл JSON data.json содержит данные о сотрудниках:

{
  "employees": [
    { "name": "John", "email": "[email protected]"},
    { "name": "Jane", "email": "[email protected]"}
  ]
}

Чтобы загрузить и проанализировать его в Python:

import json

with open(‘data.json‘) as f:
  data = json.load(f)

for employee in data[‘employees‘]:
  print(employee[‘name‘]) 
# John 
# Jane

Открываем файл, передаем его json.load()и верните объект Python, содержащий проанализированный JSON.

В данном случае это словарь с employees ключ, содержащий список объектов сотрудников.

Ключевым моментом является json.load() обрабатывал чтение файла, анализировал JSON и предоставлял нам собственные объекты Python, с которыми мы могли немедленно работать!

Красивая печать JSON

Вот удобный трюк для отладки: форматирование JSON в читаемом виде с помощью Python. json.dumps() метод.

Пройти indent параметр для его форматирования с использованием символов новой строки и пробелов:

data = {
  ‘name‘: ‘John‘,
  ‘age‘: 30,
  ‘address‘: {
    ‘street‘: ‘123 Main St‘,
    ‘city‘: ‘San Francisco‘
  }
}

print(json.dumps(data, indent=4))

Вывод:

{
    "name": "John",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "San Francisco"
    }
}

Ассоциация indent контролирует количество пробелов. Это распечатывает его с хорошим форматированием, поэтому его легче визуально анализировать.

Настоятельно рекомендую использовать json.dumps(indent=4) всякий раз, когда вы печатаете JSON в терминале для лучшей видимости.

Анализ вложенных объектов JSON

Реальный JSON часто имеет вложенные объекты и массивы. В Python с этим может быть сложно разобраться.

К счастью, pandas предоставляет замечательную утилиту под названием json_normalize() который сводит вложенный JSON в плоскую таблицу:

from pandas.io.json import json_normalize

data = {
  "cars": [
    {"make": "Ford", "models": ["Fiesta", "Focus", "Mustang"]},
    {"make": "BMW", "models": ["320", "X3", "X5"]},
    {"make": "Fiat", "models": ["500", "Panda"]}
  ]
}

df = json_normalize(data, ‘cars‘, [‘make‘, ‘models‘])

print(df)

Вывод:

Он объединяет вложенный массив «автомобили» в строки, сохраняя при этом столбцы марок и моделей.

Это очень ценно, когда вам нужно проанализировать вложенные данные JSON в пандах!

Преобразование JSON в CSV

Для анализа в Excel, Tableau или других инструментах вы можете экспортировать JSON в формат CSV.

Нет проблем, панды DataFrame.to_csv() метод делает это проще простого:

df = json_normalize(data) 

df.to_csv(‘data.csv‘, index=False)

Мимоходом index=False столбец индекса панд будет пропущен.

Вы также можете добавить данные JSON в существующий CSV:

df.to_csv(‘data.csv‘, mode=‘a‘, header=False, index=False)

Это обеспечивает простой способ извлечения JSON -> CSV для дальнейшего использования.

Обработка дубликатов

В отличие от словарей Python, JSON технически допускает дублирование ключей, например:

{
  "name": "John",
  "age": 30,
  "name": "Jane"
}

Это вызовет TypeError in json.loads() поскольку для диктов Python требуются уникальные ключи.

Для обработки дубликатов передайте object_pairs_hook Параметр:

from collections import defaultdict

def handle_dups(pairs):
  d = defaultdict(list)
  for k, v in pairs:
    d[k].append(v)

  return dict(d)

data = json.loads(json_str, object_pairs_hook=handle_dups) 

При этом значения из повторяющихся ключей собираются в списки:

{
  "name": ["John","Jane"],
  "age": 30
} 

Альтернативой является разрешение более поздним дубликатам переопределять более ранние:

def handle_dups(d):
  return {k: v for k, v in d.items()}

data = json.loads(json_str, object_hook=handle_dups)

So object_pairs_hook дает вам возможность обрабатывать объекты JSON с повторяющимися ключами.

Анализ дат JSON

Работа с датами — дело хлопотное. JSON представляет даты в виде строк:

{
  "date": "2019-01-01" 
}

По умолчанию json.loads() разберу это в str.

Мы можем использовать object_hook для автоматического преобразования дат:

from datetime import datetime

def parse_dates(data):
  for k, v in data.items():
    if isinstance(v, str):
        try:
            data[k] = datetime.strptime(v, "%Y-%m-%d") 
        except ValueError:
            pass

  return data

data = json.loads(json_str, object_hook=parse_dates)
print(data[‘date‘].year) # 2019

Теперь строки даты анализируются в datetime объекты автоматически!

Инкрементный анализ JSON

Анализ огромных файлов JSON может исчерпать память. json модуль имеет потоковый парсер JSONDecoder чтобы справиться с этим:

import json

with open(‘big.json‘) as f:
  parser = json.JSONDecoder()
  for obj in parser.decode(f.read()): 
    print(obj)

Он постепенно анализирует JSON, получая объекты Python по ходу работы.

Для массивов JSON вы также можете передать chunk_size в json.load():

with open(‘big.json‘) as f:
  for obj in json.load(f, chunk_size=1000):
    print(obj)

Он загружает массив JSON частями по 1000 элементов. Отлично подходит для огромных наборов данных!

Проверка схем JSON

При приеме данных JSON проверка помогает выявить проблемы на ранней стадии.

Ассоциация jsonschema Модуль позволяет вам определить схему и проверить данные по ней:

from jsonschema import validate

schema = {
  "type": "object",
  "required": ["name", "email"],
  "properties": {
    "name": {"type": "string"},
    "email": {"type": "string"} 
  }
}

data = {"name": "John"}

try:
  validate(data, schema)
except Exception as e:
  print(e) # ‘email‘ is a required property

При этом проверяются обязательные поля, ожидаемые типы и т. д. Критически важно для надежных API JSON.

Какой парсер мне следует использовать?

Python имеет несколько вариантов анализа JSON:

• JSON – Модуль JSON стандартной библиотеки. Отличный баланс скорости, совместимости и возможностей.
• простой – Внешний модуль ориентирован на производительность. До 10 раз быстрее, чем json.
• панд – pd.read_json() и json_normalize() отлично справляются с преобразованием JSON в DataFrames.

Моя рекомендация:

• JSON – Лучше всего подходит для общих задач синтаксического анализа, таких как чтение файлов или простой анализ строк.
• панд – Если JSON → DataFrame — ваша конечная цель, панды не смогут победить.
• простой – Для критически важных приложений, работающих с большим количеством JSON.

Подводя итог, Python превращает анализ JSON в удовольствие, будь то простые строки или огромные наборы данных. json и pandas Модули предоставляют все необходимые инструменты.

Надеюсь, эти советы помогут вам стать ниндзя синтаксического анализа JSON! Дайте мне знать, если у вас есть еще вопросы.