파이썬을 사용한 JSON

시스템 설계 면접 질문 너무 개방적이어서 올바른 준비 방법을 알기가 너무 어렵습니다. 이제 구매 후 Amazon, Microsoft 및 Adobe의 디자인 라운드를 해독할 수 있습니다. 이 책은. 매일 수정 하나 디자인 질문 그리고 나는 당신이 디자인 라운드를 깨뜨릴 수 있다고 약속합니다.

JSON이란 무엇입니까?

JSON은 JavaScript Object Notation의 약자입니다. JavaScript 구문을 기반으로 합니다. 구문적으로 JSON 형식은 JavaScript 객체를 생성하기 위한 코드와 유사합니다. JSON은 Javascript를 기반으로 하지만 JSON은 Javascript와 구별되며 일부 JavaScript는 지원 JSON. 이 기사에서는 Python에서 JSON을 사용하는 방법에 대해 알아봅니다.

JSON은 완전히 언어 독립적인 텍스트 형식이며 동시에 C, C++, C#, Java, JavaScript, Perl, Python, 그리고 많은 다른 사람들. 이 때문에 JSON은 이상적인 데이터 교환 언어로 간주됩니다.

네트워크 연결을 통해 구조화된 데이터를 직렬화하고 전송하기 위해 JSON이 자주 사용됩니다. XML은 같은 용도로 사용되지만 주로 서버와 서버 간의 데이터 전송에 JSON을 사용합니다. 웹 애플리케이션. JSON은 가볍기 때문에 XML보다 선호됩니다. 공식에서 JSON에 대한 자세한 정보를 확인할 수 있습니다. JSON 웹사이트.

JSON 객체:

JSON 객체는 JavaScript 객체 및 Python 사전과 유사합니다. JavaScript 객체 및 Python 사전과 마찬가지로 JSON 객체도 중괄호로 둘러싸인 정렬되지 않은 이름 및 값 쌍의 집합입니다. 이름-값 쌍은 큰따옴표로 묶인 이름, 콜론, 값으로 표시됩니다.

{
"Name":"John"
}

개체에는 여러 이름-값 쌍과 이름-값 쌍도 포함될 수 있습니다. 이름-값은 쉼표로 구분됩니다.

{
  "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도 지원 데이터 유형 숫자, 문자열, 목록 및 개체와 같은.

Python을 사용한 JSON:

몇 가지 코드 예제를 통해 Python에서 JSON 데이터를 사용하는 방법을 이해해 보겠습니다. Python은 JSON 데이터 작업에 사용할 수 있는 내장 json 패키지와 함께 제공됩니다. 이 패키지를 사용하려면 Python 스크립트에서 json을 가져와야 합니다.

import json

직렬화 및 역직렬화:

JSON 데이터를 일련의 바이트로 변환하여 메모리에 저장하거나 네트워크에서 공유하는 프로세스를 인코딩이라고 합니다. 직렬화는 JSON 데이터를 인코딩하는 프로세스입니다.

직렬화의 역 과정은 역직렬화입니다. 데이터를 디코딩하는 프로세스를 Deserialization이라고 합니다.

간단히 말해서 직렬화와 역직렬화는 데이터를 메모리에 쓰고 읽는 것을 의미합니다. 인코딩은 데이터 쓰기를 위한 것이고 디코딩은 데이터 읽기를 위한 것입니다.

JSON 데이터 직렬화:

Python의 내장 json 패키지는 Python 객체를 JSON으로 변환하기 위한 dump() 및 dumps() 메서드를 제공합니다. 이 두 가지 방법의 차이점을 살펴보겠습니다.

덤프() 우울()
dump()는 Python 객체를 JSON 객체로 변환하고 파일에 씁니다. Python 객체를 JSON 문자열로 변환하려면 dumps()가 사용됩니다.
데이터가 저장될 출력 파일은 인수로 전달되어야 합니다. 파일 이름은 필요하지 않습니다
dumps()보다 빠름 dump()보다 느림

아래 표는 Python 객체가 동등한 JSON 객체로 변환되는 방법을 설명합니다.

파이썬 객체 동등한 JSON 객체
딕셔너리 목적
명부 배열
튜플 배열
하위 버전
INT 번호
뜨다 번호
참된 참된
거짓 그릇된
없음 null로

덤프() 예제:

파이썬 객체를 JSON 객체로 변환하고 dump() 메서드를 사용하여 파일에 저장하는 예를 살펴보겠습니다. 이것은 우리의 파이썬 데이터입니다

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

그리고 파이썬 코드는 다음과 같습니다:

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

dump()는 두 개의 인수를 취합니다.

  • 파이썬_데이터
  • filename-Data_file.json, JSON 객체가 저장될 출력 파일입니다.

dumps() 예:

dumps() 메서드는 Python 객체를 JSON 문자열로 변환합니다.

json_string=json.dumps(python_data)

여기서 우리는 필요하지 않은 dump()에서 했던 것처럼 다른 인수 파일 이름을 전달하지 않습니다.

dump() 및 dumps()에 대한 키워드 인수:

톱니 모양:

JSON은 읽기 쉽지만 올바르게 형식화되면 읽기가 훨씬 더 쉬워집니다. indent라는 추가 키워드 인수를 사용하여 중첩 구조의 들여쓰기를 변경할 수 있습니다. 아래 코드를 실행하여 들여쓰기를 사용한 형식의 차이를 확인하세요.

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

분리 기호:

형식을 변경하는 데 사용할 수 있는 또 다른 키워드 인수는 구분 기호입니다. 구분자는 (item_separator, key_separator) 튜플입니다. 기본값은 (', ',': ')입니다. 가장 간결한 JSON을 얻으려면 공백을 제거하는 (',',':')를 사용하십시오.

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

자세한 내용은 문서 키워드 인수의 추가 목록을 보려면

JSON 데이터 역직렬화:

역직렬화는 JSON 개체를 해당 Python 개체로 변환합니다. 역직렬화를 위해 load() 및 load()를 사용할 수 있습니다.

load()는 파일에서 데이터를 가져오는 반면 load()는 문자열 객체에서 데이터를 가져옵니다.

아래의 테이블 JSON 객체가 각각의 Python 객체로 변환되는 방법을 설명합니다.

JSON 객체 파이썬 객체
대상 딕셔너리
정렬 명부
하위 버전
null로 없음
숫자(int) INT
숫자(실수) 뜨다
참된 참된
그릇된 거짓

이 테이블은 직렬화에서 본 테이블과 정확히 반대가 아닙니다. 객체를 인코딩할 때 디코딩 후 동일한 객체를 다시 얻지 못할 수 있기 때문입니다.

아래 예를 확인하십시오. 우리는 튜플을 인코딩하고 있습니다. JSON 객체에 해당하는 튜플은 배열입니다. 배열을 디코딩하면 목록이 제공됩니다. 따라서 튜플을 인코딩 및 디코딩하면 목록이 생성됩니다.

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))

load() 예제:

load() 메서드는 JSON 개체를 Python 개체로 변환하고 파일에서 입력을 가져옵니다. 데이터를 직렬화하는 동안 Data_file.json을 생성했음을 기억하십시오. 여기에서 같은 파일을 사용합시다.

import json

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

print(data)

그렇지 않은 경우 데이터의 유형 로드할 때 결과 데이터의 유형은 변환 테이블에 있는 모든 유형이 될 수 있음을 기억하십시오.

load() 예제:

load()는 파일 대신 문자열에서 입력을 가져옵니다.

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))

실시간 예:

연습하기 위해 사용하자 JSON자리 표시자, 샘플 JSON 데이터를 제공합니다. API 요청을 통해 JSONPlaceholder 서비스에서 데이터를 가져올 수 있습니다. Python은 API 호출에 사용할 수 있는 '요청'이라는 내장 패키지를 제공합니다.

원하는 이름과 원하는 위치에 Python 파일을 만들고 아래 패키지를 가져옵니다.

import json
import requests

/todos 엔드포인트에 대한 JSONPlaceholder 서비스에 API 요청을 해야 합니다. API 호출이 성공하면 상태 코드로 200이 표시됩니다.

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

응답 객체의 텍스트 속성을 역직렬화하려면 json.loads 또는 json() 메서드를 사용할 수 있습니다. 위에서 보았듯이 로드는 json 함수로, 문자열 데이터를 구문 분석할 뿐만 아니라 요청 컨텍스트와 함께 사용할 수도 있습니다.

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

.json은 requests.models.Response 클래스의 메소드입니다. 요청 응답에서 json 데이터를 반환합니다.

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

json.loads와 .json의 출력은 동일합니다.

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

코드를 변경할 때마다 Python 파일과 터미널 사이를 이동하는 것이 어렵다면 대화형 모드에서 스크립트를 실행하는 것이 편리합니다. 스크립트를 실행할 때 -i를 사용하여 대화식 모드로 실행할 수 있습니다. 장점은 스크립트를 실행할 뿐만 아니라 모든 데이터에 액세스 터미널 자체의 스크립트에서.

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

response.json() 메서드는 목록을 반환합니다. 반환된 항목으로 모든 목록 작업을 수행할 수 있습니다.

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

우리는 할 일 항목이 어떻게 생겼는지 아이디어를 얻기 위해 임의의 항목을 인쇄하고 있습니다. 브라우저에서 끝점을 방문하여 항목을 볼 수도 있습니다.

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

파이썬을 사용한 JSON

최대 할일을 완료한 사용자 찾기:

데이터를 보면 고유한 사용자 ID를 가진 여러 사용자가 있고 각 할 일 항목에는 '완료됨'이라는 속성이 있습니다. 어떤 사용자가 최대 작업을 완료했는지 알아봅시다.

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

역순으로

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

#Gets the

최대 수

 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)

이제 완료한 사용자 목록이 있습니다. 최대 수 할일의. 출력물을 멋진 방식으로 인쇄해 봅시다.

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

출력은 다음과 같습니다.

Users 5 and 10 and 8 completed 12 TODOs

이제 완료한 사용자의 완료된 할일을 포함하는 "completed_todos.json"이라는 json 파일을 생성해 보겠습니다. 최대 수 할일의.

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)

filter() 메서드를 모르는 경우 filter() 메서드는 시퀀스의 각 요소가 true 또는 false인지 확인하는 함수의 도움으로 시퀀스를 필터링합니다.

여기에서 filter() 메서드는 Filtered_todos()라는 함수를 사용하는데, 이 함수는 최대 할 일을 완료한 사용자 목록에 사용자 ID가 있는지 확인하고 해당 사용자에 대해 할 일을 완료했는지도 확인합니다. 두 조건이 모두 참이면 dump() 메서드를 사용하여 출력 파일에 해당 할 일을 작성합니다.

"completed_todos.json" 출력 파일에는 최대 할일을 완료한 사용자의 완료된 할일 목록만 포함됩니다.

사용자 정의 Python 객체 직렬화 및 역직렬화:

우리만의 커스텀 파이썬 객체를 만들어 봅시다.

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()

EmployeeDetails라는 클래스와 직원의 이름을 반환하는 메서드를 만들고 있습니다. 이를 위한 객체를 생성해 보겠습니다.

이제 emp_name 변수를 직렬화하고 무슨 일이 일어나는지 보십시오.

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

문자열 유형인 emp_name을 직렬화하려고 할 때 문제가 발생하지 않습니다. 우리가 만든 커스텀 파이썬 객체 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

"EmployeeDetails"가 JSON 직렬화 불가능 오류가 발생합니다. 대부분의 파이썬 내장 데이터 유형을 인코딩할 수 있지만 json 모듈은 사용자 정의 파이썬 객체를 직렬화하는 방법을 모릅니다.

데이터 구조 단순화:

사용자 정의 개체를 직접 인코딩하는 대신 사용자 정의 개체를 json 모듈이 이해하는 다른 표현으로 변환한 다음 이를 JSON으로 변환할 수 있습니다.

예제의 도움으로 어떻게 작동하는지 이해합시다. 복소수를 나타내기 위해 Python은 내장된 데이터 형식 "복잡한". 복소수는 a+bj 형식으로 표현되며, 여기서 'a'는 실수부이고 'b'는 허수부입니다.

>>> 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

복소수는 JSON 직렬화가 불가능하므로 복소수 is를 json 모듈이 이해할 수 있는 형식으로 변환해 보겠습니다.

복소수를 생성하려면 실수부와 허수부만 있으면 됩니다.

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

복소수 생성자에 실수부와 허수부를 전달하면 복소수가 나옵니다.

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

관습을 깨는 방법을 이해하는 것이 중요합니다 데이터 형식 직렬화 및 역직렬화를 위해 필수 구성 요소로 이동합니다.

인코딩 사용자 정의 데이터 유형:

이제 복소수를 형성하는 데 필요한 모든 구성 요소가 있습니다. 복소수를 JSON으로 변환하기 위해 우리가 할 수 있는 일은 우리 자신의 인코딩 함수를 생성하고 그것을 dump() 메소드에 전달하는 것입니다.

다음은 복소수를 인코딩하는 데 사용할 수 있는 방법입니다. 복소수를 제외하고 다른 사용자 정의 데이터 유형을 함수에 대한 입력으로 전달하면 유형 오류가 발생합니다.

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')

JSON 직렬화 가능하지 않은 사용자 정의 데이터 유형을 변환하려고 할 때마다 인코딩 함수가 호출됩니다.

>>> 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

이제 'encode_complex_numbers' 함수를 사용하여 복소수를 직렬화할 수 있습니다. 다른 사용자 정의 데이터 유형의 경우 유형 오류가 발생합니다. 우리 코드에서 오류가 인쇄되었는지 어떻게 알 수 있는지에 대한 질문을 받을 수 있습니다. 강조 표시된 라인을 주목하세요. 샘플은 내 인코딩 기능이 있는 파일 이름입니다. 그 위치에 파일 이름이 표시됩니다. default() 메서드 대신 호출됩니다.

또한 주목해야 할 또 다른 사항은 json 모듈이 이해하는 튜플에서 복소수의 실수 부분과 허수 부분을 반환한다는 것입니다.

default() 메서드를 재정의하는 대신 표준 클래스 JSONEncoder 아래에 'ComplexEncoder'라는 하위 클래스를 만드는 다른 방법이 있습니다.

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

우리는하지 않습니다 유형 오류 처리 코드에서 우리는 기본 클래스가 그것을 처리하도록 합니다. 이제 복소수를 인코딩하는 두 가지 옵션이 있습니다. 우리는 dump() 메소드에서 ComplexEncoder 클래스를 사용하거나 그것에 대한 객체를 생성하고 encode() 메소드를 호출할 수 있습니다.

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

사용자 정의 데이터 유형 디코딩:

복소수의 실수와 허수가 있어도 복소수를 재생성하는 것으로 충분합니까? 아니요, 인코딩 함수의 출력을 디코딩할 때 반환되는 결과를 보겠습니다.

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

우리가 얻어야 하는 것은 복소수지만 실제로 얻은 것은 목록일 뿐입니다. 복소수를 다시 만들어야 하는 경우 값을 복소수 생성자에 전달해야 합니다. 우리가 놓친 것은 메타데이터입니다.

메타데이터 이해하기:

메타데이터는 개체를 재생성하는 데 충분하고 필요한 최소한의 정보를 의미합니다.

json 모듈은 모든 사용자 정의 데이터 유형이 이해할 수 있는 형식으로 표현되기를 원합니다. complex_data.json이라는 파일을 생성하고 모든 메타데이터 정보를 추가해 봅시다. 복소수를 나타내는 다음 객체는 메타데이터 정보이며 파일에 추가합니다.

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

여기서 __complex__ 키가 우리가 찾고 있는 메타데이터입니다. __complex__ 키에 값을 할당해도 상관 없습니다. 우리가 할 일은 키가 존재하는지 확인하는 것뿐입니다.

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

우리는 인코딩에서 했던 것처럼 복소수를 디코딩하기 위해 자체 함수를 작성하고 있습니다. 다른 사용자 정의 데이터 유형의 경우 기본 디코더가 처리하도록 합니다.

load() 메서드가 호출될 때마다 기본 디코더가 처리하도록 하는 대신 자체 디코더가 데이터를 디코딩하기를 원합니다. 이를 달성하려면 디코딩 기능이 object_hook 매개변수에 전달되어야 합니다.

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

출력은 다음과 같습니다

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

object_hook은 dumps()의 기본 메소드와 유사합니다. 복소수가 두 개 이상인 경우 이를 complex_data.json에도 추가하고 코드를 다시 한 번 실행할 수 있습니다.

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

이제 우리의 출력은 복소수 목록이 될 것입니다.

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

JSONEncoder 클래스 아래에 자체 인코더 클래스를 추가한 것처럼 object_hook을 재정의하는 대신 JSONDecoder 클래스 아래에 자체 디코더 클래스를 가질 수 있습니다.

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)

결론 :

이 기사에서 Python을 사용한 JSON에 대해 읽었습니다. 지금까지 배운 내용에서 중요한 점을 기억해 봅시다.

  • 내장된 json 패키지 가져오기
  • load 또는 load()를 사용하여 데이터 읽기
  • 데이터 처리
  • dump() 또는 dumps()를 사용하여 처리된 쓰기
  • 사용자 지정 데이터 유형을 처리하는 경우 메타데이터를 가져오고 데이터를 읽고 쓸 수 있는 자체 디코더와 인코더를 작성하십시오.
균열 시스템 설계 인터뷰
Translate »