소개
Python 의 객체 지향 프로그래밍 (OOP) 기능은 개발자에게 인스턴스 데이터를 효과적으로 관리할 수 있는 강력한 도구를 제공합니다. 그 중 하나가 __dict__ 속성으로, Python 객체의 속성에 동적으로 접근하고 조작할 수 있게 해줍니다.
이 튜토리얼에서는 __dict__ 속성이 어떻게 작동하는지 살펴보고 Python 프로젝트에서 인스턴스 데이터를 관리하기 위해 이를 사용하는 다양한 방법을 배웁니다. 이 랩을 마치면 이 기능을 활용하여 더 유연하고 동적인 Python 애플리케이션을 만드는 방법을 이해하게 될 것입니다.
Python 객체와 __dict__ 속성 이해하기
Python 객체가 속성을 저장하는 방법과 __dict__ 속성을 사용하여 이에 접근하는 방법을 이해해 보겠습니다.
Python 에서 객체란 무엇인가?
Python 에서 모든 것은 객체입니다. 객체는 속성 (데이터) 과 메서드 (함수) 를 가집니다. 클래스에서 객체를 생성하면 객체는 자체 네임스페이스를 가져 속성을 저장합니다.
Python 클래스와 객체 생성하기
__dict__ 속성을 탐색하기 위해 간단한 Python 클래스와 객체를 생성해 보겠습니다.
LabEx 환경에서 터미널을 엽니다.
코드 편집기를 사용하여
person.py라는 새 Python 파일을 만듭니다.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
return f"Hello, my name is {self.name} and I am {self.age} years old."
## Create a Person object
person = Person("Alice", 30)
## Print the person object attributes
print(f"Name: {person.name}")
print(f"Age: {person.age}")
print(f"Greeting: {person.greet()}")
## Let's examine the __dict__ attribute
print("\nThe __dict__ attribute contains:")
print(person.__dict__)
- 터미널에서 Python 파일을 실행합니다.
python3 person.py
다음과 유사한 출력을 볼 수 있습니다.
Name: Alice
Age: 30
Greeting: Hello, my name is Alice and I am 30 years old.
The __dict__ attribute contains:
{'name': 'Alice', 'age': 30}
__dict__ 속성이란 무엇인가?
__dict__ 속성은 객체에 대해 정의된 모든 속성을 포함하는 딕셔너리입니다. 이 딕셔너리의 각 키는 속성 이름이고, 각 값은 해당 속성 값입니다.
출력에서 볼 수 있듯이, person 객체의 __dict__ 속성은 __init__ 메서드에서 설정한 name 및 age 속성을 포함합니다. 그러나 메서드는 인스턴스가 아닌 클래스에서 정의되므로 greet 메서드는 포함하지 않습니다.
클래스 및 인스턴스 속성 탐색하기
클래스 및 인스턴스 속성의 차이점을 이해하기 위해 코드를 업데이트해 보겠습니다.
person.py파일을 수정합니다.
class Person:
## Class attribute - shared by all instances
species = "Human"
def __init__(self, name, age):
## Instance attributes - unique to each instance
self.name = name
self.age = age
def greet(self):
return f"Hello, my name is {self.name} and I am {self.age} years old."
## Create a Person object
person = Person("Alice", 30)
## Print attributes
print(f"Name: {person.name}")
print(f"Age: {person.age}")
print(f"Species: {person.species}") ## Accessing class attribute
## Examine the __dict__ attributes
print("\nInstance __dict__ contains:")
print(person.__dict__)
print("\nClass __dict__ contains:")
print(Person.__dict__)
- 업데이트된 파일을 실행합니다.
python3 person.py
species 클래스 속성이 인스턴스의 __dict__에 저장되지 않지만 인스턴스를 통해 접근할 수 있음을 알 수 있습니다. 클래스의 __dict__는 클래스 수준의 모든 속성 및 메서드를 포함합니다.
__dict__가 유용한 이유
__dict__ 속성은 Python 객체의 기본 저장 메커니즘에 직접 접근할 수 있도록 합니다. 이는 다음과 같은 경우에 유용할 수 있습니다.
- 객체가 어떤 속성을 가지고 있는지 동적으로 검사
- 런타임에 속성 추가 또는 수정
- 객체 직렬화 (JSON 과 같은 형식으로 변환)
- 고급 프로그래밍 패턴 구현
이제 __dict__가 무엇인지 이해했으므로 다음 단계에서 객체 속성을 조작하는 방법을 배우겠습니다.
__dict__를 사용하여 속성에 접근하고 수정하기
__dict__ 속성이 무엇인지 이해했으므로, 이를 사용하여 객체 속성에 동적으로 접근하고 수정하는 방법을 배우겠습니다.
__dict__를 통한 속성 접근
Python 에서 객체의 속성에 접근하는 방법에는 두 가지가 있습니다.
- 점 표기법 사용:
person.name __dict__속성 사용:person.__dict__['name']
이러한 방법을 탐색하기 위해 새 Python 파일을 만들어 보겠습니다.
attribute_access.py라는 새 파일을 만듭니다.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
## Create a Person object
person = Person("Bob", 25)
## Method 1: Using dot notation
print("Using dot notation:")
print(f"Name: {person.name}")
print(f"Age: {person.age}")
## Method 2: Using __dict__
print("\nUsing __dict__:")
print(f"Name: {person.__dict__['name']}")
print(f"Age: {person.__dict__['age']}")
## Print the entire __dict__
print("\nAll attributes:")
print(person.__dict__)
- 파일을 실행합니다.
python3 attribute_access.py
출력은 두 방법 모두 동일한 결과를 제공함을 보여줍니다.
Using dot notation:
Name: Bob
Age: 25
Using __dict__:
Name: Bob
Age: 25
All attributes:
{'name': 'Bob', 'age': 25}
__dict__를 통한 속성 수정
__dict__ 속성은 속성을 읽는 것뿐만 아니라 수정하거나 새 속성을 추가하는 데에도 사용됩니다. 방법을 살펴보겠습니다.
modify_attributes.py라는 새 파일을 만듭니다.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
## Create a Person object
person = Person("Charlie", 35)
print("Original attributes:")
print(person.__dict__)
## Modify an existing attribute
person.__dict__['age'] = 36
print("\nAfter modifying age:")
print(person.__dict__)
print(f"Accessing with dot notation: person.age = {person.age}")
## Add a new attribute
person.__dict__['city'] = "New York"
print("\nAfter adding city attribute:")
print(person.__dict__)
print(f"Accessing with dot notation: person.city = {person.city}")
## Delete an attribute
del person.__dict__['city']
print("\nAfter deleting city attribute:")
print(person.__dict__)
## Try to access the deleted attribute (this will cause an error)
try:
print(person.city)
except AttributeError as e:
print(f"Error: {e}")
- 파일을 실행합니다.
python3 modify_attributes.py
다음과 유사한 출력을 볼 수 있습니다.
Original attributes:
{'name': 'Charlie', 'age': 35}
After modifying age:
{'name': 'Charlie', 'age': 36}
Accessing with dot notation: person.age = 36
After adding city attribute:
{'name': 'Charlie', 'age': 36, 'city': 'New York'}
Accessing with dot notation: person.city = New York
After deleting city attribute:
{'name': 'Charlie', 'age': 36}
Error: 'Person' object has no attribute 'city'
__dict__를 언제 사용해야 하는가 vs. 점 표기법
두 방법 모두 속성에 접근하고 수정하는 데 사용할 수 있지만, __dict__를 사용하는 것이 더 적절한 경우가 있습니다.
- 변수에 저장된 이름을 가진 속성에 접근해야 할 때
- 속성을 동적으로 추가하거나 제거하려는 경우
- 객체의 모든 속성을 반복해야 할 때
이러한 경우를 보여주는 예제를 만들어 보겠습니다.
dynamic_attributes.py라는 새 파일을 만듭니다.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
## Create a Person object
person = Person("David", 40)
## Case 1: Access attribute using a variable name
attr_name = "name"
print(f"Accessing {attr_name}: {person.__dict__[attr_name]}")
## Case 2: Dynamically add attributes
attributes_to_add = {
'city': 'Boston',
'job': 'Engineer',
'salary': 85000
}
for key, value in attributes_to_add.items():
person.__dict__[key] = value
print("\nAfter adding multiple attributes:")
print(person.__dict__)
## Case 3: Iterate over all attributes
print("\nAll attributes and their values:")
for attr_name, attr_value in person.__dict__.items():
print(f"{attr_name}: {attr_value}")
## Let's do something practical - create a function to clean up person data
def sanitize_person(person_obj):
"""Remove any attributes that are not name or age"""
allowed_attrs = ['name', 'age']
attrs_to_remove = [key for key in person_obj.__dict__ if key not in allowed_attrs]
for attr in attrs_to_remove:
del person_obj.__dict__[attr]
sanitize_person(person)
print("\nAfter sanitization:")
print(person.__dict__)
- 파일을 실행합니다.
python3 dynamic_attributes.py
출력은 __dict__를 사용하여 속성을 동적으로 작업하는 방법을 보여줍니다.
직접적인 속성 조작 방법 비교
이제 속성을 조작하는 다양한 방법을 비교하기 위해 예제를 하나 더 만들어 보겠습니다.
attribute_comparison.py라는 새 파일을 만듭니다.
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
## Create a Person object
person = Person("Eve", 28)
## Method 1: Using dot notation
person.city = "Chicago"
## Method 2: Using __dict__
person.__dict__['job'] = "Designer"
## Method 3: Using setattr
setattr(person, 'hobby', 'Painting')
## Method 4: Using getattr
name_value = getattr(person, 'name')
print("All attributes after different methods of adding:")
print(person.__dict__)
print(f"Retrieved name using getattr: {name_value}")
## You can also check if an attribute exists
if 'city' in person.__dict__:
print("The city attribute exists!")
## Or retrieve a value with a default if it doesn't exist
country = person.__dict__.get('country', 'Unknown')
print(f"Country (with default): {country}")
- 파일을 실행합니다.
python3 attribute_comparison.py
이 예제는 Python 에서 객체 속성을 조작하는 여러 가지 방법이 있음을 보여줍니다. __dict__는 속성 저장소에 직접 접근할 수 있지만, setattr() 및 getattr()과 같은 다른 내장 함수는 더 Pythonic 한 방식으로 유사한 기능을 제공합니다.
다음 단계에서는 __dict__ 속성을 사용하는 몇 가지 실제 응용 프로그램을 살펴보겠습니다.
동적 속성 관리를 위한 __dict__의 실제 응용
__dict__를 사용하여 속성에 접근하고 수정하는 방법을 이해했으므로, 실제 Python 프로그램에서 이 기능의 몇 가지 실제 응용 프로그램을 살펴보겠습니다.
응용 1: 객체 직렬화 (JSON 으로 변환)
__dict__의 일반적인 사용 사례 중 하나는 객체 직렬화, 특히 Python 객체를 저장 또는 전송을 위해 JSON 형식으로 변환할 때입니다.
object_serialization.py라는 새 파일을 만듭니다.
import json
class Person:
def __init__(self, name, age, city=None):
self.name = name
self.age = age
if city:
self.city = city
def to_json(self):
## Use __dict__ to get all attributes as a dictionary
return json.dumps(self.__dict__)
@classmethod
def from_json(cls, json_str):
## Create a new Person object from a JSON string
data = json.loads(json_str)
return cls(**data)
## Create a Person object
person = Person("Frank", 45, "San Francisco")
## Serialize to JSON
json_data = person.to_json()
print("JSON Data:")
print(json_data)
## Deserialize from JSON
person2 = Person.from_json(json_data)
print("\nDeserialized Person object attributes:")
print(person2.__dict__)
## Let's create multiple people and serialize them
people = [
Person("Grace", 32, "Seattle"),
Person("Henry", 27),
Person("Isla", 39, "Miami")
]
## Serialize the list of people
people_json = [person.to_json() for person in people]
print("\nJSON for multiple people:")
for p_json in people_json:
print(p_json)
## Save to a file
with open('people.json', 'w') as f:
json.dump([p.__dict__ for p in people], f)
print("\nSaved people data to people.json")
## Read from the file
with open('people.json', 'r') as f:
loaded_data = json.load(f)
print("\nLoaded from file:")
print(loaded_data)
## Convert back to Person objects
loaded_people = [Person(**data) for data in loaded_data]
print("\nRecreated Person objects:")
for person in loaded_people:
print(f"{person.name}, {person.age}, {getattr(person, 'city', 'No city')}")
- 파일을 실행합니다.
python3 object_serialization.py
이 예제는 __dict__가 Python 객체를 JSON 으로 변환하고 다시 JSON 에서 변환하는 것을 어떻게 쉽게 만드는지 보여줍니다. __dict__를 사용하면 객체의 모든 속성을 딕셔너리로 쉽게 가져올 수 있으며, 이를 json 모듈을 사용하여 JSON 으로 변환할 수 있습니다.
응용 2: 동적 객체 팩토리
__dict__의 또 다른 실제 응용 프로그램은 데이터를 기반으로 동적으로 객체를 생성하는 것입니다.
dynamic_object_factory.py라는 새 파일을 만듭니다.
class DynamicObject:
def __init__(self, **kwargs):
## Add all the keyword arguments as attributes
for key, value in kwargs.items():
self.__dict__[key] = value
def __str__(self):
attributes = ", ".join(f"{k}={v}" for k, v in self.__dict__.items())
return f"DynamicObject({attributes})"
## Create objects with different attributes
person = DynamicObject(name="Jennifer", age=29, profession="Developer")
car = DynamicObject(make="Toyota", model="Camry", year=2020, color="Blue")
book = DynamicObject(title="Python Programming", author="John Smith", pages=350)
## Print the objects
print(person)
print(car)
print(book)
## We can add attributes after creation
person.__dict__['country'] = "Canada"
print("\nAfter adding country attribute:")
print(person)
## We can also create an empty object and fill it later
empty_obj = DynamicObject()
print("\nEmpty object:", empty_obj)
## Fill it with data from a dictionary
data = {"type": "Laptop", "brand": "Dell", "ram": "16GB", "storage": "512GB SSD"}
empty_obj.__dict__.update(data)
print("After filling:", empty_obj)
## Let's create a factory function that creates objects from different data sources
def create_object_from_data(data_source):
if isinstance(data_source, dict):
return DynamicObject(**data_source)
elif isinstance(data_source, list) and all(isinstance(item, tuple) and len(item) == 2 for item in data_source):
return DynamicObject(**dict(data_source))
else:
raise ValueError("Unsupported data source type")
## Create objects from different data sources
dict_data = {"name": "Kevin", "age": 35, "email": "kevin@example.com"}
list_data = [("product", "Monitor"), ("price", 299.99), ("in_stock", True)]
obj1 = create_object_from_data(dict_data)
obj2 = create_object_from_data(list_data)
print("\nObjects created from different data sources:")
print(obj1)
print(obj2)
- 파일을 실행합니다.
python3 dynamic_object_factory.py
이 예제는 __dict__를 사용하여 임의의 속성을 가진 동적 객체를 생성하는 방법을 보여줍니다. 이는 API, 파일 또는 데이터베이스와 같은 외부 소스에서 데이터를 사용할 때 유용합니다.
응용 3: 간단한 속성 추적
__dict__를 사용하여 객체의 속성 변경 사항을 추적할 수 있습니다. 이는 변경 감지 또는 실행 취소/다시 실행 기능 구현과 같은 기능에 유용할 수 있습니다.
attribute_tracking.py라는 새 파일을 만듭니다.
class TrackedObject:
def __init__(self, **kwargs):
## Initialize with the provided attributes
self.__dict__.update(kwargs)
## Store the original state
self.__original_state = self.__dict__.copy()
def get_changes(self):
"""Return a dictionary of attributes that have changed"""
changes = {}
for key, current_value in self.__dict__.items():
## Skip the original state attribute itself
if key == '_TrackedObject__original_state':
continue
## Check if the attribute existed originally
if key in self.__original_state:
## Check if the value has changed
if current_value != self.__original_state[key]:
changes[key] = {
'old': self.__original_state[key],
'new': current_value
}
else:
## This is a new attribute
changes[key] = {
'old': None,
'new': current_value
}
## Check for deleted attributes
for key in self.__original_state:
if key not in self.__dict__:
changes[key] = {
'old': self.__original_state[key],
'new': None
}
return changes
def has_changes(self):
"""Check if the object has any changes"""
return len(self.get_changes()) > 0
def reset(self):
"""Reset the object to its original state"""
## Remove all current attributes
for key in list(self.__dict__.keys()):
if key != '_TrackedObject__original_state':
del self.__dict__[key]
## Add back the original attributes
for key, value in self.__original_state.items():
self.__dict__[key] = value
## Create a tracked object
user = TrackedObject(name="Linda", email="linda@example.com", age=31)
## Print the original state
print("Original state:")
print(user.__dict__)
## Make some changes
user.age = 32
user.email = "linda.new@example.com"
user.address = "123 Main St"
del user.name
## Check for changes
print("\nAfter changes:")
print(user.__dict__)
print("\nDetected changes:")
changes = user.get_changes()
for attr, change in changes.items():
print(f"{attr}: {change['old']} -> {change['new']}")
print(f"\nHas changes: {user.has_changes()}")
## Reset to original state
user.reset()
print("\nAfter reset:")
print(user.__dict__)
print(f"Has changes: {user.has_changes()}")
- 파일을 실행합니다.
python3 attribute_tracking.py
이 예제는 __dict__를 사용하여 속성 추적을 구현하는 방법을 보여줍니다. 이는 양식 유효성 검사, 상태 관리 또는 실행 취소/다시 실행 기능 구현과 같은 많은 응용 프로그램에서 유용할 수 있습니다.
__dict__ 속성은 Python 의 객체 지향 프로그래밍 무기고에서 강력한 도구입니다. 작동 방식과 효과적으로 사용하는 방법을 이해하면 더 유연하고 동적이며 유지 관리 가능한 Python 코드를 만들 수 있습니다.
__dict__를 사용한 미니 프로젝트 구축: 연락처 관리자
__dict__ 속성의 다양한 응용 프로그램을 탐구했으므로, 간단한 연락처 관리자 응용 프로그램을 구축하여 지식을 실천에 옮겨 보겠습니다. 이 미니 프로젝트는 실제 시나리오에서 __dict__를 사용하는 방법을 보여줍니다.
연락처 관리자 응용 프로그램
연락처 관리자를 통해 다음을 수행할 수 있습니다.
- 다양한 속성을 가진 연락처 추가
- 연락처 검색
- 연락처 정보 업데이트
- 연락처 삭제
- 연락처를 JSON 으로 내보내기
- JSON 에서 연락처 가져오기
1 단계: Contact 및 ContactManager 클래스 생성
contact_manager.py라는 새 파일을 만듭니다.
import json
import os
class Contact:
def __init__(self, name, email=None, phone=None, **kwargs):
self.name = name
self.email = email
self.phone = phone
## Add any additional attributes
for key, value in kwargs.items():
self.__dict__[key] = value
def update(self, **kwargs):
"""Update contact attributes"""
self.__dict__.update(kwargs)
def __str__(self):
"""String representation of the contact"""
attrs = []
for key, value in self.__dict__.items():
if value is not None:
attrs.append(f"{key}: {value}")
return ", ".join(attrs)
class ContactManager:
def __init__(self):
self.contacts = []
def add_contact(self, contact):
"""Add a new contact"""
self.contacts.append(contact)
print(f"Added contact: {contact.name}")
def find_contact(self, **kwargs):
"""Find contacts matching the criteria"""
results = []
for contact in self.contacts:
match = True
for key, value in kwargs.items():
## Skip if the contact doesn't have this attribute
if key not in contact.__dict__:
match = False
break
## Skip if the attribute value doesn't match
if contact.__dict__[key] != value:
match = False
break
if match:
results.append(contact)
return results
def update_contact(self, contact, **kwargs):
"""Update a contact's attributes"""
contact.update(**kwargs)
print(f"Updated contact: {contact.name}")
def delete_contact(self, contact):
"""Delete a contact"""
if contact in self.contacts:
self.contacts.remove(contact)
print(f"Deleted contact: {contact.name}")
else:
print("Contact not found.")
def export_contacts(self, filename):
"""Export contacts to a JSON file"""
contacts_data = []
for contact in self.contacts:
contacts_data.append(contact.__dict__)
with open(filename, 'w') as f:
json.dump(contacts_data, f, indent=2)
print(f"Exported {len(self.contacts)} contacts to {filename}")
def import_contacts(self, filename):
"""Import contacts from a JSON file"""
if not os.path.exists(filename):
print(f"File {filename} not found.")
return
with open(filename, 'r') as f:
contacts_data = json.load(f)
imported_count = 0
for data in contacts_data:
## Create a copy of the data to avoid modifying the original
contact_data = data.copy()
## Get the required parameters
name = contact_data.pop('name', None)
email = contact_data.pop('email', None)
phone = contact_data.pop('phone', None)
if name:
## Create a new contact with remaining attributes as kwargs
contact = Contact(name, email, phone, **contact_data)
self.contacts.append(contact)
imported_count += 1
print(f"Imported {imported_count} contacts from {filename}")
def print_all_contacts(self):
"""Print all contacts"""
if not self.contacts:
print("No contacts found.")
return
print(f"\nAll Contacts ({len(self.contacts)}):")
print("-" * 40)
for i, contact in enumerate(self.contacts, 1):
print(f"{i}. {contact}")
print("-" * 40)
## Let's test our contact manager
if __name__ == "__main__":
## Create a contact manager
manager = ContactManager()
## Add some contacts
manager.add_contact(Contact("John Doe", "john@example.com", "555-1234",
address="123 Main St", city="Boston"))
manager.add_contact(Contact("Jane Smith", "jane@example.com", "555-5678",
company="ABC Corp", role="Developer"))
manager.add_contact(Contact("Bob Johnson", "bob@example.com", "555-9012",
twitter="@bobjohnson", birthday="1985-03-15"))
## Print all contacts
manager.print_all_contacts()
## Find contacts
print("\nContacts with email ending with @example.com:")
for contact in manager.contacts:
if contact.email and contact.email.endswith("@example.com"):
print(f"- {contact.name}: {contact.email}")
## Use the find_contact method
print("\nFinding contacts by name:")
results = manager.find_contact(name="Jane Smith")
for contact in results:
print(f"Found: {contact}")
## Update a contact
if results:
manager.update_contact(results[0], phone="555-NEW-NUM", role="Senior Developer")
print(f"After update: {results[0]}")
## Export contacts to JSON
manager.export_contacts("contacts.json")
## Delete a contact
manager.delete_contact(results[0])
## Print all contacts after deletion
manager.print_all_contacts()
## Create a new manager and import contacts
print("\nCreating a new manager and importing contacts:")
new_manager = ContactManager()
new_manager.import_contacts("contacts.json")
new_manager.print_all_contacts()
- 파일을 실행합니다.
python3 contact_manager.py
연락처 추가, 찾기, 업데이트 및 삭제, JSON 파일로 연락처 내보내기 및 가져오기를 포함하여 연락처 관리자가 작동하는 것을 보여주는 출력을 볼 수 있습니다.
2 단계: 사용자 지정 기능을 사용하여 연락처 관리자 확장
이제 다양한 유형의 연락처에 대한 사용자 지정 필드를 추가하는 기능을 추가하여 연락처 관리자를 향상시켜 보겠습니다.
extended_contact_manager.py라는 새 파일을 만듭니다.
from contact_manager import Contact, ContactManager
class BusinessContact(Contact):
def __init__(self, name, email=None, phone=None, company=None, role=None, **kwargs):
super().__init__(name, email, phone, **kwargs)
self.company = company
self.role = role
self.contact_type = "business"
class PersonalContact(Contact):
def __init__(self, name, email=None, phone=None, relationship=None, birthday=None, **kwargs):
super().__init__(name, email, phone, **kwargs)
self.relationship = relationship
self.birthday = birthday
self.contact_type = "personal"
class ExtendedContactManager(ContactManager):
def add_business_contact(self, name, email=None, phone=None, company=None, role=None, **kwargs):
contact = BusinessContact(name, email, phone, company, role, **kwargs)
self.add_contact(contact)
return contact
def add_personal_contact(self, name, email=None, phone=None, relationship=None, birthday=None, **kwargs):
contact = PersonalContact(name, email, phone, relationship, birthday, **kwargs)
self.add_contact(contact)
return contact
def find_by_contact_type(self, contact_type):
"""Find contacts by type (business or personal)"""
return self.find_contact(contact_type=contact_type)
def get_contact_details(self, contact):
"""Get detailed information about a contact"""
details = []
for key, value in contact.__dict__.items():
if value is not None:
if key == "contact_type":
details.append(f"Type: {value.capitalize()}")
else:
## Convert key from snake_case to Title Case
formatted_key = " ".join(word.capitalize() for word in key.split("_"))
details.append(f"{formatted_key}: {value}")
return "\n".join(details)
## Test the extended contact manager
if __name__ == "__main__":
## Create an extended contact manager
manager = ExtendedContactManager()
## Add some business contacts
manager.add_business_contact(
"Alice Johnson",
"alice@company.com",
"555-1111",
"XYZ Corp",
"Marketing Manager",
department="Marketing",
office_location="Building A, 3rd Floor"
)
manager.add_business_contact(
"Bob Williams",
"bob@startup.co",
"555-2222",
"StartUp Inc",
"CEO",
linkedin="linkedin.com/in/bobwilliams"
)
## Add some personal contacts
manager.add_personal_contact(
"Carol Davis",
"carol@gmail.com",
"555-3333",
"Friend",
"1990-05-15",
address="456 Oak St",
favorite_restaurant="Italian Place"
)
manager.add_personal_contact(
"Dave Wilson",
"dave@hotmail.com",
"555-4444",
"Family",
"1982-12-03",
emergency_contact=True
)
## Print all contacts
manager.print_all_contacts()
## Find contacts by type
print("\nBusiness Contacts:")
business_contacts = manager.find_by_contact_type("business")
for contact in business_contacts:
print(f"- {contact.name} ({contact.company})")
print("\nPersonal Contacts:")
personal_contacts = manager.find_by_contact_type("personal")
for contact in personal_contacts:
print(f"- {contact.name} ({contact.relationship})")
## Show detailed information for a contact
if business_contacts:
print("\nDetailed information for", business_contacts[0].name)
print(manager.get_contact_details(business_contacts[0]))
## Export contacts to JSON
manager.export_contacts("extended_contacts.json")
## Import contacts
new_manager = ExtendedContactManager()
new_manager.import_contacts("extended_contacts.json")
print("\nAfter importing:")
new_manager.print_all_contacts()
## Check if we can still identify contact types after import
imported_business = new_manager.find_by_contact_type("business")
print(f"\nImported {len(imported_business)} business contacts")
imported_personal = new_manager.find_by_contact_type("personal")
print(f"Imported {len(imported_personal)} personal contacts")
- 파일을 실행합니다.
python3 extended_contact_manager.py
이 확장된 연락처 관리자는 __dict__ 속성을 사용하여 다양한 속성을 가진 다양한 유형의 연락처를 처리할 수 있는 유연한 데이터 구조를 만드는 방법을 보여줍니다.
3 단계: 간단한 명령줄 인터페이스 생성
마지막으로 연락처 관리자를 위한 간단한 명령줄 인터페이스를 만들어 보겠습니다.
contact_manager_cli.py라는 새 파일을 만듭니다.
from extended_contact_manager import ExtendedContactManager, BusinessContact, PersonalContact
def print_menu():
print("\n===== Contact Manager =====")
print("1. Add Business Contact")
print("2. Add Personal Contact")
print("3. List All Contacts")
print("4. Find Contact")
print("5. Update Contact")
print("6. Delete Contact")
print("7. Export Contacts")
print("8. Import Contacts")
print("9. Exit")
print("==========================")
def get_contact_details(contact_type):
"""Get contact details from user input"""
details = {}
## Common fields
details['name'] = input("Name: ")
details['email'] = input("Email (optional): ") or None
details['phone'] = input("Phone (optional): ") or None
## Type-specific fields
if contact_type == "business":
details['company'] = input("Company (optional): ") or None
details['role'] = input("Role (optional): ") or None
## Ask for custom fields
print("Add custom fields (leave empty to finish):")
while True:
field_name = input("Field name (or empty to finish): ")
if not field_name:
break
field_value = input(f"{field_name}: ")
details[field_name] = field_value
elif contact_type == "personal":
details['relationship'] = input("Relationship (optional): ") or None
details['birthday'] = input("Birthday (YYYY-MM-DD, optional): ") or None
## Ask for custom fields
print("Add custom fields (leave empty to finish):")
while True:
field_name = input("Field name (or empty to finish): ")
if not field_name:
break
field_value = input(f"{field_name}: ")
details[field_name] = field_value
return details
def select_contact(manager):
"""Let the user select a contact from the list"""
if not manager.contacts:
print("No contacts available.")
return None
print("\nSelect a contact:")
for i, contact in enumerate(manager.contacts, 1):
print(f"{i}. {contact.name}")
try:
selection = int(input("Enter number (0 to cancel): "))
if selection == 0:
return None
if 1 <= selection <= len(manager.contacts):
return manager.contacts[selection - 1]
else:
print("Invalid selection.")
return None
except ValueError:
print("Please enter a valid number.")
return None
def main():
manager = ExtendedContactManager()
while True:
print_menu()
choice = input("Enter your choice (1-9): ")
if choice == '1':
## Add Business Contact
print("\n-- Add Business Contact --")
details = get_contact_details("business")
name = details.pop('name')
email = details.pop('email')
phone = details.pop('phone')
company = details.pop('company')
role = details.pop('role')
manager.add_business_contact(name, email, phone, company, role, **details)
elif choice == '2':
## Add Personal Contact
print("\n-- Add Personal Contact --")
details = get_contact_details("personal")
name = details.pop('name')
email = details.pop('email')
phone = details.pop('phone')
relationship = details.pop('relationship')
birthday = details.pop('birthday')
manager.add_personal_contact(name, email, phone, relationship, birthday, **details)
elif choice == '3':
## List All Contacts
manager.print_all_contacts()
elif choice == '4':
## Find Contact
print("\n-- Find Contact --")
search_term = input("Enter name to search: ")
results = manager.find_contact(name=search_term)
if results:
print(f"\nFound {len(results)} contacts:")
for contact in results:
print(manager.get_contact_details(contact))
print("-" * 30)
else:
print("No contacts found with that name.")
elif choice == '5':
## Update Contact
print("\n-- Update Contact --")
contact = select_contact(manager)
if contact:
print("\nCurrent details:")
print(manager.get_contact_details(contact))
print("\nEnter new details (leave empty to keep current value):")
updates = {}
for key, value in contact.__dict__.items():
if key != "contact_type": ## Don't allow changing the contact type
new_value = input(f"{key} [{value}]: ")
if new_value and new_value != str(value):
updates[key] = new_value
manager.update_contact(contact, **updates)
print("\nContact updated.")
elif choice == '6':
## Delete Contact
print("\n-- Delete Contact --")
contact = select_contact(manager)
if contact:
confirm = input(f"Are you sure you want to delete {contact.name}? (y/n): ")
if confirm.lower() == 'y':
manager.delete_contact(contact)
elif choice == '7':
## Export Contacts
print("\n-- Export Contacts --")
filename = input("Enter filename (default: contacts.json): ") or "contacts.json"
manager.export_contacts(filename)
elif choice == '8':
## Import Contacts
print("\n-- Import Contacts --")
filename = input("Enter filename: ")
manager.import_contacts(filename)
elif choice == '9':
## Exit
print("\nThank you for using Contact Manager!")
break
else:
print("Invalid choice. Please try again.")
if __name__ == "__main__":
main()
- CLI 응용 프로그램을 실행합니다.
python3 contact_manager_cli.py
- 명령줄 인터페이스를 사용하여 연락처를 추가하고, 연락처를 찾고, 연락처를 업데이트하고, 연락처를 내보내기/가져오기를 시도해 보십시오.
이 미니 프로젝트는 Python 에서 유연한 데이터 기반 응용 프로그램을 구축할 때 __dict__ 속성이 얼마나 강력한지 보여줍니다. 연락처 관리자는 연락처에 대한 사용자 지정 필드, JSON 으로의 직렬화 및 역직렬화, 다양한 연락처 유형의 쉬운 관리를 허용하며, 모두 __dict__ 속성을 활용하여 인스턴스 데이터를 동적으로 관리합니다.
이 프로젝트를 통해 다음을 배우게 되었습니다.
__dict__를 사용하여 객체 속성을 저장하고 검색합니다.- 다양한 속성을 처리할 수 있는 유연한 클래스를 만듭니다.
- 객체를 JSON 으로 직렬화 및 역직렬화합니다.
- 동적 속성을 활용하는 간단한 명령줄 응용 프로그램을 구축합니다.
이러한 기술은 데이터 처리 도구에서 웹 응용 프로그램, API 통합에 이르기까지 많은 실제 Python 응용 프로그램에 적용할 수 있습니다.
요약
이 랩에서는 Python 의 강력한 __dict__ 속성을 탐구하고 인스턴스 데이터를 효과적으로 관리하는 데 어떻게 사용할 수 있는지 배웠습니다. 다음은 학습한 내용의 요약입니다.
__dict__이해:__dict__속성이 객체의 인스턴스 변수를 저장하는 딕셔너리이며, 객체 속성에 동적으로 접근하고 조작할 수 있는 방법을 제공한다는 것을 배웠습니다.속성 접근 및 수정: 점 표기법, 직접적인
__dict__조작,setattr()및getattr()과 같은 내장 함수를 포함하여 객체 속성에 접근하고 수정하는 다양한 방법을 발견했습니다.실제 응용: 객체 직렬화, 동적 속성 관리 및 속성 추적을 포함한
__dict__의 실제 응용 프로그램을 탐구했습니다.미니 프로젝트 구축: 유연한 데이터 저장, 직렬화 및 동적 속성 처리를 위해
__dict__속성을 활용하는 연락처 관리자 응용 프로그램을 구축하여 지식을 실천에 옮겼습니다.
__dict__ 속성은 더 유연하고 동적인 Python 코드를 작성하는 데 도움이 되는 강력한 도구입니다. 작동 방식과 효과적으로 사용하는 방법을 이해하면 변화하는 요구 사항에 적응하고 다양한 데이터 구조를 쉽게 처리할 수 있는 응용 프로그램을 만들 수 있습니다.
Python 여정을 계속 진행하면서 __dict__ 속성이 훌륭한 유연성을 제공하지만 신중하게 사용해야 함을 기억하십시오. 많은 경우, 속성, 디스크립터 또는 getattr() 및 setattr()과 같은 내장 함수를 사용하는 것과 같은 더 Python 적인 접근 방식이 더 깔끔하고 유지 관리 가능한 솔루션을 제공할 수 있습니다.
