Работа с json python: Работа с json в python

Работа в Pandas с JSON, PostgreSQL, MongoDB, Excel на примерах ~ PythonRu

Чтение и запись в файлы Microsoft Excel

Данные очень легко читать из файлов CSV, но они часто хранятся в табличной форме в формате Excel.

pandas предоставляет специальные функции для работы с ним:

Функция read_excel() может читать из файлов Excel 2003 (.xls) и Excel 2007 (.xlsx). Это возможно благодаря модулю xlrd.

Для начала откроем файл Excel и введем данные со следующий таблиц. Разместим их в листах sheet1 и sheet2. Сохраним файл как ch05_data.xlsx.

Для чтения данных из файла XLS нужно всего лишь конвертировать его в Dataframe, используя для этого функцию read_excel().

>>> pd.read_excel('ch05_data.xlsx')

По умолчанию готовый объект pandas Dataframe будет состоять из данных первого листа файла. Но если нужно загрузить и второй, то достаточно просто указать его номер (индекс) или название в качестве второго аргумента.

>>> pd.read_excel('ch05_data.xlsx','Sheet2')

>>> pd.read_excel('ch05_data.xlsx',1)

Запись работает по тому же принципу. Для конвертации объекта Dataframe в Excel нужно написать следующее.

>>> frame = pd.DataFrame(np.random.random((4,4)),
... 			 index = ['exp1','exp2','exp3','exp4'],
... 			 columns = ['Jan2015','Fab2015','Mar2015','Apr2005'])
>>> frame.to_excel('data2.xlsx')
>>> frame

В рабочей директории будет создан файл с соответствующими данными.

Данные JSON

JSON (JavaScript Object Notation) стал одним из самых распространенных стандартных форматов для передачи данных в сети.

Одна из главных его особенностей — гибкость, хотя структура и не похожа на привычные таблицы.

В этом разделе вы узнаете, как использовать функции read_json() и to_json() для использования API. А в следующем — познакомитесь с другим примером взаимодействия со структурированными данными формата, который чаще встречается в реальной жизни.

http://jsonviewer.stack.hu/ — полезный онлайн-инструмент для проверки формата JSON. Нужно вставить данные в этом формате, и сайт покажет, представлены ли они в корректной форме, а также покажет дерево структуры.

{
  "up": {
    "white": 0,
    "black": 4,
    "red": 8,
    "blue": 12
  },
  "down": {
    "white": 1,
    "black": 5,
    "red": 9,
    "blue": 13
  },
  "right": {
    "white": 2,
    "black": 6,
    "red": 10,
    "blue": 14
  },
  "left": {
    "white": 3,
    "black": 7,
    "red": 11,
    "blue": 15
  }
}

Начнем с самого полезного примера, когда есть объект Dataframe и его нужно конвертировать в файл JSON. Определим такой объект и используем его для вызова функции to_json(), указав название для итогового файла.

>>> frame = pd.DataFrame(np.arange(16).reshape(4,4),
... 			 index=['white','black','red','blue'],
... 			 columns=['up','down','right','left'])
>>> frame.to_json('frame.json')

Он будет находится в рабочей папке и включать все данные в формате JSON.

Обратную операцию можно выполнить с помощью функции read_json(). Параметром здесь должен выступать файл с данными.

>>> pd.read_json('frame.json')

Это был простейший пример, где данные JSON представлены в табличной форме (поскольку источником файла frame.json служил именно такой объект — Dataframe). Но в большинстве случаев у JSON-файлов нет такой четкой структуры. Поэтому нужно конвертировать файл в табличную форму. Этот процесс называется нормализацией.

Библиотека pandas предоставляет функцию json_normalize(), которая умеет конвертировать объект dict или список в таблицу. Для начала ее нужно импортировать:

>>> from pandas.io.json import json_normalize

Создадим JSON-файл как в следующем примере с помощью любого текстового редактора и сохраним его в рабочей директории как books.json.

[{"writer": "Mark Ross",
 "nationality": "USA",
 "books": [
 {"title": "XML Cookbook", "price": 23.56},
 {"title": "Python Fundamentals", "price": 50.70},
 {"title": "The NumPy library", "price": 12.30}
 ]
},
{"writer": "Barbara Bracket",
 "nationality": "UK",
 "books": [
 {"title": "Java Enterprise", "price": 28.60},
 {"title": "HTML5", "price": 31.35},
 {"title": "Python for Dummies", "price": 28.00}
 ]
}]

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

>>> import json
>>> file = open('books.json','r')
>>> text = file.read()
>>> text = json.loads(text)

После этого можно использовать функцию json_normalize(). Например, можно получить список книг. Для этого необходимо указать ключ books в качестве второго параметра.

>>> json_normalize(text,'books')

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

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

>>> json_normalize(text,'books',['nationality','writer'])

Результатом будет Dataframe с готовой структурой.

Формат HDF5

До сих пор в примерах использовалась запись данных лишь в текстовом формате. Но когда речь заходит о больших объемах, то предпочтительнее использовать бинарный. Для этого в Python есть несколько инструментов. Один из них — библиотека HDF5.

HDF расшифровывается как hierarchical data format (иерархический формат данных), а сама библиотека используется для чтения и записи файлов HDF5, содержащих структуру с узлами и возможностью хранить несколько наборов данных.

Библиотека разработана на C, но предусматривает интерфейсы для других языков: Python, MATLAB и Java. Она особенно эффективна при сохранении больших объемов данных. В сравнении с остальными форматами, работающими в бинарном виде, HDF5 поддерживает сжатие в реальном времени, используя преимущества повторяющихся паттернов в структуре для уменьшения размера файла.

Возможные варианты в Python — это PyTables и h5py. Они отличаются по нескольким аспектам, а выбирать их стоит, основываясь на том, что нужно программисту.

h5py предоставляет прямой интерфейс с высокоуровневыми API HDF5, а PyTables скрывает за абстракциями многие детали HDF5 с более гибкими контейнерами данных, индексированные таблицы, запросы и другие способы вычислений.

В pandas есть классовый dict под названием HDFStore, который использует PyTables для хранения объектов pandas. Поэтому перед началом работы с форматом необходимо импортировать класс HDFStore:

>>> from pandas.io.pytables import HDFStore

Теперь данные объекта Dataframe можно хранить в файле с расширением .h5. Для начала создадим Dataframe.

>>> frame = pd.DataFrame(np.arange(16).reshape(4,4),
... 			 index=['white','black','red','blue'],
... 			 columns=['up','down','right','left'])

Дальше нужен файл HDF5 под названием mydata.h5. Добавим в него содержимое объекта Dataframe.

>>> store = HDFStore('mydata.h5')
>>> store['obj1'] = frame

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

>>> store
<class 'pandas.io.pytables.HDFStore'>
File path: ch05_data.h5

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

Взаимодействие с базами данных

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

Загрузка из SQL в Dataframe — это простой процесс, а pandas предлагает дополнительные функции для еще большего упрощения.

Модуль pandas.io.sql предоставляет объединенный интерфейс, независимый от базы данных, под названием sqlalchemy. Он упрощает режим соединения, поскольку команды неизменны вне зависимости от типа базы. Для создания соединения используется функция create_engine(). Это же позволяет настроить все необходимые свойства: ввести имя пользователя, пароль и порт, а также создать экземпляр базы данных.

Вот список разных типов баз данных:

>>> from sqlalchemy import create_engine

>>> engine = create_engine('postgresql://scott:tiger@localhost:5432/mydatabase')

>>> engine = create_engine('mysql+mysqldb://scott:tiger@localhost/foo')

>>> engine = create_engine('oracle://scott:[email protected]:1521/sidname')

>>> engine = create_engine('mssql+pyodbc://mydsn')

>>> engine = create_engine('sqlite:///foo.db')

Загрузка и запись данных с SQLite3

Для первого примера используем базу данных SQLite, применив встроенный Python sqlite3. SQLite3 — это инструмент, реализующий реляционную базу данных очень простым путем. Это самый легкий способ добавить ее в любое приложение на Python. С помощью SQLite фактически можно создать встроенную базу данных в одном файле.

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

Создадим объект Dataframe, который будет использоваться для создания новой таблицы в базе данных SQLite3.

>>> frame = pd.DataFrame(np.arange(20).reshape(4,5),
... 			 columns=['white','red','blue','black','green'])
>>> frame

Теперь нужно реализовать соединение с базой.

>>> engine = create_engine('sqlite:///foo.db')

Конвертируем объект в таблицу внутри базы данных.

>>> frame.to_sql('colors',engine)

А вот для чтения базы нужно использовать функцию read_sql(), указав название таблицы и движок.

>>> pd.read_sql('colors',engine)

На примере видно, что даже в этом случае процесс записи очень прост благодаря API библиотеки pandas.

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

Во-первых, нужно установить соединение и создать таблицу, определив правильные типы данных, которые впоследствии будут загружаться.

>>> import sqlite3
>>> query = """
... CREATE 

Чтение и запись файлов JSON в Python с помощью библиотеки Pandas

Библиотека Pandas предоставляет классы и функционал для чтения, обработки и визуализации данных, хранящихся в различных форматах. В этой статье мы научимся считывать и записывать данные JSON, используя Python и Pandas.

Сначала мы создадим файл с использованием ядра Python, а затем считаем и запишем в него данные с помощью Pandas.

В Python для создания данных JSON можно использовать вложенные словари. Каждый элемент во внешнем словаре соответствует столбцу в файле JSON.

Ключ каждого элемента – заголовок столбца, а значение – другой словарь, состоящий из строк столбца. Реализуем словарь, который можно использовать для создания файла JSON со списком вымышленных пациентов:

patients = {
         "Name":{"0":"John","1":"Nick","2":"Ali","3":"Joseph"},
         "Gender":{"0":"Male","1":"Male","2":"Female","3":"Male"},
         "Nationality":{"0":"UK","1":"French","2":"USA","3":"Brazil"},
         "Age" :{"0":10,"1":25,"2":35,"3":29}
}

В приведенном выше коде первый элемент соответствует столбцу Name. Значение элемента состоит из словаря, в котором элементы являются строками. Ключи внутренних элементов словаря соответствуют порядковым номерам строк, где значения представляют значения строк.

В столбце Name первая запись сохраняется в нулевом индексе, где значением записи является John, и так далее.

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

Создадим список для файла JSON, в котором хранится информация о разных автомобилях:

cars = [
    {"Name":"Honda", "Price": 10000, "Model":2005, "Power": 1300},
    {"Name":"Toyota", "Price": 12000, "Model":2010, "Power": 1600},
    {"Name":"Audi", "Price": 25000, "Model":2017, "Power": 1800},
    {"Name":"Ford", "Price": 28000, "Model":2009, "Power": 1200},
         
]

Каждому элементу словаря соответствует строка в файле JSON. Например, первый элемент в первом словаре хранит в столбце Name значение Honda. Значение в первой строке столбца Price будет 10000 и так далее.

С помощью вложенных словарей и списков словарей можно сохранить данные в файле JSON. Для этого мы будем использовать модуль json и метод dump():

import json
with open('E:/datasets/patients.json', 'w') as f:
    json.dump(patients, f)
    
with open('E:/datasets/cars.json', 'w') as f:
    json.dump(cars, f)  

Теперь у нас есть два файла JSON — patients.json и cars.json.

Чтобы прочитать файл JSON с помощью Pandas, вызовем метод read_json() и передадим ему путь к файлу, который нужно прочитать. Метод возвращает DataFrame, который хранит данные в виде столбцов и строк.

Но сначала нужно установить библиотеку Pandas:

Приведенный ниже скрипт считывает файл patients.json из локальной системной директории и сохраняет результат во фрейме данных patients_df. Затем заголовок фрейма выводится с помощью метода head():

import pandas as pd
patients_df = pd.read_json('E:/datasets/patients.json')
patients_df.head()

Запуск этого кода должен дать следующий результат:

Следующий скрипт считает файл cars.json из локальной системы и затем вызовет метод head()cars_df для вывода заголовка:

cars_df = pd.read_json('E:/datasets/cars.json')
cars_df.head()

Результат запуска этого кода:

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

Давайте прочитаем и выведем заголовок из Iris Dataset:

import pandas as pd
iris_data = pd.read_json("https://raw.githubusercontent.com/domoritz/maps/master/data/iris.json")
iris_data.head()

Результат запуска этого кода:

Чтобы преобразовать фрейм данных Pandas в файл JSON, используем функцию to_json() и передадим ей в качестве параметра путь к файлу, который будет создан.

Создадим файл JSON из набора данных tips, который включен в библиотеку Seaborn. Но сначала установим ее:

Затем импортируем ее и загрузим подсказки в набор данных:

import seaborn as sns

dataset = sns.load_dataset('tips')
dataset.head()

Ниже показано как выглядит набор данных:

Функция Seaborn load_dataset() возвращает DataFrame, поэтому загрузка набора данных позволяет вызвать функцию to_json() для ее преобразования.

После получения доступа к набору данных, сохраним его содержимое в файле JSON. Мы создали для этого каталог datasets:

dataset.to_json('E:/datasets/tips.json')

Перейдя в каталог E:/datasets, вы должны увидеть там файл tips.json, JSON-данные которого соответствует записям во фрейме данных Pandas tips:

{
   "total_bill":{
       "0":16.99,
       "1":10.34,
       "2":21.01,
       "3":23.68,
       "4":24.59,
       "5":25.29,
       ...
   }
   "tip":{
       "0":1.01,
       "1":1.66,
       "2":3.5,
       "3":3.31,
       "4":3.61,
       "5":4.71,
       ...
   }
   "sex":{
        "0":"Female",
        "1":"Male",
        "2":"Male",
        "3":"Male",
        "4":"Female",
        "5":"Male",
        ...
   }
    "smoker":{
        "0":"No",
        "1":"No",
        "2":"No",
        "3":"No",
        "4":"No",
        "5":"No",
        ...
    }
    ...

В этой статье мы рассмотрели, как считывать и записывать файлы JSON, используя популярную библиотеку Pandas Python.

Данная публикация представляет собой перевод статьи «Reading and Writing JSON to a File in Python» , подготовленной дружной командой проекта Интернет-технологии.ру

Python Language — Модуль JSON

Для полной документации, включая функциональность, зависящую от версии, ознакомьтесь с официальной документацией .

Значения по умолчанию

json модуль будет обрабатывать кодирование и декодирование следующих типов по умолчанию:

Типы де-сериализации:

Модуль json также понимает NaN , Infinity и -Infinity как их соответствующие значения float, которые находятся вне спецификации JSON.

Типы сериализации:

Чтобы запретить кодирование NaN , Infinity и -Infinity вы должны закодировать с allow_nan=False . Это приведет к повышению значения ValueError если вы попытаетесь закодировать эти значения.

Пользовательская (де-) сериализация

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

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

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

# my_json module

import json
from functools import partial

def serialise_object(obj):
    # Do something to produce json-serialisable data
    return dict_obj

dump = partial(json.dump, default=serialise_object)
dumps = partial(json.dumps, default=serialise_object)

Десериализация:

Существуют различные крючки, которые обрабатываются функциями json, такими как object_hook и parse_float. Для исчерпывающего списка вашей версии python см. Здесь .

# my_json module

import json
from functools import partial

def deserialise_object(dict_obj):
    # Do something custom
    return obj

def deserialise_float(str_obj):
    # Do something custom
    return obj

load = partial(json.load, object_hook=deserialise_object, parse_float=deserialise_float)
loads = partial(json.loads, object_hook=deserialise_object, parse_float=deserialise_float)

Дальнейшая настройка (дезактивация):

Модуль json также позволяет расширять / заменять json.JSONEncoder и json.JSONDecoder для обработки разных типов. Крюки, описанные выше, могут быть добавлены как значения по умолчанию, создав эквивалентный именованный метод. Чтобы использовать их, просто передайте класс как параметр cls в соответствующую функцию. Использование functools.partial позволяет частично применить параметр cls к этим функциям для удобства, например

# my_json module

import json
from functools import partial

class MyEncoder(json.JSONEncoder):
    # Do something custom

class MyDecoder(json.JSONDecoder):
    # Do something custom

dump = partial(json.dump, cls=MyEncoder)
dumps = partial(json.dumps, cls=MyEncoder)
load = partial(json.load, cls=MyDecoder)
loads = partial(json.loads, cls=MyDecoder)

Работа с документацией в Python: поиск информации и соглашения

Python обладает великолепной документацией и предоставляет удобные способы для работы с ней: от официального сайта до встроенной справочной системы.

Работа с документацией является одной из важных составляющих деятельности разработчика. И это не только чтение документации к библиотекам и комментариев в коде, но и документирование собственного кода, а также поддержание его в актуальном состоянии. Качественно задокументированный код во многих случаях упрощает его поддержание и сокращает время на «вхождение» новых сотрудников в проект. Если же речь идет об изучении нового языка программирования, качество документации и поддержка сообщества могут сыграть решающую роль в освоении материала и снизить порог вхождения.

Документация к языку программирования Python обладает всеми качествами, которые отличают «хорошую» документацию от «плохой». Тем не менее, новички часто сталкиваются с рядом вопросов. Как быстро найти информацию о классе или функции? Как самому писать документацию к коду? Какие инструменты можно использовать при документировании кода? На эти вопросы мы и постараемся ответить в статье.

Основной источник информации о Python

Безусловно, основным, наиболее полным и актуальным источником информации о Python является сайт c официальной документацией. Главная страница сайта предоставляет удобную навигацию по разделам.

Важные разделы сайта (полезно начинающим программистам)

• Setup and Usage — содержит информацию об установке и настройке Python на разных платформах;
• Tutorial — учебное пособие для новичков, с которого и рекомендуется начинать свой путь в мир Python;
• Library Reference — подробное описание стандартной библиотеки Python;
• Python HOWTO — различные руководства по конкретным темам;
• Language Reference — раздел для тех кто, хочет знать подробности реализации СPython.

В остальных разделах вы можете найти информацию о сторонних модулях, их установке и распространении, информацию по написанию расширений для Python на языках С/С++, часто задаваемые вопросы и новости Python.

Поиск по сайту с документацией

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

Создатели Python предусмотрели возможность установить документацию локально на компьютере. Для этого необходимо перейти на страницу загрузки, выбрать версию Python, формат файлов (доступны pdf, epub, html, txt) и способ архивирования. После скачивания и распаковки архива, вы можете пользоваться документацией в полном объеме.

Встроенная справочная система

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

Небольшое уточнение: поскольку в Python все является объектом, в том числе методы и классы, далее мы будем часто употреблять термин «объект» применительно к целям получения информации.

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

Примеры

>>> help(ord)
Help on built-in function ord in module builtins:
ord(c, /)
    Return the Unicode code point for a one-character string.
(END)

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

Теперь попробуем получить информацию о модуле стандартной библиотеки os.

>>> help(os)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'os' is not defined

Почему вызов функции завершился выбросом исключения? Ведь модуль os входит в стандартную библиотеку и маловероятно, что справочная информация по нему не была включена.

Docstring

Чтобы ответить на этот вопрос, давайте разберемся, где хранится справочная информация и как работает функция help. Как уже говорилось выше, все в Python является объектом. Все объекты в Python имеют специальный атрибут __doc__, предназначенный для хранения строки документации — docstring. Вот как определено понятие docstring в официальной документации: «Docstring — строковый литерал, который встречается как первый оператор в определении модуля, функции, класса или метода. Такой docstring становится специальным атрибутом __doc__ этого объекта».

Посмотрим, что хранится в атрибуте __doc__ объекта ord.

>>> ord.__doc__
'Return the Unicode code point for a one-character string.'

Размещение справки об объекте в исходном коде самого объекта позволяет элегантно решить вопрос хранения информации и доступа к ней. Функция help при передаче ей в качестве аргумента объекта для получения информации о нем, обращается к атрибуту __doc__ этого объекта. Поскольку модуль os не импортирован, он отсутствует в глобальной области видимости и не доступен при вызове функции help. Именно по этой причине мы получаем ошибку. Для решения проблемы достаточно импортировать модуль. Есть еще один способ избежать ошибки и не связанный с импортом объекта — передать в качестве аргумента в функцию help строку с именем объекта.

>>> help('os')

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

Посмотрим на исходный код модуля os и убедимся в том, что docstring и содержимое атрибута os.__doc__ совпадают. Из приведенного кода видно, как определяются в коде docstring. Строки документации заключаются в тройные кавычки и пишутся сразу под заголовком объекта.

Вы уже заметили, что вывод функции help отличается от вывода, полученного через обращение к атрибуту __doc__ объекта. Он более информативен и выводит информацию в виде форматированного текста. У функции help есть еще одна особенность, повышающая удобство работы со справочной системой. При вызове help без аргументов запускается интерактивный режим справочной системы. Для получения справки в нем достаточно набрать только название интересующего нас объекта. Запустив интерактивный режим в отдельном терминале, мы получаем удобный инструмент для работы с документацией.

Как вспомнить название модуля, класса или функции?

Стандартная библиотека Python весьма обширна и содержит большое количество модулей. Помнить их все, в том числе и заложенный функционал, невозможно. Что делать, если мы не помним (не знаем) название модуля, класса или функции? Ниже приведены несколько примеров, помогающих в таких ситуациях.

Получение списка доступных модулей:

>>> help('modules')

Получение ключевых слов:

>>> from keyword import kwlist
>>> print(*kwlist, sep='\n')

Получение списка названий встроенных функций:

>>> import builtins
>>> print(*builtins.__dict__.keys(), sep='\n')

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

>>> dir(int)

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

Теперь, когда мы знаем о docstring и работе функции help, мы можем задокументировать свой код. В качестве примера возьмем скрипт factorial.py:

def factorial(n):
   if n < 2:
       return 1
   return n * factorial(n — 1)

if __name__ == "__main__":
   n = int(input())
   print(factorial(n))

Добавим docstring.

""" Скрипт для нахождения факториала """

def factorial(n):
    """ Вычисляет факториал числа n """
   if n < 2:
       return 1
   return n * factorial(n - 1)

if __name__ == "__main__":
   n = int(input())
   print(factorial(n))

Убедимся в наличии документации по модулю factorial:

>>> import factorial
>>> factorial.__doc__
' Скрипт для нахождения факториала '
>>> factorial.factorial.__doc__
' Вычисляет факториал числа n '

Вызов help(factorial) вернет справку:

Help on module factorial:

NAME
   factorial - Скрипт для нахождения факториала

FUNCTIONS
   factorial(n)
       Вычисляет факториал числа n

FILE
   /home/user/factorial.py
(END)

При создании документации к коду стоит придерживаться правил и рекомендаций, описанных в PEP257 и PEP8. Ссылки на эти документы приведены в конце статьи.

О библиотеке pydoc

Мы уже упоминали модуль стандартной библиотеки pydoc. Он автоматически генерирует документацию из модулей Python. Документация может быть представлена ​​в виде страниц текста на консоли, отображаться в браузере или сохраняться в HTML-файлах.

Команда pydoc позволяет вывести текст справки прямо в терминале (не интерпретаторе Python):

$ pydoc sum

Help on built-in function sum in module __builtin__:

sum(...)
   sum(sequence[, start]) -> value
   Return the sum of a sequence of numbers (NOT strings) plus the value
   of parameter 'start' (which defaults to 0). When the sequence is
   empty, return start.
(END)

Для создания документации в виде HTML-страниц используется ключ -w. Это позволяет организовать хранение документации отдельно от кода.

$ pydoc -w sum
wrote sum.html
$ cat sum.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><title>python: built-in function sum</title>
<meta charset="utf-8">
</head><body bgcolor="#f0f0f8">
<dl><dt><a name="-sum"><strong>sum</strong></a>(...)</dt><dd><tt>sum(sequence[,&nbsp;start])&nbsp;-&gt;&nbsp;value<br>
&nbsp;<br>
Return&nbsp;the&nbsp;sum&nbsp;of&nbsp;a&nbsp;sequence&nbsp;of&nbsp;numbers&nbsp;(NOT&nbsp;strings)&nbsp;plus&nbsp;the&nbsp;value<br>
of&nbsp;parameter&nbsp;'start'&nbsp;(which&nbsp;defaults&nbsp;to&nbsp;0).&nbsp;&nbsp;When&nbsp;the&nbsp;sequence&nbsp;is<br>
empty,&nbsp;return&nbsp;start.</tt></dd></dl>

Для поиска по docstring модулей используется ключ -k. В качестве аргумента в этом случае передается ключевое слово. В результате будут выведены названия всех модулей в docstring которых встречается ключевое слово.

$ pydoc -k json
json - JSON (JavaScript Object Notation) <http://json.org> is a subset of
json.decoder - Implementation of JSONDecoder
json.encoder - Implementation of JSONEncoder
json.scanner - JSON token scanner
json.tool - Command-line tool to validate and pretty-print JSON
_json
pbr.pbr_json

Обратим ваше внимание на одну особенность поиска по документации при использовании ключа -k. Поиск производится только по первым строкам документации модулей. Тем не менее, данный функционал может быть весьма полезным в некоторых случаях.

Для любителей работать в браузере, предусмотрена возможность запуска HTTP-сервера документации, который будет доступен по порту, указанному после ключа -p.

$ pydoc3 -p 1234
Server ready at http://localhost:1234/
Server commands: [b]rowser, [q]uit
server>

В третьей версии Python для управления сервером добавлена пара команд: b — открытие страницы документации в браузере, q — завершения работы сервера. При вызове команды pydoc3 с ключом -b произойдет запуск сервера и автоматическое открытие страницы в браузере. В документацию также будут включены модули, расположенные в директории из которой был запущен сервер.

Соблюдение соглашений

При документировании кода важно соблюдать принятые в языке программирования соглашения. Для решения этих задач существуют различные инструменты. В этой статье мы становимся на одном из них — модуле pydocstyle.

Модуль pydocstyle — это инструмент статического анализа для проверки соответствия docstring соглашениям, принятым в Python. Установка модуля осуществляется с помощью менеджера пакетов pip:

$ pip install pydocstyle

По умолчанию pydocstyle проверяет docstring на соответствие официальному соглашению PEP257. Проверим созданный нами скрипт factorial.py:

$ pydocstyle factorial.py
factorial.py:1 at module level:
  D400: First line should end with a period (not 'а')
factorial.py:1 at module level:
  D210: No whitespaces allowed surrounding docstring text
factorial.py:3 in public function `factorial`:
  D400: First line should end with a period (not 'n')
factorial.py:3 in public function `factorial`:
  D210: No whitespaces allowed surrounding docstring text

Видим, что pydocstyle обнаружил ошибки — лишние пробелы вокруг текста и отсутствие точки в конце строк документации. Исправим эти ошибки и запустим pydocstyle еще раз.

Модуль pydocstyle имеет более широкие возможности, чем в приведенном выше примере, и гибкую систему настроек под требования по оформлению документации. Ознакомится с их полным списком можно вызвав pydocstyle -h или в разделе «документация» на сайте проекта.

Полезные ссылки

ФРОО рекомендует:

Еще статьи по Python

Заметки Python #18: Сетевое программирование |

2 654

Вот мы и добрались до самого главного — обсуждения взаимодействия между сервером и клиентом. Как они соединяются друг с другом? Какие протоколы нужно использовать и что такое сокет?

Протокол

Сетевое программирование — это та его часть, которая подразумевает обмен данными между сервером и клиентом. При этом клиент и сервер — это не обязательно разные физические сервера, компьютеры, гаджеты. Клиент-серверная архитектура может быть реализована логически, на одном «железе», в одной комнате, за одним столом. Для взаимодействия между ними используется некоторый свод правил по транспортировке, инкапсуляции, очередности пакетов и сетевого взаимодействия — это называется протоколом передачи данных. Приложения, написанные на Python обычно используют протоколы транспортного уровня TCP и UDP.

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

Протокол UDP — низкоуровневый. С его помощью компьютеры могут отправлять и получать информацию в виде отдельных пакетов, не создавая логическое соединение. В отличие от TCP, взаимодействия по протоколу UDP не отличаются надежностью. Это усложняет управление ими в приложениях, в которых при обмене информацией нужны гарантии. Поэтому большинство интернет-приложений используют TCP.

[adace-ad id=»3470″]

Сокеты

С протоколами разобрались. Но как этими протоколами пользоваться нашим клиентам и сервером? Это взаимодействие осуществляется с помощью сокета. Сокет — абстрактный объект, представляющий конечную точку соединения. . С сокетом в Питоне можно работать, как с файлом — считывать его и получать данные. Сокет содержит в себе два параметра: IP-адрес и порт.

Сервер, принимая соединение присваивает своему сокету определенный порт. Порт — число в заголовках пакетов TCP, UDP, указывающее, для какого приложения в системе предназначен данный IP-пакет.  Использовать порты с номерами 0-1023 нельзя — они зарезервированы под служебные сетевые протоколы (например, 21 — FTP, 80 — HTTP и т.д.). Клиент, отправляя данные тоже должен создать свой сокет. Два сокета с обоих сторон создают виртуальное соединение по которому будет идти передача данных. Нужно отметить, что при работе с протоколом TCP, создается два сокета: один из них — слушающий (listen). Он переходит в режим ожидания и активизируется при появлении нового соединения. При этом можно проверять актуальные активные соединения, установить периодичность операции. Второй — сокет для обмена данных с клиентом (accept). Это два разных сокета, не путайте

[adace-ad id=»3482″]

Работа с сокетами в Python

Для создания сокетов в питоне используется модуль socket. В нем так же имеются методы для , установление и закрытие соединения, отправку данных по сети и их получение и другие операции.

Работа ТСР протокола

Чтобы понять, как с сокетом работает протокол ТСР, посмотрим на изображение ниже. Пояснение будет в коде программы (для примера мы отправляем клиенту текущее время)

Серверная часть:

Функция socket() инициализирует создание сокета. В ней передаются два параметра: communication domain и type of socket. AF_INET — это коммуникационный домен, который задает сетевую направленность нашему сокету. Тип сокета — SOCK_STREAM — он определяет сокет как потоковый, то есть реализующий последовательный, надежный двусторонний поток байтов по протоколу ТСР. Создалась конечная точка подключения — сокет. Функция socket() возвращает нам файловый дескриптор, который позволяет работать с сокетом, как с файлом — записывать и считывать данные в/из него. Метод encode применяется здесь, т.к. данные нужно отправлять по сети в виде байтов.

[code]

# серверная часть
from socket import *
import time

s = socket(AF_INET, SOCK_STREAM) # Создается сокет протокола TCP
s.bind((», 10000)) # Присваиваем ему порт 10000
s.listen(10) # Максимальное количество одновременных запросов

while True:
client, addr = s.accept() # акцептим запрос на соединение
print(client)
print(«Запрос на соединение от %s» % str(addr))
timestr = time.ctime(time.time()) + «\n»
client.send(timestr.encode(‘utf-8’)) #передаем данные, предварительно упаковав их в байты
client.close() # закрываем соединение

[/code]

 

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

Клиентская часть

[adace-ad id=»3475″]

 

Клиент устанавливает соединение с помощью метода connect (в нашем случае, localhost, т.к. сервер и клиент на одной машине). Как мы уже знаем, сервер отправляет нам последовательность кодированных байтов — наша задача декодировать их в строки юникода

[code]

# клиентская часть

from socket import *

s = socket(AF_INET, SOCK_STREAM) # создаем аналогичный сокет, как у сервера
s.connect((‘localhost’, 10000)) # коннектимся с сервером
tm = s.recv(1024) # Принимаем не более 1024 байта данных
s.close() # закрываем соединение
print(«Текущее время: %s» % tm.decode(‘utf-8’)) # получаем данные, декодировав байты

[/code]

 

Результат клиентской части (после запуска сервера):

Результат серверной части (после подключения клиента):

 

Как происходит кодирование/декодирование данных?

Строки, байты, изменяемые строки байтов:

 

Код / данные	Результат print(type())
i= ‘Data’	<class ‘str’> — строка
bi = b’Data’	<class ‘bytes’> — строка байтов
ba = bytearray(bi)	<class ‘bytearray’> — изменяемая строка байтов
i2 = bi.decode(‘cp1251’)	<class ‘str’> — из строки байт в unicode-строку
bi2 = i.encode(‘koi8-r’)	<class ‘bytes’> — из unicode-строки в строку байт
ba2 = bytearray(i, ‘utf-8’)	<class ‘bytearray’> — из unicode-строки в массив байтов

Отправка и приём сообщений

В качестве примера можно рассмотреть простой механизм отправки сообщений от клиента к серверу и обратно. Сервер получает приветствие от клиента и отправляет ответ клиенту. Клиент, соответственно, отправляет приветствие серверу и получает от него ответ

Серверная часть:

[code]

# клиентская часть

from socket import *
import time

s = socket(AF_INET, SOCK_STREAM) # Создаем сокет TCP
s.bind((», 11111)) # Присваиваем порт 11111
s.listen(5) # пять запросов максимум
while True: # пока выполняется условие (пока есть запросы на подключение от клиента)
client, addr = s.accept() # принимаем запрос на соединение
data = client.recv(1000000) # указываем максимальное количество данных, которое можно принять от клиента
print(‘Месседж: ‘, data.decode(‘utf-8’), ‘, пришло от него: ‘, addr)
msg = ‘Купи виски’
client.send(msg.encode(‘utf-8’)) #передаем данные, предварительно упаковав их в байты
client.close()

[/code]

 

Клиентская часть:

[code]

# клиентская часть
from socket import *

s = socket(AF_INET, SOCK_STREAM) # Создаем сокет TCP
s.connect((‘localhost’, 11111)) # коннект к серверу
msg = ‘Привет, сервер’
s.send(msg.encode(‘utf-8’))  #передаем данные, предварительно упаковав их в байты
data = s.recv(1000000) #получаем не более 1000000 байт
print(‘Сообщение от сервера: ‘, data.decode(‘utf-8’), ‘, длиной ‘, len(data), ‘ байт’) #получаем сообщение от сервера, декодировав байты юникод
s.close()

[/code]

 

JSON Instant Messaging

JIM — протокол для обмена данных между клиентом и сервером, который работает через TCP-сокеты (SOCK_STREAM) и передачу JSON-объектов. Все сетевые операции проходят в байтовом представлении. Данные в JSON-формате в протоколе JIM всегда содержат два поля: action и time.

Поле action задает характер действия — авторизация или отправка сообщения и т.п.

Поле time показывает время отправки данного сообщение (используется UNIX-время  — определяется как количество секунд, прошедших с полуночи (00:00:00 UTC) 1 января 1970 года)

JSON-объекты в JIM имеют ограничение по количеству символов. Например, сам текст сообщения ограничен 500 символами. Остальные ограничения:

Поле action — «Действие», 15 символов

Поле response — «Код ответа сервера», 3 символа (цифры)

Поле name — «Имя пользователя  или название чата». Здесь максимум 25 символов;

Весь скомпилированный JSON-объект должен уложиться в 640 символов.

Аутентификация

Для того, чтобы инициализировать процесс аутентификации, надо создать такой JSON-объект:

[code]

{
«action»: «authenticate»,
«time»: <unix timestamp>,
«user»: {
«account_name»: «digital2»,
«password»: «superpythontools»
}
}

[/code]

 

Ответы сервера будут содержать поле response, и может быть еще одно (необязательное) поле alert/error с текстом ошибки.

[code]

{
«response»: код,
«alert»: текст
}

[/code]

 

Подключение, отключение, авторизация

Авторизация — не обязательное условие при использовании JIM, т.е. его могут использовать любые пользователи. Если авторизация будет нужна на каком-то этапе, сервер выдаст алерт с кодом 401. Если аутентификация всё же нужна, то сервер может выдать один из нескольких вариантов респонзов:

[code]

{
«response»: 200,
«alert»:»Необязательное сообщение/уведомление»
}

{
«response»: 402,
«error»: «This could be «wrong password» or «no account with that name»»
}

{
«response»: 409,
«error»: «Someone is already connected with the given user name»
}

[/code]

 

Отключение от сервера должно сопровождаться сообщением “quit”:

[code]

{
«action»: «quit»
}

[/code]

В сети/ не в сети

Для того, чтобы обозначить своё присутствие в «онлайне», клиент должен отправлять специальное presence сообщение с полем type

[code]

{
«action»: «presence»,
«time»: <unix timestamp>,
«type»: «status»,
«user»: {
«account_name»: «digital2»,
«status»: «User is online»
}
}

[/code]

 

В свою очередь, сервер посылает специальный probe-запрос для проверки доступности клиента:

[code]

{
«action»: «probe»,
«time»: <unix timestamp>,
}

[/code]

Алерты и ошибки сервера

 

Код	Что означает?
1xx — информационные сообщения	100 — базовое уведомление; 101 — важное уведомление.
2xx — успешное завершение:	200 — OK;  201 (created) — объект создан; 202 (accepted) — подтверждение.
4xx — ошибка на стороне клиента:	400 — неправильный запрос/JSON-объект; 401 — не авторизован; 402 — неправильный логин/пароль; 403 (forbidden) — пользователь заблокирован; 404 (not found) — пользователь/чат отсутствует на сервере; 409 (conflict) — уже имеется подключение с указанным логином; 410 (gone) — адресат существует, но недоступен (offline).
5xx — ошибка на стороне сервера:	500 — ошибка сервера.

 

Обмен сообщениями

Экшн msg для сервера означает одно — ему надо передать сообщение адресату из поля to. Если не задана кодировка в поле encoding, то сервер будет считывать данные в ascii-формате

[code]

{
«action»: «msg»,
«time»: <unix timestamp>,
«to»: «account_name»,
«from»: «account_name»,
«encoding»: «ascii»,
«message»: «message»
}

[/code]

Сообщение в «чат»

Тоже самое, что и отправка обычному пользователю, только в поле to ставится решетка с названием чатрума

[code]

{
«action»: «msg»,
«time»: <unix timestamp>,
«to»: «#room_name»,
«from»: «account_name»,
«message»: «Hello World»
}

[/code]

 

Чтобы зайти в чат:

[code]

{
«action»: «join»,
«time»: <unix timestamp>,
«room»: «#room_name»
}

[/code]

 

Выйти из чата:

[code]

{
«action»: «leave»,
«time»: <unix timestamp>,
«room»: «#room_name»
}

[/code]

 

Метод Actions

Методы протокола «действия» в  JIM:

“action”: “presence” — присутствие. Сервисное сообщение для извещения сервера о присутствии клиента online;
“action”: “prоbe” — проверка присутствия. Сервисное сообщение от сервера для проверки присутствии клиента online;
“action”: “msg” — простое сообщение пользователю или в чат;
“action”: “quit” — отключение от сервера;
“action”: “authenticate” — авторизация на сервере;
“action”: “join” — присоединиться к чату;
“action”: “leave” — покинуть чат.

Настоятельно рекомендуем ознакомиться с сокетами на Python в материале Хабра — https://habr.com/ru/post/149077/

json_util — Инструменты для использования модуля Python json с документами BSON — документация PyMongo 3.9.0

Инструменты для использования модуля Python json с документами BSON.

Этот модуль предоставляет два вспомогательных метода: дампов и загружает , которые обертывают
собственные методы json и обеспечивают явное преобразование BSON в и из
JSON. JSONOptions позволяет контролировать, как JSON
генерируется и анализируется, по умолчанию используется устаревший формат PyMongo. json_util также может генерировать канонический или расширенный расширенный JSON
когда CANONICAL_JSON_OPTIONS или RELAXED_JSON_OPTIONS равно
при условии, соответственно.

Пример использования (десериализация):

 >>> из bson.json_util импортных загрузок
>>> load ('[{"foo": [1, 2]}, {"bar": {"hello": "world"}}, {"code": {"$ scope": {}, " $ code ":" function x () {return 1;} "}}, {" bin ": {" $ type ":" 80 "," $ binary ":" AQIDBA == "}}] ')
[{u'foo ': [1, 2]}, {u'bar': {u'hello ': u'world'}}, {u'code ': Код (' function x () {return 1; } ', {})}, {u'bin': двоичный ('... ', 128)}]
 

Пример использования (сериализация):

 >>> из bson import Binary, Code
>>> из дампов импорта bson.json_util
>>> dumps ([{'foo': [1, 2]},
... {'bar': {'hello': 'world'}},
... {'code': Code ("function x () {return 1;}", {})},
... {'bin': двоичный (b "")}])
'[{"foo": [1, 2]}, {"bar": {"hello": "world"}}, {"code": {"$ code": "function x () {return 1; } "," $ scope ": {}}}, {" bin ": {" $ binary ":" AQIDBA == "," $ type ":" 00 "}}] '
 

Пример использования (с CANONICAL_JSON_OPTIONS ):

 >>> из bson import Binary, Code
>>> от bson.json_util импортные дампы, CANONICAL_JSON_OPTIONS
>>> dumps ([{'foo': [1, 2]},
... {'bar': {'hello': 'world'}},
... {'code': Code ("function x () {return 1;}")},
... {'bin': Binary (b "")}],
... json_options = CANONICAL_JSON_OPTIONS)
'[{"foo": [{"$ numberInt": "1"}, {"$ numberInt": "2"}]}, {"bar": {"hello": "world"}}, {" code ": {" $ code ":" function x () {return 1;} "}}, {" bin ": {" $ binary ": {" base64 ":" AQIDBA == "," subType ":" 00 "}}}] '
 

Пример использования (с RELAXED_JSON_OPTIONS ):

 >>> из bson import Binary, Code
>>> от bson.json_util импортные дампы, RELAXED_JSON_OPTIONS
>>> dumps ([{'foo': [1, 2]},
... {'bar': {'hello': 'world'}},
... {'code': Code ("function x () {return 1;}")},
... {'bin': Binary (b "")}],
... json_options = RELAXED_JSON_OPTIONS)
'[{"foo": [1, 2]}, {"bar": {"hello": "world"}}, {"code": {"$ code": "function x () {return 1; } "}}, {" bin ": {" $ binary ": {" base64 ":" AQIDBA == "," subType ":" 00 "}}}] '
 

Кроме того, вы можете вручную передать по умолчанию в json.свалки () .
Он не обрабатывает двоичных и код
экземпляры (поскольку это расширенные строки, вы не можете указать собственные значения по умолчанию),
но это будет быстрее, поскольку меньше рекурсии.

Примечание

Если вашему приложению не нужна гибкость, предлагаемая
JSONOptions и проводит много времени в json_util
модуль, посмотрите на
python-bsonjs для приятного
улучшение производительности. python-bsonjs — быстрый BSON для MongoDB
Расширенный конвертер JSON для Python, построенный на основе
Либбсон. python-bsonjs работает лучше всего
с PyMongo при использовании RawBSONDocument .

Изменено в версии 2.8: Формат вывода для Timestamp изменен с
От ‘{« t »: ,« i »: }’ до ‘{« $ timestamp »: {« t »: ,« i »: }}’.
Этот новый формат будет декодирован в экземпляр
Отметка времени . Старый формат останется
декодируется в Python dict, как и раньше. Кодирования в старый формат больше нет
поддерживается, поскольку он никогда не был правильным и теряет информацию о типе.Добавлена ​​поддержка $ numberLong и $ undefined — новое в MongoDB 2.6 — и
парсинг $ date в формате ISO-8601.

Изменено в версии 2.7: Сохраняет порядок при визуализации SON, Timestamp, Code, Binary и DBRef.
экземпляры.

Изменено в версии 2.3: добавлены помощники дампа и загрузки для автоматической обработки преобразования в и
из json и поддерживает Binary и
Код

класс bson.json_util. DatetimeRepresentation

НАСЛЕДИЕ = 0

Legacy MongoDB Расширенное представление даты и времени JSON.

экземпляра datetime.datetime экземпляров будут закодированы в JSON в
format {«$ date»: } , где dateAsMilliseconds — это
64-битное целое число со знаком, дающее количество миллисекунд с момента появления Unix
эпоха UTC. Это была кодировка по умолчанию до версии PyMongo 3.4.

ДЛИННЫЙ НОМЕР = 1

NumberLong представление даты и времени.

экземпляра datetime.datetime экземпляров будут закодированы в JSON в
формат {«$ date»: {«$ numberLong»: «»}} ,
где dateAsMilliseconds — строковое представление 64-битного подписанного
целое число, указывающее количество миллисекунд с момента UTC эпохи Unix.

ISO8601 = 2

Представление даты и времени ISO-8601.

datetime.datetime экземпляра больше или равно Unix
эпоха UTC будет закодирована в JSON в формате {«$ date»: «»} .
datetime.datetime экземпляра до эпохи Unix UTC будут
закодировано, как если бы представление datetime
ДЛИННЫЙ НОМЕР .

класс bson.json_util. Режим JSON

НАСЛЕДИЕ = 0

Устаревшее расширенное представление JSON.

В этом режиме дампов () создает наследие PyMongo
нестандартный вывод JSON. Рассмотрите возможность использования
RELAXED или
CANONICAL взамен.

РАССЛАБЛЕННЫЙ = 1

Расслабленное расширенное представление JSON.

В этом режиме

Python Read JSON File — Чтение JSON в Python

Привет всем, добро пожаловать в Python Read JSON File Tutorial. В этом руководстве мы узнаем, что такое JSON и как читать файлы или строки JSON в Python. Возможно, вы уже слышали о JSON. Он используется в Android, веб-технологиях, REST API и везде.

Что такое JSON?

• JSON означает JavaScript Object Notation.
• Это формат обмена данными, в котором вы можете передавать данные от клиента к серверу и с сервера к клиенту.
• Он также используется для связи между приложениями.
• JSON чрезвычайно важен при разработке приложений, особенно когда вы работаете с Rest API.
• Он основан на подмножестве Java Script.
• Легко читать и писать.

Почему мы используем JSON?

В первые дни веб-разработки мы работали с HTML, html — это де-факто шаблон проектирования. Первоначально мы создавали статических страницы , но теперь мир меняется, и мы делаем динамических страницы. Динамические страницы просто означает, что данные, которые вы получаете с сервера, будут динамическими или на ваш запрос вы получите ответ.

• Когда мы отправляем запрос на сервер, сервер отвечает на данные клиенту. Мы можем отправлять данные в текстовом формате от сервера к клиенту, но чтение данных в виде простого текста затруднительно для программы.

Рассмотрим пример

• Представьте, что у вас есть 10 сотрудников в вашей базе данных, и по запросу вы предоставляете данные всех сотрудников в простом текстовом формате.

имя сотрудника — Джон Доу, адрес сотрудника — Чикаго

Имя сотрудника — Джон Доу, адрес сотрудника — Чикаго

• И предположим, что у нас есть то же самое со случайными строками для всех сотрудников.Теперь человек может понять это, читая, но это сложно понять для языка программирования.
• Итак, нам нужна четко определенная структура, чтобы мы могли легко читать данные в нашей программе. А JSON — это структура, которая широко используется.
• Если вы создаете приложение с интерфейсом, который взаимодействует с API и взаимодействует с сервером. Тогда JSON является стандартным форматом для отправки и получения данных с использованием стандартных HTTP-запросов.

Правило синтаксиса JSON

• Использует пары «ключ-значение» — {«name»: «Sam»}
• Использует двойные кавычки для KEY.
• Должен использовать указанные типы данных.
• Тип файла: «.json»
• Тип MIME: «Приложение / json»
• Подробнее о JSON можно узнать из по ссылке .

Пример

Рассмотрим пример того, как выглядит json —

{
«name»: «Сэм»
«возраст»: 20
«адрес»:{
«street»: «Главная улица»
«город»: «Ранчи»
}
«зарплата»: 5000
}

{ «имя»: «Сэм» «возраст»: 20 «адрес»: { «улица»: «Главная улица» «город»: «Ранчи» } «зарплата»: 5000 }

Python читает файл JSON

Теперь посмотрим, как читать файлы JSON в Python.Это не так уж сложно, и я объясню это подробно. Итак, приступим,

Создание файла JSON

Прежде всего создадим файл json. В этом файле, например, я пишу данные о сотрудниках компании. Я дал этому файлу имя employee.json .

{
«сотрудники»: [
{
«name»: «Сэм»,
«Отдел»: «HR»,
«зарплата»: 5000
},

{
«name»: «Майра»,
«Отдел»: «Продажи»,
«зарплата»: 6000
},

{
«name»: «Хишам»,
«Отдел»: «HR»,
«зарплата»: 9000

},

{
«name»: «Арш»,
«Отдел»: «Производство»,
«зарплата»: 10000

}
]
}

1 2 3 4 5 6 7 8 9 10 11 12 13 14 13 14 18 19 20 21 22 23 24 25 26 27 28 29 30 30

{ «сотрудники»: [ { «имя»: «Сэм», «Отдел»: «HR», «зарплата»: 5000 }, { «имя»: «Майра», «Отдел»: «Продажи», «зарплата»: 6000 }, { «имя»: «Хишам», » Отдел »:« HR », « зарплата »: 9000 }, { « имя »:« Арш », « Отдел »:« Производство », « зарплата » : 10000 } ] }

Здесь мы храним информацию о сотруднике, такую ​​как имя, отдел и зарплата.Теперь перейдем к части кодирования. В приведенном выше JSON сначала у нас есть объект JSON, внутри объекта у нас есть ключ с именем employee , этот ключевой сотрудник содержит массив, в котором у нас есть объекты JSON, содержащие информацию о сотрудниках. Помните, что объект JSON определяется с помощью фигурных скобок {} , а массив JSON определяется с помощью квадратных скобок [] . У нас может быть объект внутри массива и массив внутри объекта, поэтому вы можете вложить свои данные JSON в соответствии с вашими потребностями.

Создание скрипта Python

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

Загрузка файла json

Теперь нам нужно загрузить файл json в объект python. Если мы хотим загрузить файл json, мы используем метод json.load () . Для этого нам нужно сделать следующее —

импортировать json

# открыть файл
с открытым (‘сотрудник.json ‘) как f:
data = json.load (f)

# чтение файла
для emp в данных [‘сотрудники’]:
печать (жирный шрифт)

import json # открыть файл с open (’employee.json’) как f: data = json.load (f) # файл чтения для emp in данные [‘сотрудники’]: печать (жирный шрифт)

Что мы сделали?

В приведенном выше коде мы сделали следующее —

• В первой строке мы импортировали файл json.
• Чтобы сначала загрузить файл json, нам нужно открыть этот файл. с open ('employee.json') как f: откроет нужный файл. Здесь файл json существует в том же каталоге, поэтому нам не нужно указывать путь к файлу. Но если ваш файл находится в другом каталоге, вы должны указать правильный путь к файлу.
• json.load (f) используется для загрузки файла json в объект python. Он принимает аргумент, то есть имя файла.
• Теперь нам нужно прочитать данные из файла json.
• Для чтения данных мы должны запустить цикл, который будет извлекать данные из списка.
• print (emp) метод просто распечатывает данные файла json.

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

Таким образом, мы можем увидеть данные, которые хранятся в файле json. И вы можете видеть, что мы можем читать ДАННЫЕ и идентифицировать различные атрибуты данных.

Доступ к файлу JSON по нашему выбору

Очень легко получить доступ к файлу, как мы хотим.Для этого нужно применить следующие коды —

Доступ к имени сотрудника

для emp в данных [‘сотрудники’]:
print (emp [«имя»])

для emp в данных [‘сотрудники’]: print (emp [«имя»])

Таким образом, мы можем получить доступ только к имени сотрудника из json файла. Теперь вывод будет таким:

Доступ в отдел и зарплата сотрудника

для emp в данных [‘сотрудники’]:
print (emp [«Отдел»], emp [«зарплата»])

для emp в данных [‘сотрудники’]: print (emp [«Dept»], emp [«salary»])

Это будет читать отдел и зарплату каждого сотрудника.На выходе будет —

Итак, это все о Python Read JSON File Tutorial . Если есть сомнения, прокомментируйте. И, пожалуйста, поделитесь этим постом со своими друзьями, если вы считаете его полезным. Спасибо 🙂

Сохранение и загрузка данных Python с помощью JSON

Перейти к навигации

• Войти
• Зарегистрироваться

Форма поиска

Поиск

Главное меню

• Статьи
  • Контейнеры
  • DevOps
  • Игры
  • Правительство
  • Аппаратное обеспечение
    • 3D-печать
    • Arduino
    • Raspberry Pi
  • Kubernetes

    Linux

  • Kubernetes Командная строка
• OpenStack
• Программирование
  • Go
  • JavaScript
  • Python
• SysAdmin

Ресурсы

• Что такое открытый исходный код?
  • Открытый исходный код
• Проекты и приложения
• Организации
• Облачные технологии
  • Ansible
  • Большие данные
  • Наука о данных
  • Docker
  • Git
  • Java
  • Интернет вещей
  • Контейнеры Linux
  • Микросервисы
  • OpenStack
  • Python
    • Фреймворки графического интерфейса Python
    • IDE Python
    • Библиотеки шаблонов Python
    • Веб-скребки Python
  • Программно определяемые сети
  Альтернативы для виртуализации
  • to Acrobat
  • Альтернативы AutoCAD
  • Альтернативы Dreamweaver
  • Альтернативы Gmail
  • Альтернативы MATLAB
  • Альтернативы Minecraft
  • Альтернативы Google Фото
  • Альтернативы Photoshop 902 12
  • Альтернативы Publisher
  • Альтернативы Skype
  • Альтернативы Slack
  • Альтернативы Trello
  • Подробнее…
  • Linux
• Загрузки
  • Шпаргалки
    • Шпаргалка Ansible k8s
    • Шпаргалка AWK
    • Шпаргалка по Bash
    • Шпаргалка по Blender

29 Шпаргалка по C

Шпаргалка по Emac

Шпаргалка

Шпаргалка FreeDOS

Шпаргалка GIMP

Шпаргалка GNOME

Шпаргалка по макросам Groff

Шпаргалка Go

Шпаргалка по оконному менеджеру i3

Шпаргалка по Inkscape

Шпаргалка по IRC

Шпаргалка по IRC

Шпаргалка по Kubectl

Шпаргалка по общим командам Linux

Шпаргалка по правам пользователей Linux

Шпаргалка по микросервисам

Шпаргалка по сети

Шпаргалка по Pandoc

Шпаргалка по pip

Python 3.7 шпаргалка

шпаргалка Raspberry Pi

шпаргалка SELinux

шпаргалка SSH

Ежегодник с открытым исходным кодом

• 2015
• 2016
• 2017
• 2018
• Special Edition
• Special Edition
• 7 основных библиотек PyPI
• 6 удивительных способов использования Jupyter

Руководства по DevOps

• Начало преобразования DevOps
• Введение в Small Scrum Scrum
• Начало работы с DevSecOps
• Руководство по инструментам мониторинга DevOps

Руководство по инструментам мониторинга DevOps

Руководства системного администратора

• Ansible Automation for Sysadmins
• Учебник по контейнерам

Электронные книги

• Начало работы с Kubernetes
• Межпроцессное взаимодействие в Linux
• 5 инструментов для совместной работы с открытым исходным кодом 6

ized

• 7 настольных инструментов с открытым исходным кодом
• Raspberry Pi: С чего начать
• Запуск Kubernetes на Raspberry Pi

О

• Об Opensource.com
  • Добро пожаловать в сообщество Opensource.com
  • Познакомьтесь с командой
  • Создайте учетную запись
  • Правила для комментариев и обсуждений
  • Соответствующая программа
  • Часто задаваемые вопросы
• Внесите вклад в Opensource.com
  • Opensource.com руководство по стилю
  • Написание тем
• Свяжитесь с нами

Открытая организация

• Начало работы
• Книжная серия
  • Полевое руководство
  • Руководство для руководителей
  • Руководство по изменению ИТ-культуры

  Руководство для преподавателей

  • Организуйте инновации
• Ресурсы
  • Что такое открытая организация?
  • Насколько открыта ваша организация?
  • Что такое открытое решение?

• Войти
• Зарегистрироваться

• Твиттер
• Facebook
• Корм ​​

Главное меню

• Статьи
  • Контейнеры
  • DevOps
  • Игры
  • Правительство
  • Оборудование
    • 3D-печать
    • Ардуино
    • Raspberry Pi
  • Кубернетес
  • Закон
  • Linux
    • Командная строка
  • OpenStack
  • Программирование
    • Go
    • JavaScript
    • Питон
  • Системный администратор
• Ресурсы
  • Что такое открытый код?
  • Проекты и приложения
  • Организации
  • Облачные технологии
  • Альтернативы с открытым исходным кодом
  • Linux
• Загрузки
• Около
• Открытая организация
  • Начать
  • Книжная серия
  • Ресурсы
    • Что такое открытая организация?
    • Насколько открыта ваша организация?

.

No related posts.