KR_JSON - somaz94/python-study GitHub Wiki

Python JSON ์ฒ˜๋ฆฌ ๊ฐœ๋… ์ •๋ฆฌ


1๏ธโƒฃ JSON ๊ธฐ์ดˆ

JSON(JavaScript Object Notation)์€ ๋ฐ์ดํ„ฐ๋ฅผ ๊ตํ™˜ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋Š” ๊ฒฝ๋Ÿ‰ ๋ฐ์ดํ„ฐ ํ˜•์‹์ด๋‹ค.

import json

# ๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ํƒ€์ž… ๋ณ€ํ™˜
python_dict = {
    "name": "John",
    "age": 30,
    "city": "Seoul"
}

# Python -> JSON
json_str = json.dumps(python_dict)
print(json_str)  # {"name": "John", "age": 30, "city": "Seoul"}

# JSON -> Python
python_data = json.loads(json_str)
print(python_data["name"])  # John

# Python ํƒ€์ž…๊ณผ JSON ํƒ€์ž… ๋งคํ•‘
# dict -> object, list/tuple -> array, str -> string, 
# int/float -> number, True/False -> true/false, None -> null

# ํ•œ๊ธ€ ๋ฐ ์œ ๋‹ˆ์ฝ”๋“œ ์ฒ˜๋ฆฌ
korean_data = {"์ด๋ฆ„": "ํ™๊ธธ๋™", "๋„์‹œ": "์„œ์šธ"}
json_str = json.dumps(korean_data, ensure_ascii=False)
print(json_str)  # {"์ด๋ฆ„": "ํ™๊ธธ๋™", "๋„์‹œ": "์„œ์šธ"}

โœ… ํŠน์ง•:

  • ๊ฐ„๋‹จํ•œ ๋ฐ์ดํ„ฐ ๋ณ€ํ™˜
  • ๋ฌธ์ž์—ด ์ง๋ ฌํ™”
  • ๊ธฐ๋ณธ ๋ฐ์ดํ„ฐ ํƒ€์ž… ์ง€์›
  • ์–ธ์–ด์— ๋…๋ฆฝ์ ์ธ ๋ฐ์ดํ„ฐ ํ˜•์‹
  • ์‚ฌ๋žŒ์ด ์ฝ๊ณ  ์“ฐ๊ธฐ ์‰ฌ์›€
  • ๊ธฐ๊ณ„๊ฐ€ ํŒŒ์‹ฑํ•˜๊ณ  ์ƒ์„ฑํ•˜๊ธฐ ์‰ฌ์›€


2๏ธโƒฃ ํŒŒ์ผ ์ž…์ถœ๋ ฅ

JSON ๋ฐ์ดํ„ฐ๋ฅผ ํŒŒ์ผ๋กœ ์ €์žฅํ•˜๊ณ  ๋ถˆ๋Ÿฌ์˜ค๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

# JSON ํŒŒ์ผ ์“ฐ๊ธฐ
data = {
    "users": [
        {"id": 1, "name": "Alice"},
        {"id": 2, "name": "Bob"}
    ]
}

with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=4)

# JSON ํŒŒ์ผ ์ฝ๊ธฐ
with open('data.json', 'r', encoding='utf-8') as f:
    loaded_data = json.load(f)

# ์—ฌ๋Ÿฌ ์˜ต์…˜ ํ™œ์šฉ
with open('formatted_data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, 
              indent=2,           # ๋“ค์—ฌ์“ฐ๊ธฐ ๊ฐ„๊ฒฉ ์„ค์ •
              sort_keys=True,     # ํ‚ค๋ฅผ ์•ŒํŒŒ๋ฒณ ์ˆœ์œผ๋กœ ์ •๋ ฌ
              ensure_ascii=False, # ๋น„ASCII ๋ฌธ์ž ๊ทธ๋Œ€๋กœ ์ถœ๋ ฅ
              separators=(',', ': '))  # ๊ตฌ๋ถ„์ž ์ง€์ •

# ๋Œ€์šฉ๋Ÿ‰ ํŒŒ์ผ ์ฒ˜๋ฆฌ
def read_json_stream(file_path):
    """๋Œ€์šฉ๋Ÿ‰ JSON ํŒŒ์ผ์„ ํ•œ ์ค„์”ฉ ์ฒ˜๋ฆฌ"""
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            if line.strip():  # ๋นˆ ์ค„ ๊ฑด๋„ˆ๋›ฐ๊ธฐ
                yield json.loads(line)

# JSONL(JSON Lines) ํ˜•์‹ ์ฒ˜๋ฆฌ
def write_jsonl(data_list, file_path):
    """๊ฐ ํ•ญ๋ชฉ์„ JSON Lines ํ˜•์‹์œผ๋กœ ์ €์žฅ"""
    with open(file_path, 'w', encoding='utf-8') as f:
        for item in data_list:
            f.write(json.dumps(item, ensure_ascii=False) + '\n')

โœ… ํŠน์ง•:

  • ํŒŒ์ผ ์ €์žฅ/๋กœ๋“œ
  • UTF-8 ์ธ์ฝ”๋”ฉ
  • ๋“ค์—ฌ์“ฐ๊ธฐ ์ง€์›
  • ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
  • JSONL ํ˜•์‹ ์ง€์›
  • ํŒŒ์„œ ์˜ต์…˜ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•


3๏ธโƒฃ ๊ณ ๊ธ‰ ์ง๋ ฌํ™”

๋ณต์žกํ•œ Python ๊ฐ์ฒด๋ฅผ JSON์œผ๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

from datetime import datetime
from decimal import Decimal
import uuid

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, Decimal):
            return str(obj)
        if isinstance(obj, uuid.UUID):
            return str(obj)
        # ์‚ฌ์šฉ์ž ์ •์˜ ํด๋ž˜์Šค ์ฒ˜๋ฆฌ
        if hasattr(obj, 'to_json'):
            return obj.to_json()
        return super().default(obj)

# ์‚ฌ์šฉ์ž ์ •์˜ ํด๋ž˜์Šค
class User:
    def __init__(self, name, created_at):
        self.name = name
        self.created_at = created_at
        self.id = uuid.uuid4()
    
    def to_json(self):
        return {
            'name': self.name,
            'created_at': self.created_at,
            'id': self.id
        }

data = {
    'user': User('John Doe', datetime.now()),
    'balance': Decimal('10.52'),
    'transaction_id': uuid.uuid4()
}

json_str = json.dumps(data, cls=CustomEncoder, indent=2)
print(json_str)

# ์ง๋ ฌํ™”/์—ญ์ง๋ ฌํ™” ํ•จ์ˆ˜ ์‚ฌ์šฉ
def serialize(obj):
    """๊ฐ์ฒด๋ฅผ JSON ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜"""
    return json.dumps(obj, cls=CustomEncoder)

def deserialize(json_str, custom_decoder=None):
    """JSON ๋ฌธ์ž์—ด์„ ๊ฐ์ฒด๋กœ ๋ณ€ํ™˜"""
    if custom_decoder:
        return json.loads(json_str, object_hook=custom_decoder)
    return json.loads(json_str)

# object_hook์œผ๋กœ ์ปค์Šคํ…€ ๊ฐ์ฒด ๋ณต์›
def user_decoder(obj):
    if 'name' in obj and 'created_at' in obj and 'id' in obj:
        user = User(obj['name'], datetime.fromisoformat(obj['created_at']))
        user.id = uuid.UUID(obj['id'])
        return user
    return obj

โœ… ํŠน์ง•:

  • ์ปค์Šคํ…€ ์ธ์ฝ”๋”
  • ๋ณต์žกํ•œ ๊ฐ์ฒด ๋ณ€ํ™˜
  • ์œ ์—ฐํ•œ ํ™•์žฅ
  • object_hook์œผ๋กœ ์—ญ์ง๋ ฌํ™” ์ปค์Šคํ„ฐ๋งˆ์ด์ง•
  • ์‚ฌ์šฉ์ž ์ •์˜ ํด๋ž˜์Šค ์ง€์›
  • ๊ธฐ๋ณธ ํƒ€์ž…์œผ๋กœ ์—†๋Š” ๋ฐ์ดํ„ฐ ํƒ€์ž… ์ฒ˜๋ฆฌ


4๏ธโƒฃ JSON ์Šคํ‚ค๋งˆ ๊ฒ€์ฆ

JSON ๋ฐ์ดํ„ฐ๊ฐ€ ์ •์˜๋œ ๊ตฌ์กฐ๋ฅผ ๋”ฐ๋ฅด๋Š”์ง€ ๊ฒ€์ฆํ•˜๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

from jsonschema import validate, ValidationError, Draft7Validator

# ๊ธฐ๋ณธ ์Šคํ‚ค๋งˆ ์ •์˜
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
        "email": {"type": "string", "format": "email"},
        "tags": {
            "type": "array",
            "items": {"type": "string"},
            "minItems": 1
        },
        "address": {
            "type": "object", 
            "properties": {
                "street": {"type": "string"},
                "city": {"type": "string"},
                "country": {"type": "string"}
            },
            "required": ["street", "city"]
        }
    },
    "required": ["name", "age", "email"]
}

# ๊ฒ€์ฆ ํ•จ์ˆ˜
def validate_json(data, schema):
    try:
        validate(instance=data, schema=schema)
        return True, None
    except ValidationError as e:
        return False, str(e)

# ์‚ฌ์šฉ ์˜ˆ์‹œ
user_data = {
    "name": "Alice Smith",
    "age": 25,
    "email": "[email protected]",
    "tags": ["developer", "python"],
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

is_valid, error = validate_json(user_data, schema)
if is_valid:
    print("๋ฐ์ดํ„ฐ๊ฐ€ ์œ ํšจํ•ฉ๋‹ˆ๋‹ค.")
else:
    print(f"๊ฒ€์ฆ ์‹คํŒจ: {error}")

# ๋ชจ๋“  ์—๋Ÿฌ ํ•œ๋ฒˆ์— ์ˆ˜์ง‘ํ•˜๊ธฐ
def collect_all_errors(data, schema):
    validator = Draft7Validator(schema)
    errors = list(validator.iter_errors(data))
    return [str(error) for error in errors]

# ์Šคํ‚ค๋งˆ ๋™์  ์ƒ์„ฑ
def generate_schema_from_data(data):
    """์ƒ˜ํ”Œ ๋ฐ์ดํ„ฐ๋กœ๋ถ€ํ„ฐ ๊ธฐ๋ณธ ์Šคํ‚ค๋งˆ ์ƒ์„ฑ"""
    schema = {"type": "object", "properties": {}}
    for key, value in data.items():
        if isinstance(value, str):
            schema["properties"][key] = {"type": "string"}
        elif isinstance(value, int):
            schema["properties"][key] = {"type": "integer"}
        elif isinstance(value, float):
            schema["properties"][key] = {"type": "number"}
        elif isinstance(value, bool):
            schema["properties"][key] = {"type": "boolean"}
        elif isinstance(value, list):
            schema["properties"][key] = {"type": "array"}
        elif isinstance(value, dict):
            schema["properties"][key] = {"type": "object"}
        elif value is None:
            schema["properties"][key] = {"type": "null"}
    
    return schema

โœ… ํŠน์ง•:

  • ๋ฐ์ดํ„ฐ ์œ ํšจ์„ฑ ๊ฒ€์‚ฌ
  • ์Šคํ‚ค๋งˆ ์ •์˜
  • ์—๋Ÿฌ ์ฒ˜๋ฆฌ
  • ๊ณ„์ธต์  ๊ตฌ์กฐ ๊ฒ€์ฆ
  • ํƒ€์ž… ๋ฐ ํ˜•์‹ ๊ฒ€์ฆ
  • ์กฐ๊ฑด๋ถ€ ๊ฒ€์ฆ ์ง€์›
  • ๋™์  ์Šคํ‚ค๋งˆ ์ƒ์„ฑ


5๏ธโƒฃ ์‹ค์šฉ์ ์ธ ์˜ˆ์ œ

์ผ๋ฐ˜์ ์ธ JSON ์ž‘์—…์„ ์œ„ํ•œ ์‹ค์šฉ์ ์ธ ์˜ˆ์ œ์ด๋‹ค.

# ์„ค์ • ๊ด€๋ฆฌ ํด๋ž˜์Šค
class Config:
    def __init__(self, config_file):
        self.config_file = config_file
        self.config = self.load_config()
    
    def load_config(self):
        try:
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            return self.create_default_config()
    
    def save_config(self):
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(self.config, f, indent=4, ensure_ascii=False)
    
    def create_default_config(self):
        default_config = {
            "app_name": "MyApp",
            "version": "1.0.0",
            "debug": True,
            "logging": {
                "level": "INFO",
                "file": "app.log"
            },
            "database": {
                "host": "localhost",
                "port": 5432,
                "name": "mydb"
            }
        }
        return default_config
    
    def get(self, key, default=None):
        """์„ค์ • ๊ฐ’ ๊ฐ€์ ธ์˜ค๊ธฐ (์  ํ‘œ๊ธฐ๋ฒ• ์ง€์›)"""
        keys = key.split('.')
        value = self.config
        try:
            for k in keys:
                value = value[k]
            return value
        except (KeyError, TypeError):
            return default
    
    def set(self, key, value):
        """์„ค์ • ๊ฐ’ ์„ค์ •ํ•˜๊ธฐ (์  ํ‘œ๊ธฐ๋ฒ• ์ง€์›)"""
        keys = key.split('.')
        config = self.config
        for k in keys[:-1]:
            if k not in config or not isinstance(config[k], dict):
                config[k] = {}
            config = config[k]
        config[keys[-1]] = value
        self.save_config()

# RESTful API ์‘๋‹ต ์ฒ˜๋ฆฌ
def json_response(data, status=200):
    """JSON API ์‘๋‹ต ์ƒ์„ฑ"""
    from flask import Response  # ํ•„์š”์— ๋”ฐ๋ผ ์„ค์น˜: pip install flask
    return Response(
        json.dumps(data, ensure_ascii=False),
        status=status,
        mimetype='application/json; charset=utf-8'
    )

# JSON ๋ฐ์ดํ„ฐ ๋ณ‘ํ•ฉ
def merge_json(base, override):
    """๋‘ JSON ๊ฐ์ฒด ๋ณ‘ํ•ฉ (์ค‘์ฒฉ ๊ตฌ์กฐ ์ง€์›)"""
    if not isinstance(base, dict) or not isinstance(override, dict):
        return override
    
    result = base.copy()
    for key, value in override.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = merge_json(result[key], value)
        else:
            result[key] = value
    return result

# JSON ์ฐจ์ด ์ฐพ๊ธฐ
def find_json_diff(old, new):
    """๋‘ JSON ๊ฐ์ฒด ๊ฐ„์˜ ์ฐจ์ด์  ์ฐพ๊ธฐ"""
    diff = {}
    
    # old์—๋Š” ์žˆ์ง€๋งŒ new์—๋Š” ์—†๋Š” ํ‚ค
    for key in old:
        if key not in new:
            diff[key] = {"old": old[key], "new": None}
    
    # ํ‚ค๊ฐ€ ์–‘์ชฝ ๋ชจ๋‘์— ์žˆ์ง€๋งŒ ๊ฐ’์ด ๋‹ค๋ฅธ ๊ฒฝ์šฐ
    for key in new:
        if key in old:
            if isinstance(old[key], dict) and isinstance(new[key], dict):
                nested_diff = find_json_diff(old[key], new[key])
                if nested_diff:
                    diff[key] = nested_diff
            elif old[key] != new[key]:
                diff[key] = {"old": old[key], "new": new[key]}
        else:
            diff[key] = {"old": None, "new": new[key]}
    
    return diff

โœ… ํŠน์ง•:

  • ์„ค์ • ํŒŒ์ผ ๊ด€๋ฆฌ
  • ๊ธฐ๋ณธ๊ฐ’ ์ฒ˜๋ฆฌ
  • ์—๋Ÿฌ ๋ณต๊ตฌ
  • ๊ณ„์ธต์  ์„ค์ • ์ ‘๊ทผ
  • API ์‘๋‹ต ํฌ๋งทํŒ…
  • JSON ๊ฐ์ฒด ๋ณ‘ํ•ฉ
  • ๋ณ€๊ฒฝ ์‚ฌํ•ญ ์ถ”์ 
  • ์œ ์—ฐํ•œ ๋ฐ์ดํ„ฐ ๊ด€๋ฆฌ


6๏ธโƒฃ JSON๊ณผ ์›น API

JSON์€ ์›น API์—์„œ ๋„๋ฆฌ ์‚ฌ์šฉ๋˜๋Š” ๋ฐ์ดํ„ฐ ๊ตํ™˜ ํ˜•์‹์ด๋‹ค.

import requests
import json

# API ์š”์ฒญ ๋ฐ JSON ์ฒ˜๋ฆฌ
def fetch_data_from_api(url, params=None):
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()  # 4xx, 5xx ์—๋Ÿฌ ํ™•์ธ
        return response.json()  # JSON ์‘๋‹ต์„ ํŒŒ์‹ฑํ•˜์—ฌ Python ๊ฐ์ฒด๋กœ ๋ณ€ํ™˜
    except requests.exceptions.RequestException as e:
        print(f"API ์š”์ฒญ ์—๋Ÿฌ: {e}")
        return None
    except json.JSONDecodeError as e:
        print(f"JSON ํŒŒ์‹ฑ ์—๋Ÿฌ: {e}")
        return None

# ๋ฐ์ดํ„ฐ POST ์š”์ฒญ
def post_data_to_api(url, data):
    headers = {'Content-Type': 'application/json'}
    try:
        response = requests.post(
            url, 
            data=json.dumps(data, ensure_ascii=False),
            headers=headers
        )
        response.raise_for_status()
        return response.json()
    except (requests.exceptions.RequestException, json.JSONDecodeError) as e:
        print(f"API ์š”์ฒญ ์—๋Ÿฌ: {e}")
        return None

# ๊ฐ„๋‹จํ•œ REST API ํด๋ผ์ด์–ธํŠธ
class RestClient:
    def __init__(self, base_url, token=None):
        self.base_url = base_url
        self.headers = {'Content-Type': 'application/json'}
        if token:
            self.headers['Authorization'] = f'Bearer {token}'
    
    def get(self, endpoint, params=None):
        url = f"{self.base_url}/{endpoint}"
        response = requests.get(url, params=params, headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def post(self, endpoint, data):
        url = f"{self.base_url}/{endpoint}"
        response = requests.post(
            url, 
            data=json.dumps(data, ensure_ascii=False),
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()
    
    def put(self, endpoint, data):
        url = f"{self.base_url}/{endpoint}"
        response = requests.put(
            url, 
            data=json.dumps(data, ensure_ascii=False),
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()
    
    def delete(self, endpoint):
        url = f"{self.base_url}/{endpoint}"
        response = requests.delete(url, headers=self.headers)
        response.raise_for_status()
        return response.status_code == 204 or response.json()

โœ… ํŠน์ง•:

  • API ํ†ต์‹ ์— JSON ํ™œ์šฉ
  • ์‘๋‹ต ๋ฐ์ดํ„ฐ ํŒŒ์‹ฑ
  • ์˜ค๋ฅ˜ ์ฒ˜๋ฆฌ
  • ์ธ์ฆ ํ—ค๋” ๊ด€๋ฆฌ
  • RESTful API ํด๋ผ์ด์–ธํŠธ
  • CRUD ์ž‘์—… ์ง€์›
  • HTTP ๋ฉ”์„œ๋“œ ์ฒ˜๋ฆฌ


7๏ธโƒฃ JSON ์„ฑ๋Šฅ ์ตœ์ ํ™”

๋Œ€๋Ÿ‰์˜ JSON ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ ์„ฑ๋Šฅ์„ ์ตœ์ ํ™”ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

import json
import time
import orjson  # pip install orjson
import ujson   # pip install ujson

# ์„ฑ๋Šฅ ๋น„๊ต
def compare_json_libs(data, iterations=1000):
    """๋‹ค์–‘ํ•œ JSON ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์„ฑ๋Šฅ ๋น„๊ต"""
    results = {}
    
    # ํ‘œ์ค€ json ๋ชจ๋“ˆ
    start = time.time()
    for _ in range(iterations):
        json_str = json.dumps(data)
        json_obj = json.loads(json_str)
    results['json'] = time.time() - start
    
    # ujson ๋ชจ๋“ˆ
    try:
        start = time.time()
        for _ in range(iterations):
            json_str = ujson.dumps(data)
            json_obj = ujson.loads(json_str)
        results['ujson'] = time.time() - start
    except ImportError:
        results['ujson'] = "๋ชจ๋“ˆ ์—†์Œ"
    
    # orjson ๋ชจ๋“ˆ
    try:
        start = time.time()
        for _ in range(iterations):
            json_str = orjson.dumps(data)
            json_obj = orjson.loads(json_str)
        results['orjson'] = time.time() - start
    except ImportError:
        results['orjson'] = "๋ชจ๋“ˆ ์—†์Œ"
    
    return results

# ์ŠคํŠธ๋ฆฌ๋ฐ ์ฒ˜๋ฆฌ๋กœ ๋Œ€์šฉ๋Ÿ‰ JSON ์ฒ˜๋ฆฌ
def process_large_json_stream(file_path, process_func):
    """๋Œ€์šฉ๋Ÿ‰ JSON ํŒŒ์ผ์„ ์ŠคํŠธ๋ฆฌ๋ฐ ๋ฐฉ์‹์œผ๋กœ ์ฒ˜๋ฆฌ"""
    import ijson  # pip install ijson
    
    with open(file_path, 'rb') as f:
        # ํŠน์ • ํŒจํ„ด์— ๋งž๋Š” ๊ฐ์ฒด๋งŒ ์ถ”์ถœํ•˜์—ฌ ์ฒ˜๋ฆฌ
        for item in ijson.items(f, 'items.item'):
            process_func(item)

# ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ์ธ JSON ์ƒ์„ฑ
def generate_large_json(file_path, n_items, chunk_size=1000):
    """๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ์œผ๋กœ ๋Œ€์šฉ๋Ÿ‰ JSON ํŒŒ์ผ ์ƒ์„ฑ"""
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write('{"items": [')
        
        for i in range(n_items):
            item = {
                "id": i,
                "name": f"Item {i}",
                "value": i * 10
            }
            
            if i > 0:
                f.write(',')
            
            f.write(json.dumps(item))
            
            # ๋ฉ”๋ชจ๋ฆฌ ํ™•๋ณด๋ฅผ ์œ„ํ•ด ์ฃผ๊ธฐ์ ์œผ๋กœ flush
            if i % chunk_size == 0:
                f.flush()
        
        f.write(']}')

โœ… ํŠน์ง•:

  • ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
  • ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์„ฑ
  • ๋Œ€์ฒด ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ํ™œ์šฉ
  • ์ŠคํŠธ๋ฆฌ๋ฐ ํŒŒ์‹ฑ
  • ์ฒญํฌ ๋‹จ์œ„ ์ฒ˜๋ฆฌ
  • ์„ฑ๋Šฅ ๋ฒค์น˜๋งˆํ‚น
  • ๋ฆฌ์†Œ์Šค ์ตœ์ ํ™”


์ฃผ์š” ํŒ

โœ… ๋ชจ๋ฒ” ์‚ฌ๋ก€:

  • ์ธ์ฝ”๋”ฉ ์ง€์ • (UTF-8)
  • ensure_ascii=False ํ™œ์šฉํ•˜์—ฌ ํ•œ๊ธ€ ๊ฐ€๋…์„ฑ ํ–ฅ์ƒ
  • ์—๋Ÿฌ ์ฒ˜๋ฆฌ ๊ตฌํ˜„ (try-except)
  • ์Šคํ‚ค๋งˆ ๊ฒ€์ฆ์œผ๋กœ ๋ฐ์ดํ„ฐ ์œ ํšจ์„ฑ ํ™•์ธ
  • ํฐ ํŒŒ์ผ์€ ์ŠคํŠธ๋ฆฌ๋ฐ ์ฒ˜๋ฆฌ (ijson ํ™œ์šฉ)
  • ์„ฑ๋Šฅ ์ตœ์ ํ™” ํ•„์š” ์‹œ orjson, ujson ๊ณ ๋ ค
  • ๋ณด์•ˆ ์ฃผ์˜ (๊ฒ€์ฆ๋˜์ง€ ์•Š์€ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ ์ฃผ์˜)
  • ๊น”๋”ํ•œ ํฌ๋งทํŒ… (indent ์‚ฌ์šฉ)
  • ๋ฐ์ดํ„ฐ ์••์ถ• ๊ณ ๋ ค (๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ)
  • ์ค‘์ฒฉ ๊ฐ์ฒด ์ฒ˜๋ฆฌ ์‹œ ์žฌ๊ท€ ํ•จ์ˆ˜ ์‚ฌ์šฉ
  • ์‹œ๊ฐ„/๋‚ ์งœ๋Š” ISO ํ˜•์‹ ์‚ฌ์šฉ ๊ถŒ์žฅ
  • ๋ณต์žกํ•œ ๊ฐ์ฒด๋Š” ์ง๋ ฌํ™” ๋กœ์ง ๋ถ„๋ฆฌ
  • ์„ค์ • ํŒŒ์ผ ๋“ฑ ์ค‘์š” JSON์€ ๋ฐฑ์—… ์œ ์ง€
  • ๋‚ด๋ถ€ ํฌ๋งท์ด ์•„๋‹Œ ๊ตํ™˜ ํฌ๋งท์œผ๋กœ ํ™œ์šฉ
  • ์›น API์—์„œ๋Š” Content-Type ํ—ค๋” ํ™•์ธ
  • ๋Œ€์†Œ๋ฌธ์ž ๊ตฌ๋ถ„์— ์ฃผ์˜ (JSON์€ ๋Œ€์†Œ๋ฌธ์ž ๊ตฌ๋ถ„)


โš ๏ธ **GitHub.com Fallback** โš ๏ธ