介绍
Python 的面向对象编程（OOP）特性为开发者提供了强大的工具，以有效管理实例数据。其中一个工具就是 __dict__ 属性，它允许你动态地访问和操作 Python 对象的属性。
在本教程中，我们将探讨 __dict__ 属性的工作原理，并学习各种使用方法，以便在你的 Python 项目中管理实例数据。在完成这个实验后，你将理解如何利用这个特性来创建更灵活、更具动态性的 Python 应用程序。
理解 Python 对象和 __dict__ 属性
让我们从理解 Python 对象如何存储它们的属性，以及如何使用 __dict__ 属性访问它们开始。
Python 中的对象是什么？
在 Python 中，一切皆为对象。对象拥有属性（数据）和方法（函数）。当你从一个类创建对象时，该对象会获得自己的命名空间来存储其属性。
创建一个 Python 类和对象
让我们创建一个简单的 Python 类和对象，开始探索 __dict__ 属性：
-
在 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__ 与点号表示法
虽然两种方法都可以用来访问和修改属性，但在某些情况下，使用 __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()，它们以更符合 Python 习惯的方式提供了类似的功能。
在下一步中，我们将探讨使用 __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 之间的转换变得容易。通过使用 __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 文件和从 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
- 构建一个利用动态属性的简单命令行应用程序
这些技能可以应用于许多实际的 Python 应用程序，从数据处理工具到 Web 应用程序和 API 集成。
总结
在这个实验中，你探索了 Python 中强大的 __dict__ 属性，并学习了如何有效地使用它来管理实例数据。以下是你所学内容的总结：
-
理解
__dict__：你已经了解到__dict__属性是一个字典，它存储对象实例变量，提供了一种动态访问和操作对象属性的方法。 -
访问和修改属性：你已经发现了访问和修改对象属性的各种方法，包括点符号、直接的
__dict__操作以及内置函数，如setattr()和getattr()。 -
实际应用：你已经探索了
__dict__的实际应用，包括对象序列化、动态属性管理和属性跟踪。 -
构建一个迷你项目：你通过构建一个联系人管理器应用程序将你的知识付诸实践，该应用程序利用
__dict__属性进行灵活的数据存储、序列化和动态属性处理。
__dict__ 属性是一个强大的工具，可以帮助你编写更灵活和动态的 Python 代码。通过理解它的工作原理以及如何有效地使用它，你可以创建能够适应不断变化的需求并轻松处理各种数据结构的应用程序。
在你继续你的 Python 之旅时，请记住，虽然 __dict__ 属性提供了极大的灵活性，但应该谨慎使用。在许多情况下，更符合 Python 风格的方法，例如使用属性（properties）、描述符（descriptors）或内置函数（如 getattr() 和 setattr()），可能会提供更清晰、更易于维护的解决方案。
