JSON z Pythonem

Pytania do rozmowy kwalifikacyjnej na temat projektowania systemu może być tak nieograniczona, że ​​trudno jest określić właściwy sposób przygotowania. Teraz jestem w stanie złamać rundy projektowe Amazon, Microsoft i Adobe po zakupie ta książka. Codziennie poprawiaj jeden pytanie projektowe i obiecuję, że możesz złamać cały projekt.

Co to jest JSON?

JSON oznacza JavaScript Object Notation. Opiera się na składni JavaScript. Składniowo format JSON jest podobny do kodu służącego do tworzenia obiektów JavaScript. Mimo że JSON jest oparty na JavaScript, JSON różni się od JavaScript, a niektóre JavaScript są nie JSON. W tym artykule dowiemy się, jak używać JSON z Pythonem.

JSON jest całkowicie niezależnym od języka formatem tekstowym, jednocześnie wykorzystuje konwencje znane programistom z rodziny języków C, m.in. C, C++, C#, Java, JavaScript, Perl, Python, i wiele innych. Z tego powodu JSON jest uważany za idealny język wymiany danych.

Do serializacji i przesyłania danych strukturalnych przez połączenie sieciowe często używany jest format JSON. Mimo że XML jest używany w tym samym celu, używamy JSON głównie do przesyłania danych między serwerem a Aplikacja internetowa. JSON jest preferowany w stosunku do XML, ponieważ jest lekki. Więcej informacji o JSON znajdziesz na oficjalnej stronie Strona internetowa JSON.

Obiekt JSON:

Obiekt JSON wygląda podobnie do obiektów JavaScript i słowników Python. Podobnie jak obiekty JavaScript i słowniki Pythona, obiekt JSON jest również nieuporządkowanym zestawem par nazwa i wartość otoczonym nawiasami klamrowymi. Para nazwa-wartość jest reprezentowana przez nazwę w podwójnych cudzysłowach, po której następuje dwukropek i wartość.

{
"Name":"John"
}

Obiekt może również zawierać wiele par nazwa-wartość oraz par nazwa-wartość. Nazwa-wartość jest oddzielona przecinkiem.

{
  "id": "0001",
  "type": "donut",
  "name": "Cake",
  "ppu": 0.55,
  "batters":
    {
      "batter":
        [
          { "id": "1001", "type": "Regular" },
          { "id": "1002", "type": "Chocolate" },
          { "id": "1003", "type": "Blueberry" },
          { "id": "1004", "type": "Devil's Food" }
        ]
    },
  "topping":
    [
      { "id": "5001", "type": "None" },
      { "id": "5002", "type": "Glazed" },
      { "id": "5005", "type": "Sugar" },
      { "id": "5007", "type": "Powdered Sugar" },
      { "id": "5006", "type": "Chocolate with Sprinkles" },
      { "id": "5003", "type": "Chocolate" },
      { "id": "5004", "type": "Maple" }
    ]
}

JSON obsługuje również typy danych jak liczby, ciągi, listy i obiekty.

JSON z Pythonem:

Zacznijmy rozumieć, jak dane JSON w Pythonie z kilkoma przykładami kodu. Python ma wbudowany pakiet json, którego możemy używać do pracy z danymi JSON. Aby skorzystać z tego pakietu, musimy zaimportować json w naszym skrypcie Pythona.

import json

Serializacja i deserializacja:

Proces konwertowania danych JSON na serię bajtów, które mają być przechowywane w pamięci lub udostępniane w sieci, nazywa się kodowaniem. Serializacja to proces kodowania danych JSON.

Odwrotnym procesem serializacji jest Deserializacja. Proces dekodowania danych nazywa się Deserializacją.

Mówiąc prościej, możemy powiedzieć, że serializacja i deserializacja oznaczają zapisywanie i odczytywanie danych do pamięci. Kodowanie służy do zapisywania danych, podczas gdy dekodowanie służy do odczytywania danych.

Serializacja danych JSON:

Wbudowany pakiet json Pythona udostępnia metody dump() i dumps() do konwertowania obiektów Pythona na JSON. Zobaczmy różnicę między tymi dwiema metodami:

wysypisko() depresja()
dump() konwertuje obiekty Pythona na obiekty JSON i zapisuje je do pliku. Aby przekonwertować obiekt Pythona na ciąg znaków JSON, używana jest funkcja dumps()
Plik wyjściowy, w którym mają być przechowywane dane, musi być przekazany jako argument Nazwa pliku nie jest wymagana
Szybciej niż zrzuty() Wolniej niż dump()

Poniższa tabela wyjaśnia, w jaki sposób obiekty Pythona są konwertowane na równoważne obiekty JSON.

Obiekt Pythona Równoważny obiekt JSON
Dykt przedmiot
Lista Szyk
Krotka Szyk
str sznur
int Numer
unosić się Numer
Prawdziwy prawdziwy
Fałszywy fałszywy
żaden zero

dump() przykład:

Zobaczmy przykład, jak przekonwertować obiekt Pythona na obiekt JSON i zapisać go do pliku za pomocą metody dump(). To są nasze dane Pythona

python_data=
    {
      "batter":
        [
          { "id": "1001", "type": "Regular" },
          { "id": "1002", "type": "Chocolate" },
          { "id": "1003", "type": "Blueberry" },
          { "id": "1004", "type": "Devil's Food" }
        ]
    }

A kod Pythona to:

with open('Data_file.json','w') as filename:
    json.dump(python_data,filename)

dump() przyjmuje dwa argumenty:

  • python_data
  • filename-Data_file.json, który jest plikiem wyjściowym, w którym ma być przechowywany obiekt JSON.

dumps() przykład:

Metoda dumps() konwertuje obiekt Pythona na ciąg JSON.

json_string=json.dumps(python_data)

Tutaj nie przekazujemy innego argumentu nazwa pliku, jak to zrobiliśmy w dump(), co nie jest wymagane.

Argumenty słów kluczowych dla dump() i dumps():

akapit:

Chociaż JSON jest łatwy do odczytania, staje się jeszcze łatwiejszy do odczytania po prawidłowym sformatowaniu. Możesz użyć dodatkowego argumentu słowa kluczowego o nazwie indent, aby zmienić wcięcie dla struktur zagnieżdżonych. Wykonaj poniższy kod i zwróć uwagę na różnicę w formacie przy użyciu wcięcia.

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

separator:

Jest jeszcze jeden argument słowa kluczowego, którego możemy użyć do zmiany formatowania, to separatory. Separator jest krotką (element_separator, klucz_separator). Wartość domyślna to (', ',': '). Aby uzyskać najbardziej kompaktowy JSON, użyj (',',':'), co eliminuje odstępy.

print(json.dumps(python_data))
print(json.dumps(python_data,separators=(',',':')))

Patrz: docs dla dodatkowej listy argumentów słów kluczowych.

Deserializacja danych JSON:

Deserializacja konwertuje obiekty JSON na ich odpowiednie obiekty Python. Możemy użyć load() i load() do deserializacji.

load() pobiera swoje dane z pliku, podczas gdy load() pobiera swoje dane z obiektu string.

Poniżej stoły wyjaśnia, w jaki sposób obiekty JSON są konwertowane na odpowiednie obiekty Pythona:

Obiekt JSON Obiekt Pythona
przedmiot DICT
szyk podstęp
ciąg str
zero żaden
liczba (wew.) int
liczba (rzeczywista) unosić się
prawdziwy Prawdziwy
fałszywy Fałszywy

Ta tabela nie jest dokładnym przeciwieństwem tabeli, którą widzieliśmy w serializacji. Dzieje się tak, ponieważ kiedy kodujemy obiekt, możemy nie odzyskać tego samego obiektu po dekodowaniu.

Sprawdź poniższy przykład, kodujemy krotkę. Odpowiednikiem krotki obiektu JSON jest tablica. Dekodowanie tablicy daje listę. Tak więc kodowanie i dekodowanie krotki daje w wyniku listę.

import json

input_data=('a','b',1,2,3)
encoded_data=json.dumps(input_data)
decoded_data=json.loads(encoded_data)
print(input_data==decoded_data)
print(type(input_data))
print(type(decoded_data))
print(input_data==tuple(decoded_data))

Przykład load():

Metoda load() konwertuje obiekt JSON na obiekt Pythona i pobiera dane wejściowe z pliku. Pamiętaj, że podczas serializacji danych utworzyliśmy plik Data_file.json. Użyjmy tutaj tego samego pliku.

import json

with open('Data_file.json','r') as filename:
    data=json.load(filename)

print(data)

Jeśli tego nie zrobisz rodzaj danych ładujesz, pamiętaj, że typem danych wynikowych może być wszystko, co znajduje się w tabeli konwersji.

load() przykład:

load() pobiera dane wejściowe z łańcucha zamiast z pliku.

import json

json_data="""
{
      "batter":
        [
          { "id": "1001", "type": "Regular" },
          { "id": "1002", "type": "Chocolate" },
          { "id": "1003", "type": "Blueberry" },
          { "id": "1004", "type": "Devil's Food" }
        ]
    }
"""

print(json.loads(json_data))

Przykład w czasie rzeczywistym:

Aby ćwiczyć, użyjmy JSON Symbol zastępczy, który zawiera przykładowe dane JSON. Możemy uzyskać dane z usługi JSONPlaceholder wysyłając do niej żądanie API. Python dostarcza wbudowany pakiet o nazwie 'requests', którego możemy użyć do wywołania API.

Utwórz plik Pythona o wybranej przez siebie nazwie i dowolnym miejscu, a następnie zaimportuj poniższe pakiety.

import json
import requests

Musimy wysłać żądanie API do usługi JSONPlaceholder dla punktu końcowego /todos. Gdy wywołanie API się powiedzie, otrzymamy 200 jako kod statusu.

response = requests.get("https://jsonplaceholder.typicode.com/todos")
print(response.status_code)

Aby zdeserializować atrybut text obiektu odpowiedzi, możemy użyć metody json.loads lub json(). Jak widzieliśmy powyżej, loady to funkcja json, która może być używana nie tylko do parsowania danych łańcuchowych, ale także do użycia z kontekstem żądań.

response = requests.get("https://jsonplaceholder.typicode.com/todos")
print(json.loads(response.text))

.json to metoda klasy request.models.Response. Zwraca dane json z odpowiedzi na żądanie.

response = requests.get("https://jsonplaceholder.typicode.com/todos")
print(response.json())

Dane wyjściowe json.loads i .json są jednak takie same.

response = requests.get("https://jsonplaceholder.typicode.com/todos")
print(response.json()==json.loads(response.text))

Jeśli trudno jest przeskakiwać między plikiem Pythona a terminalem za każdym razem, gdy zmieniasz kod, wygodnie jest uruchomić skrypt w trybie interaktywnym. Możesz uruchomić w trybie interaktywnym, używając -i podczas uruchamiania skryptu. Zaletą jest nie tylko uruchamianie skryptu, ale także możliwość dostęp do wszystkich danych ze skryptu w samym terminalu.

PS C:\Users\Gopi\Desktop\backup\myPython\freelancer> python -i code1.py
>>> json.loads(response.text)==response.json()
True
>>> response.status_code
200

Metoda response.json() zwraca listę. Możesz wykonać wszystkie operacje na liście ze zwróconym elementem.

response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos=response.json()
print(type(todos))
print(todos[10])

Drukujemy losowe elementy, aby zorientować się, jak wygląda przedmiot do zrobienia. Możesz również wyświetlić element, odwiedzając punkt końcowy w przeglądarce.

{
  'userId': 1, 
  'id': 11, 
  'title': 'vero rerum temporibus dolor', 
  'completed': True
}

JSON z Pythonemszpilka

Znajdź użytkowników, którzy ukończyli maksymalną liczbę rzeczy do zrobienia:

Jeśli przyjrzysz się danym, zobaczysz, że jest wielu użytkowników, z których każdy ma unikalny identyfikator użytkownika, a każdy element do zrobienia ma właściwość o nazwie „zakończono”. Dowiedzmy się, którzy użytkownicy wykonali maksymalne zadania.

import requests

todos_completed_by_each_user={}

response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos = response.json()

for todo in todos:
    if todo['completed']:
        try:
            todos_completed_by_each_user[todo['userId']]+=1
        except KeyError:
            todos_completed_by_each_user[todo['userId']]=1

#sorting the dictionary based on maximum completed todos in

Odwrotna kolejność

max_todos_by_user = sorted(todos_completed_by_each_user.items(),
                   key=lambda x: x[1], reverse=True)

#Gets the

maksymalny numer

 of todos completed
max_todos = max_todos_by_user[0][1]

users=[]

#Gets the list of users who have completed the maximum todos
for user,no_of_todos in max_todos_by_user:
    if no_of_todos<max_todos:
        continue
    users.append(str(user))

max_users = " and ".join(users)
print(max_users)

Teraz mamy listę użytkowników, którzy ukończyli maksymalny numer rzeczy do zrobienia. Spróbujmy w ładny sposób wydrukować wyjście.

s='s' if len(users)>1 else ""
print(f'User{s} {max_users} completed {max_todos} TODOs')

Wynik będzie wyglądał następująco:

Users 5 and 10 and 8 completed 12 TODOs

Teraz utwórzmy plik json o nazwie „completed_todos.json”, który zawiera ukończone zadania dla użytkowników, którzy ukończyli maksymalny numer rzeczy do zrobienia.

def filtered_todos(todo):
    has_max_count = str(todo["userId"]) in users
    is_complete = todo["completed"]
    return is_complete and has_max_count

# Write filtered TODOs to file.
with open("filtered_todos.json", "w") as data_file:
    filtered_todos = list(filter(filtered_todos, todos))
    json.dump(filtered_todos, data_file, indent=2)

Jeśli nie znasz metody filter(), metoda filter() filtruje sekwencję za pomocą funkcji, która sprawdza, czy każdy element sekwencji jest prawdziwy lub fałszywy.

Tutaj metoda filter() wykorzystuje funkcję o nazwie filter_todos(), która sprawdza, czy identyfikator użytkownika jest obecny na liście użytkowników, którzy wykonali maksymalną liczbę rzeczy do zrobienia, a także sprawdza, czy dla danego użytkownika zostało wykonane zadanie. Jeśli oba warunki są spełnione, zapisujemy to zadanie w naszym pliku wyjściowym za pomocą metody dump().

Plik wyjściowy „completed_todos.json” zawiera tylko ukończoną listę rzeczy do zrobienia dla użytkowników, którzy ukończyli maksymalną liczbę rzeczy do zrobienia.

Serializacja i deserializacja niestandardowych obiektów Pythona:

Stwórzmy własny niestandardowy obiekt Pythona.

class EmployeeDetails:
    def __init__(self,firstname,lastname,age):
        self.firstname = firstname
        self.lastname = lastname
        self.age=age

    def get_name(self):
        return self.firstname+' '+self.lastname

emp=EmployeeDetails('John','Terry',29)
emp_name=emp.get_name()

Tworzymy klasę o nazwie EmployeeDetails oraz metodę zwracającą imię i nazwisko pracownika. Stwórzmy dla niego obiekt.

Teraz spróbuj zserializować zmienną emp_name i zobacz, co się stanie.

PS C:\Users\Gopi\Desktop\backup\myPython\freelancer> python -i sample.py
John Terry
>>> json.dumps(emp_name)
'"John Terry"'

Nie napotykamy żadnych problemów podczas próby serializacji nazwy emp_name, która jest typu string. Zobacz, co się stanie, gdy spróbujemy serializować utworzony przez nas niestandardowy obiekt Pythona emp.

>>> json.dumps(emp)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\__init__.py", line 231, in dumps
    return _default_encoder.encode(obj)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 199, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 257, in iterencode
    return _iterencode(o, 0)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 180, in default
    o.__class__.__name__)
TypeError: Object of type 'EmployeeDetails' is not JSON serializable

Otrzymujemy komunikat o błędzie „EmployeeDetails” nie jest możliwy do serializacji w formacie JSON. Mimo że możemy zakodować większość wbudowanych typów danych Pythona, moduł json nie wie, jak serializować niestandardowe obiekty Pythona.

Uproszczenie struktur danych:

Zamiast próbować kodować obiekt niestandardowy bezpośrednio, możemy przekonwertować obiekt niestandardowy na inną reprezentację, którą rozumie moduł json, a następnie przekonwertować go do formatu JSON.

Zrozummy, jak to działa na przykładzie. Do reprezentowania liczb zespolonych Python zapewnia wbudowaną typ danych "złożony". Liczba zespolona jest wyrażona w formacie a+bj, gdzie „a” to część rzeczywista, a „b” to część urojona.

>>> import json
>>> z=2+5j
>>> type(z)
<class 'complex'>
>>> json.dumps(z)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\__init__.py", line 231, in dumps
    return _default_encoder.encode(obj)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 199, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 257, in iterencode
    return _iterencode(o, 0)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 180, in default
    o.__class__.__name__)
TypeError: Object of type 'complex' is not JSON serializable

Ponieważ liczby zespolone nie podlegają serializacji w formacie JSON, spróbujmy przekonwertować liczbę zespoloną na format zrozumiały dla modułu json.

Aby utworzyć liczbę zespoloną, potrzebujemy tylko części rzeczywistej i części urojonej.

>>> z.real
2.0
>>> z.imag
5.0

Kiedy przekażemy część rzeczywistą i urojoną złożonemu konstruktorowi, otrzymamy liczbę zespoloną.

>>> complex(2,5)==z
True

Ważne jest, aby zrozumieć, jak przełamać zwyczaj typ danych do jego podstawowych składników w celu jego serializacji i deserializacji.

Kodowanie niestandardowych typów danych:

Teraz mamy wszystkie niezbędne składniki do utworzenia liczby zespolonej. Aby przekonwertować liczbę zespoloną na JSON, możemy stworzyć własną funkcję kodującą i przekazać ją do metody dump().

Poniżej znajduje się metoda, której możemy użyć do kodowania liczb zespolonych. Oprócz liczb zespolonych, jeśli przekażemy inne niestandardowe typy danych jako dane wejściowe do funkcji, zwróci błąd typu.

def encode_complex_numbers(z):
    if isinstance(z,complex):
        return (z.real,z.imag)
    else:
        type_name=z.__class__.__name__
        raise TypeError(f'Object of type {type_name} is not JSON serializable')

Za każdym razem, gdy spróbujemy przekonwertować niestandardowy typ danych, który nie jest możliwy do serializacji w formacie JSON, zostanie wywołana nasza funkcja kodowania.

>>> json.dumps(2+5j,default=encode_complex_numbers)
'[2.0, 5.0]'
>>> json.dumps(emp,default=encode_complex_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\__init__.py", line 238, in dumps
    **kw).encode(obj)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 199, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "C:\Users\Gopi\AppData\Local\Programs\Python\Python36-32\lib\json\encoder.py", line 257, in iterencode
    return _iterencode(o, 0)
  File "sample.py", line 18, in encode_complex_numbers
    raise TypeError(f'Object of type {type_name} is not JSON serializable')
TypeError: Object of type EmployeeDetails is not JSON serializable

Zauważ, że teraz możemy serializować liczby zespolone za pomocą naszej funkcji 'encode_complex_numbers'. W przypadku innych niestandardowych typów danych otrzymamy błąd typu. Możesz otrzymać pytanie, skąd wiemy, że błąd jest drukowany z naszego kodu. Zwróć uwagę na podświetloną linię, próbka to nazwa pliku, w którym obecna jest moja funkcja kodowania, w tym miejscu zobaczysz swoją nazwę pliku. Jest wywoływana zamiast metody default().

Kolejną rzeczą, na którą warto zwrócić uwagę, jest to, że zwracamy część rzeczywistą i urojoną liczby zespolonej w krotce, którą rozumie moduł json.

Zamiast zastępować metodę default(), alternatywnym podejściem jest utworzenie podklasy o nazwie „ComplexEncoder” w ramach standardowej klasy JSONEncoder.

class ComplexEncoder(json.JSONEncoder):
    def default(self,z):
        if isinstance(z,complex):
            return (z.real,z.imag)
        else:
            return super().default(z)

My nie jesteśmy obsługa błędu typu w kodzie pozwalamy, aby obsłużyła go klasa bazowa. Teraz mamy dwie opcje kodowania liczb zespolonych. Używamy klasy ComplexEncoder w metodzie dump() lub możemy stworzyć dla niej obiekt i wywołać metodę encode().

>>> json.dumps(2+5j,cls=ComplexEncoder)
'[2.0, 5.0]'
>>> encoder=ComplexEncoder()
>>> encoder.encode(2+5j)
'[2.0, 5.0]'

Dekodowanie niestandardowych typów danych:

Nawet jeśli mamy liczby rzeczywiste i urojone liczby zespolonej, czy wystarczy odtworzyć liczbę zespoloną? Nie, zobaczmy, kiedy zdekodujemy dane wyjściowe naszej funkcji kodowania, co otrzymamy w zamian.

>>> json_format=json.dumps(2+5j,cls=ComplexEncoder)
>>> json.loads(json_format)
[2.0, 5.0]

To, co musimy otrzymać, to liczba zespolona, ​​ale tak naprawdę otrzymaliśmy tylko listę. Jeśli musimy odtworzyć liczbę zespoloną, musimy przekazać wartości do konstruktora zespolonego. To, czego przegapiliśmy, to metadane.

Zrozumienie metadanych:

Metadane oznaczają minimalną ilość informacji, która jest wystarczająca i niezbędna do odtworzenia obiektu.

Moduł json chce, aby wszystkie niestandardowe typy danych były reprezentowane w zrozumiałym formacie. Utwórzmy plik o nazwie complex_data.json i dodajmy wszystkie informacje o metadanych. Poniższy obiekt, który reprezentuje liczbę zespoloną, jest informacją o metadanych, dodaj ją do pliku.

{
    "__complex__": true,
    "real": 2,
    "imag": 5
}

Tutaj kluczem __kompleks__ są metadane, których szukamy. Przypisujesz dowolną wartość do klucza __complex__, to nie ma znaczenia. Jedyne, co zrobimy, to zweryfikujemy, czy klucz istnieje.

def decode_complex_number(dct):
    if '__complex__' in dct:
        return complex(dct['real'],dct['imag'])
    return dct

Piszemy własną funkcję do dekodowania liczby zespolonej, tak jak robiliśmy to przy kodowaniu. W przypadku innych niestandardowych typów danych pozwalamy na obsługę domyślnego dekodera.

Za każdym razem, gdy wywoływana jest metoda load(), chcemy, aby nasz własny dekoder dekodował dane, zamiast pozwalać na obsługę dekodera podstawowego. Aby to osiągnąć, musimy przekazać naszą funkcję dekodującą do parametru object_hook.

with open('complex_data.json','r') as data_file:
    data = data_file.read()
    z=json.loads(data,object_hook=decode_complex_number)

Wyjście będzie:

>>> z
(2+5j)
>>> type(z)
<class 'complex'>

Object_hook jest podobny do domyślnej metody dumps(). Jeśli masz więcej niż jedną liczbę zespoloną, możesz dodać ją również do pliku complex_data.json i ponownie uruchomić kod.

[
  {
      "__complex__": true,
      "real": 2,
      "imag": 5
  },
  {
      "__complex__": true,
      "real": 7,
      "imag": 10
  },
  {
      "__complex__": true,
      "real": 13,
      "imag": 15
  }
]

Teraz naszym wynikiem będzie lista liczb zespolonych.

>>> z
[(2+5j), (7+10j), (13+15j)]

Podobnie jak dodaliśmy własną klasę kodera pod klasą JSONEncoder, możemy mieć własną klasę dekodera pod klasą JSONDecoder zamiast zastępować obiekt_hook.

class ComplexDecoder(json.JSONDecoder):
    def __init__(self,*args,**kwargs):
        super().__init__(object_hook=self.object_hook, *args, **kwargs)
    def object_hook(self,dct):
        if '__complex__' in dct:
            return complex(dct['real'],dct['imag'])
        else:
            return super().decode(dct)

with open('complex_data.json','r') as data_file:
    data = data_file.read()
    z=json.loads(data,cls=ComplexDecoder)
    print(z)

Wnioski:

O JSON z Pythonem przeczytaliśmy w tym artykule. Spróbujmy zapamiętać ważne punkty z tego, czego się do tej pory dowiedzieliśmy.

  • Zaimportuj wbudowany pakiet json
  • Odczytaj dane za pomocą load lub load()
  • Przetwarzaj dane
  • Napisz przetworzone w za pomocą dump() lub dumps()
  • Jeśli obsługujesz niestandardowy typ danych, pobierz metadane i napisz własny dekoder i koder, aby odczytywać i zapisywać dane.
Wywiady dotyczące projektowania systemu pękania
Translate »