소개
Python 의 다재다능함은 널리 사용되는 데이터 교환 형식인 JSON 데이터 작업 능력으로 확장됩니다. 하지만 중첩된 JSON 객체를 다룰 때, 데이터 처리 워크플로우를 방해할 수 있는 악명 높은 KeyError 를 만날 수 있습니다. 이 튜토리얼은 KeyError 를 효과적으로 처리하고 Python 코드가 복잡한 JSON 구조를 원활하게 탐색할 수 있도록 하는 전략을 안내합니다.
Python 에서 JSON 객체 생성 및 이해
JSON (JavaScript Object Notation) 은 사람이 읽고 쓰기 쉽고, 기계가 파싱하기 쉬운 가벼운 데이터 교환 형식입니다. Python 에서 JSON 객체는 중괄호 {}로 묶인 키 - 값 쌍인 딕셔너리로 표현됩니다.
간단한 Python 파일을 생성하고 기본적인 JSON 객체를 정의하는 것으로 시작해 보겠습니다.
WebIDE (VS Code) 를 열고 왼쪽 탐색 패널에서 "New File" 아이콘을 클릭하여 새 파일을 만듭니다.
파일 이름을
json_basics.py로 지정하고 다음 코드를 추가합니다.
## Define a simple JSON object as a Python dictionary
person = {
"name": "John Doe",
"age": 30,
"email": "john.doe@example.com"
}
## Access and print values from the dictionary
print("Person details:")
print(f"Name: {person['name']}")
print(f"Age: {person['age']}")
print(f"Email: {person['email']}")
Ctrl+S를 누르거나 메뉴에서 "File" > "Save"를 선택하여 파일을 저장합니다.터미널을 열어 (메뉴에서: "Terminal" > "New Terminal") 다음을 입력하여 스크립트를 실행합니다.
python3 json_basics.py
다음과 같은 출력을 볼 수 있습니다.
Person details:
Name: John Doe
Age: 30
Email: john.doe@example.com
이제 더 복잡한 중첩된 JSON 객체를 만들어 보겠습니다. json_basics.py 파일을 다음 코드로 업데이트합니다.
## Define a nested JSON object
user_data = {
"person": {
"name": "John Doe",
"age": 30,
"address": {
"street": "123 Main St",
"city": "Anytown",
"state": "CA",
"zip": "12345"
}
},
"hobbies": ["reading", "hiking", "photography"]
}
## Access and print values from the nested dictionary
print("\nUser Data:")
print(f"Name: {user_data['person']['name']}")
print(f"Age: {user_data['person']['age']}")
print(f"Street: {user_data['person']['address']['street']}")
print(f"City: {user_data['person']['address']['city']}")
print(f"First hobby: {user_data['hobbies'][0]}")
파일을 저장하고 다시 실행합니다. 다음을 볼 수 있습니다.
Person details:
Name: John Doe
Age: 30
Email: john.doe@example.com
User Data:
Name: John Doe
Age: 30
Street: 123 Main St
City: Anytown
First hobby: reading
이것은 JSON 객체에서 중첩된 값에 접근하는 방법을 보여줍니다. 다음 단계에서는 존재하지 않는 키에 접근하려고 할 때 어떤 일이 발생하는지, 그리고 그 상황을 처리하는 방법을 살펴보겠습니다.
Try-Except 를 사용하여 KeyError 발생 및 처리
딕셔너리에 존재하지 않는 키에 접근하려고 하면 Python 은 KeyError를 발생시킵니다. 이는 중첩된 JSON 객체로 작업할 때, 특히 데이터 구조가 일관되지 않거나 불완전할 때 흔히 발생하는 문제입니다.
이 문제를 탐구하기 위해 새 파일을 만들어 보겠습니다.
WebIDE 에서
key_error_handling.py라는 새 파일을 만듭니다.KeyError를 보여주기 위해 다음 코드를 추가합니다.
## Define a nested JSON object with incomplete data
user_data = {
"person": {
"name": "John Doe",
"age": 30,
"address": {
"street": "123 Main St",
"city": "Anytown",
"state": "CA"
## Note: zip code is missing
}
},
"hobbies": ["reading", "hiking", "photography"]
}
## This will cause a KeyError
print("Trying to access a non-existent key:")
try:
zip_code = user_data["person"]["address"]["zip"]
print(f"Zip code: {zip_code}")
except KeyError as e:
print(f"KeyError encountered: {e}")
print("The key 'zip' does not exist in the address dictionary.")
- 파일을 저장하고 터미널을 열어 다음을 입력하여 실행합니다.
python3 key_error_handling.py
다음과 유사한 출력을 볼 수 있습니다.
Trying to access a non-existent key:
KeyError encountered: 'zip'
The key 'zip' does not exist in the address dictionary.
이것은 try-except 블록을 사용하여 KeyError를 처리하는 기본적인 방법을 보여줍니다. 이제 중첩된 딕셔너리에서 여러 잠재적인 키 오류를 처리하도록 예제를 확장해 보겠습니다.
## Add this code to your key_error_handling.py file
print("\nHandling multiple potential KeyErrors:")
## Function to safely access nested dictionary values
def safe_get_nested_value(data, keys_list):
"""
Safely access nested dictionary values using try-except.
Args:
data: The dictionary to navigate
keys_list: A list of keys to access in sequence
Returns:
The value if found, otherwise a message about the missing key
"""
current = data
try:
for key in keys_list:
current = current[key]
return current
except KeyError as e:
return f"Unable to access key: {e}"
## Test the function with various paths
paths_to_test = [
["person", "name"], ## Should work
["person", "address", "zip"], ## Should fail
["person", "contact", "phone"], ## Should fail
["hobbies", 0] ## Should work
]
for path in paths_to_test:
result = safe_get_nested_value(user_data, path)
print(f"Path {path}: {result}")
- 파일을 저장하고 다시 실행합니다. 다음과 유사한 출력을 볼 수 있습니다.
Trying to access a non-existent key:
KeyError encountered: 'zip'
The key 'zip' does not exist in the address dictionary.
Handling multiple potential KeyErrors:
Path ['person', 'name']: John Doe
Path ['person', 'address', 'zip']: Unable to access key: 'zip'
Path ['person', 'contact', 'phone']: Unable to access key: 'contact'
Path ['hobbies', 0]: reading
이것은 JSON 객체에서 중첩된 키에 접근할 때 잠재적인 KeyError 예외를 처리하기 위해 try-except 를 사용하는 방법을 보여줍니다. 함수는 키를 찾을 수 없을 때 적절한 메시지를 반환하며, 이는 처리되지 않은 예외로 인해 프로그램이 충돌하는 것보다 훨씬 좋습니다.
다음 단계에서는 dict.get() 메서드를 사용하여 훨씬 더 우아한 접근 방식을 탐구해 보겠습니다.
안전한 접근을 위한 dict.get() 메서드 사용
dict.get() 메서드는 KeyError를 발생시키지 않고 딕셔너리 값에 접근하는 더 우아한 방법을 제공합니다. 이 메서드를 사용하면 키가 존재하지 않는 경우 반환할 기본값을 지정할 수 있습니다.
이 접근 방식을 탐구하기 위해 새 파일을 만들어 보겠습니다.
WebIDE 에서
dict_get_method.py라는 새 파일을 만듭니다.다음 코드를 추가합니다.
## Define a nested JSON object with incomplete data
user_data = {
"person": {
"name": "John Doe",
"age": 30,
"address": {
"street": "123 Main St",
"city": "Anytown",
"state": "CA"
## Note: zip code is missing
}
},
"hobbies": ["reading", "hiking", "photography"]
}
## Using dict.get() for safer access
print("Using dict.get() method:")
zip_code = user_data["person"]["address"].get("zip", "Not provided")
print(f"Zip code: {zip_code}")
## This approach still has a problem with deeper nesting
print("\nProblem with deeper nesting:")
try:
## This works for 'person' key that exists
contact = user_data.get("person", {}).get("contact", {}).get("phone", "Not available")
print(f"Contact phone: {contact}")
## But this will still raise KeyError if any middle key doesn't exist
non_existent = user_data["non_existent_key"]["some_key"]
print(f"This won't print due to KeyError: {non_existent}")
except KeyError as e:
print(f"KeyError encountered: {e}")
- 파일을 저장하고 터미널을 열어 다음을 입력하여 실행합니다.
python3 dict_get_method.py
다음과 유사한 출력을 볼 수 있습니다.
Using dict.get() method:
Zip code: Not provided
Problem with deeper nesting:
Contact phone: Not available
KeyError encountered: 'non_existent_key'
이제 중첩된 딕셔너리 구조를 안전하게 탐색할 수 있는 더 강력한 솔루션을 구현해 보겠습니다.
## Add this code to your dict_get_method.py file
print("\nSafer nested dictionary navigation:")
def deep_get(dictionary, keys, default=None):
"""
Safely access nested dictionary values using dict.get().
Args:
dictionary: The dictionary to navigate
keys: A list of keys to access in sequence
default: The default value to return if any key is missing
Returns:
The value if the complete path exists, otherwise the default value
"""
result = dictionary
for key in keys:
if isinstance(result, dict):
result = result.get(key, default)
if result == default:
return default
else:
return default
return result
## Test our improved function
test_paths = [
["person", "name"], ## Should work
["person", "address", "zip"], ## Should return default
["person", "contact", "phone"], ## Should return default
["non_existent_key", "some_key"], ## Should return default
["hobbies", 0] ## Should work with list index
]
for path in test_paths:
value = deep_get(user_data, path, "Not available")
path_str = "->".join([str(k) for k in path])
print(f"Path {path_str}: {value}")
## Practical example: formatting user information safely
print("\nFormatted user information:")
name = deep_get(user_data, ["person", "name"], "Unknown")
city = deep_get(user_data, ["person", "address", "city"], "Unknown")
state = deep_get(user_data, ["person", "address", "state"], "Unknown")
zip_code = deep_get(user_data, ["person", "address", "zip"], "Unknown")
primary_hobby = deep_get(user_data, ["hobbies", 0], "None")
print(f"User {name} lives in {city}, {state} {zip_code}")
print(f"Primary hobby: {primary_hobby}")
- 파일을 저장하고 다시 실행합니다. 다음과 유사한 출력을 볼 수 있습니다.
Using dict.get() method:
Zip code: Not provided
Problem with deeper nesting:
Contact phone: Not available
KeyError encountered: 'non_existent_key'
Safer nested dictionary navigation:
Path person->name: John Doe
Path person->address->zip: Not available
Path person->contact->phone: Not available
Path non_existent_key->some_key: Not available
Path hobbies->0: reading
Formatted user information:
User John Doe lives in Anytown, CA Unknown
Primary hobby: reading
우리가 만든 deep_get() 함수는 KeyError 예외를 발생시키지 않고 딕셔너리에서 중첩된 값에 접근하는 강력한 방법을 제공합니다. 이 접근 방식은 구조가 일관되지 않거나 불완전할 수 있는 외부 소스의 JSON 데이터를 사용할 때 특히 유용합니다.
중첩된 JSON 처리를 위한 고급 기술
중첩된 JSON 객체에서 KeyError를 처리하는 기본적인 접근 방식을 살펴봤으므로, 코드를 더욱 강력하고 유지 관리 가능하게 만들 수 있는 몇 가지 고급 기술을 살펴보겠습니다.
WebIDE 에서
advanced_techniques.py라는 새 파일을 만듭니다.여러 고급 기술을 구현하기 위해 다음 코드를 추가합니다.
## Exploring advanced techniques for handling nested JSON objects
import json
from functools import reduce
import operator
## Sample JSON data with various nested structures
json_str = """
{
"user": {
"id": 12345,
"name": "Jane Smith",
"profile": {
"bio": "Software developer with 5 years of experience",
"social_media": {
"twitter": "@janesmith",
"linkedin": "jane-smith"
}
},
"skills": ["Python", "JavaScript", "SQL"],
"employment": {
"current": {
"company": "Tech Solutions Inc.",
"position": "Senior Developer"
},
"previous": [
{
"company": "WebDev Co",
"position": "Junior Developer",
"duration": "2 years"
}
]
}
}
}
"""
## Parse the JSON string into a Python dictionary
data = json.loads(json_str)
print("Loaded JSON data structure:")
print(json.dumps(data, indent=2)) ## Pretty-print the JSON data
print("\n----- Technique 1: Using a path string with split -----")
def get_by_path(data, path_string, default=None, separator='.'):
"""
Access a nested value using a dot-separated path string.
Example:
get_by_path(data, "user.profile.social_media.twitter")
"""
keys = path_string.split(separator)
## Start with the root data
current = data
## Try to traverse the path
for key in keys:
## Handle array indices in the path (e.g., "employment.previous.0.company")
if key.isdigit() and isinstance(current, list):
index = int(key)
if 0 <= index < len(current):
current = current[index]
else:
return default
elif isinstance(current, dict) and key in current:
current = current[key]
else:
return default
return current
## Test the function
paths_to_check = [
"user.name",
"user.profile.social_media.twitter",
"user.skills.1",
"user.employment.current.position",
"user.employment.previous.0.company",
"user.contact.email", ## This path doesn't exist
]
for path in paths_to_check:
value = get_by_path(data, path, "Not available")
print(f"{path}: {value}")
print("\n----- Technique 2: Using functools.reduce -----")
def get_by_path_reduce(data, path_list, default=None):
"""
Access a nested value using reduce and operator.getitem.
This approach is more concise but less flexible with error handling.
"""
try:
return reduce(operator.getitem, path_list, data)
except (KeyError, IndexError, TypeError):
return default
## Test the reduce-based function
path_lists = [
["user", "name"],
["user", "profile", "social_media", "twitter"],
["user", "skills", 1],
["user", "employment", "current", "position"],
["user", "employment", "previous", 0, "company"],
["user", "contact", "email"], ## This path doesn't exist
]
for path in path_lists:
value = get_by_path_reduce(data, path, "Not available")
path_str = "->".join([str(p) for p in path])
print(f"{path_str}: {value}")
print("\n----- Technique 3: Class-based approach -----")
class SafeDict:
"""
A wrapper class for dictionaries that provides safe access to nested keys.
"""
def __init__(self, data):
self.data = data
def get(self, *keys, default=None):
"""
Access nested keys safely, returning default if any key is missing.
"""
current = self.data
for key in keys:
if isinstance(current, dict) and key in current:
current = current[key]
elif isinstance(current, list) and isinstance(key, int) and 0 <= key < len(current):
current = current[key]
else:
return default
return current
def __str__(self):
return str(self.data)
## Create a SafeDict instance
safe_data = SafeDict(data)
## Test the class-based approach
print(f"User name: {safe_data.get('user', 'name', default='Unknown')}")
print(f"Twitter handle: {safe_data.get('user', 'profile', 'social_media', 'twitter', default='None')}")
print(f"Second skill: {safe_data.get('user', 'skills', 1, default='None')}")
print(f"Current position: {safe_data.get('user', 'employment', 'current', 'position', default='None')}")
print(f"Previous company: {safe_data.get('user', 'employment', 'previous', 0, 'company', default='None')}")
print(f"Email (missing): {safe_data.get('user', 'contact', 'email', default='Not provided')}")
- 파일을 저장하고 터미널을 열어 다음을 입력하여 실행합니다.
python3 advanced_techniques.py
JSON 객체에서 중첩된 값에 안전하게 접근하는 다양한 방법을 보여주는 출력을 볼 수 있습니다. 각 기술에는 고유한 장점이 있습니다.
- Path string with split: 경로가 문자열로 정의된 경우 (예: 구성 파일) 사용하기 쉽습니다.
- Reduce with operator.getitem: 더 간결한 접근 방식으로, 함수형 프로그래밍에 유용합니다.
- Class-based approach: 코드를 더 깨끗하고 유지 관리 가능하게 만드는 재사용 가능한 래퍼를 제공합니다.
이제 이러한 기술을 사용하여 더 복잡한 JSON 데이터 구조를 처리하는 실용적인 응용 프로그램을 만들어 보겠습니다.
## Create a new file called practical_example.py
practical_example.py라는 새 파일을 만들고 다음 코드를 추가합니다.
import json
## Sample JSON data representing a customer order system
json_str = """
{
"orders": [
{
"order_id": "ORD-001",
"customer": {
"id": "CUST-101",
"name": "Alice Johnson",
"contact": {
"email": "alice@example.com",
"phone": "555-1234"
}
},
"items": [
{
"product_id": "PROD-A1",
"name": "Wireless Headphones",
"price": 79.99,
"quantity": 1
},
{
"product_id": "PROD-B2",
"name": "Smartphone Case",
"price": 19.99,
"quantity": 2
}
],
"shipping_address": {
"street": "123 Maple Ave",
"city": "Springfield",
"state": "IL",
"zip": "62704"
},
"payment": {
"method": "credit_card",
"status": "completed"
}
},
{
"order_id": "ORD-002",
"customer": {
"id": "CUST-102",
"name": "Bob Smith",
"contact": {
"email": "bob@example.com"
// phone missing
}
},
"items": [
{
"product_id": "PROD-C3",
"name": "Bluetooth Speaker",
"price": 49.99,
"quantity": 1
}
],
"shipping_address": {
"street": "456 Oak St",
"city": "Rivertown",
"state": "CA"
// zip missing
}
// payment information missing
}
]
}
"""
## Parse the JSON data
try:
data = json.loads(json_str)
except json.JSONDecodeError as e:
print(f"Invalid JSON: {e}")
exit(1)
## Import our SafeDict class from the previous example
class SafeDict:
def __init__(self, data):
self.data = data
def get(self, *keys, default=None):
current = self.data
for key in keys:
if isinstance(current, dict) and key in current:
current = current[key]
elif isinstance(current, list) and isinstance(key, int) and 0 <= key < len(current):
current = current[key]
else:
return default
return current
def __str__(self):
return str(self.data)
## Create a SafeDict instance
safe_data = SafeDict(data)
print("Processing order information safely...")
## Process each order
for i in range(10): ## Try to process up to 10 orders
## Use SafeDict to avoid KeyError
order = safe_data.get('orders', i)
if order is None:
print(f"No order found at index {i}")
break
## Create a SafeDict for this specific order
order_dict = SafeDict(order)
## Safely extract order information
order_id = order_dict.get('order_id', default='Unknown')
customer_name = order_dict.get('customer', 'name', default='Unknown Customer')
customer_email = order_dict.get('customer', 'contact', 'email', default='No email provided')
customer_phone = order_dict.get('customer', 'contact', 'phone', default='No phone provided')
## Process shipping information
shipping = order_dict.get('shipping_address', default={})
shipping_dict = SafeDict(shipping)
shipping_address = f"{shipping_dict.get('street', default='')}, " \
f"{shipping_dict.get('city', default='')}, " \
f"{shipping_dict.get('state', default='')} " \
f"{shipping_dict.get('zip', default='')}"
## Process payment information
payment_status = order_dict.get('payment', 'status', default='Unknown')
## Calculate order total
items = order_dict.get('items', default=[])
order_total = 0
for item in items:
item_dict = SafeDict(item)
price = item_dict.get('price', default=0)
quantity = item_dict.get('quantity', default=0)
order_total += price * quantity
## Print order summary
print(f"\nOrder ID: {order_id}")
print(f"Customer: {customer_name}")
print(f"Contact: {customer_email} | {customer_phone}")
print(f"Shipping Address: {shipping_address}")
print(f"Payment Status: {payment_status}")
print(f"Order Total: ${order_total:.2f}")
print(f"Items: {len(items)}")
## Print item details
for j, item in enumerate(items):
item_dict = SafeDict(item)
name = item_dict.get('name', default='Unknown Product')
price = item_dict.get('price', default=0)
quantity = item_dict.get('quantity', default=0)
print(f" {j+1}. {name} (${price:.2f} × {quantity}) = ${price*quantity:.2f}")
- 파일을 저장하고 실행합니다.
python3 practical_example.py
누락되거나 불완전한 데이터를 적절하게 처리하면서 복잡한 JSON 데이터 구조를 안전하게 처리하는 방법을 보여주는 출력을 볼 수 있습니다. 이는 구조가 항상 예상과 일치하지 않을 수 있는 외부 소스의 데이터를 처리할 때 특히 중요합니다.
실용적인 예제는 다음을 보여줍니다.
- 중첩된 JSON 구조를 안전하게 탐색합니다.
- 누락된 데이터를 적절한 기본값으로 처리합니다.
- JSON 내에서 객체 컬렉션을 처리합니다.
- 중첩된 정보를 추출하고 형식을 지정합니다.
이러한 기술은 KeyError 예외로 인해 충돌하지 않고 실제 JSON 데이터를 처리할 수 있는 더 강력한 애플리케이션을 구축하는 데 도움이 됩니다.
요약
이 튜토리얼에서는 Python JSON 객체에서 중첩된 키에 접근할 때 KeyError를 처리하기 위한 효과적인 전략을 배웠습니다. 우리는 다음과 같은 여러 가지 접근 방식을 탐구했습니다.
- 기본 try-except 블록 -
KeyError예외를 포착하고 처리하는 기본적인 방법 - dict.get() 메서드 - 기본값을 지정할 수 있는 더 깔끔한 접근 방식
- 사용자 정의 도우미 함수 - 중첩된 구조를 안전하게 탐색하기 위한 재사용 가능한 함수 생성
- 고급 기술 - 경로 문자열, reduce 를 사용한 함수형 프로그래밍, 클래스 기반 래퍼 포함
이러한 기술을 적용하여 JSON 객체에서 누락되거나 불완전한 데이터를 우아하게 처리하고 KeyError 예외로 인해 애플리케이션이 충돌하는 것을 방지하는 더 강력한 코드를 작성할 수 있습니다.
다음 핵심 사항을 기억하십시오.
- JSON 데이터를 사용할 때는 항상 누락된 키의 가능성을 고려하십시오.
- 애플리케이션에 적합한 적절한 기본값을 사용하십시오.
- 중첩된 데이터 구조 작업을 단순화하기 위해 재사용 가능한 유틸리티를 만듭니다.
- 특정 사용 사례 및 코딩 스타일에 가장 적합한 접근 방식을 선택하십시오.
이러한 기술은 외부 소스, API 또는 사용자 입력에서 JSON 데이터를 사용하는 모든 Python 개발자에게 필수적이며, 실제 데이터를 자신 있게 처리할 수 있는 더욱 탄력적인 애플리케이션을 구축할 수 있도록 합니다.
