34、Python面向对象编程：实例操作与应用

Python面向对象编程：实例操作与应用

1. __str__ 方法的使用

在Python中， __str__ 方法是一个特殊的方法，当对象被传递给 print 函数或内置的 str 函数时，会自动调用该方法。例如，在银行账户的示例中，当将账户对象传递给 print 函数时，会调用 BankAccount 类的 __str__ 方法，并显示该方法返回的字符串。

account = bankaccount2.BankAccount(1500.0)
message = str(account)
print(message)

在上述代码中， str(account) 调用了 BankAccount 类的 __str__ 方法，并将返回的字符串赋值给 message 变量，最后通过 print 函数显示出来。

2. 类的实例操作

每个类的实例都有自己的一组数据属性，这些属性属于特定的对象实例，被称为实例属性。可以在一个程序中创建同一个类的多个实例，每个实例都有自己独立的属性。

2.1 创建多个 Coin 类实例

以下是一个创建三个 Coin 类实例的示例代码：

import coin

def main():
    coin1 = coin.Coin()
    coin2 = coin.Coin()
    coin3 = coin.Coin()

    print('I have three coins with these sides up:')
    print(coin1.get_sideup())
    print(coin2.get_sideup())
    print(coin3.get_sideup())
    print()

    print('I am tossing all three coins ...')
    print()
    coin1.toss()
    coin2.toss()
    coin3.toss()

    print('Now here are the sides that are up:')
    print(coin1.get_sideup())
    print(coin2.get_sideup())
    print(coin3.get_sideup())
    print()

main()

在这个示例中，创建了三个 Coin 类的实例 coin1 、 coin2 和 coin3 ，每个实例都有自己的 __sideup 属性。通过调用 toss 方法，可以改变每个硬币的正反面状态。

2.2 创建 CellPhone 类

下面是一个创建 CellPhone 类的示例，该类用于表示手机的信息：

class CellPhone:
    def __init__(self, manufact, model, price):
        self.__manufact = manufact
        self.__model = model
        self.__retail_price = price

    def set_manufact(self, manufact):
        self.__manufact = manufact

    def set_model(self, model):
        self.__model = model

    def set_retail_price(self, price):
        self.__retail_price = price

    def get_manufact(self):
        return self.__manufact

    def get_model(self):
        return self.__model

    def get_retail_price(self):
        return self.__retail_price

这个类包含了手机的制造商、型号和零售价格等属性，以及相应的访问器和修改器方法。

3. 访问器和修改器方法

为了确保对象对其属性的控制，通常将类的所有数据属性设置为私有，并提供公共方法来访问和修改这些属性。

• 访问器方法（Accessor Methods） ：返回类属性的值，但不改变属性的值。例如， CellPhone 类中的 get_manufact 、 get_model 和 get_retail_price 方法。
• 修改器方法（Mutator Methods） ：存储或改变类属性的值。例如， CellPhone 类中的 set_manufact 、 set_model 和 set_retail_price 方法。

4. 将对象存储在列表中

可以将对象存储在列表中，以便对多个对象进行管理。以下是一个将 CellPhone 对象存储在列表中的示例：

import cellphone

def main():
    phones = make_list()
    print('Here is the data you entered:')
    display_list(phones)

def make_list():
    phone_list = []
    print('Enter data for five phones.')
    for count in range(1, 6):
        print('Phone number ' + str(count) + ':')
        man = input('Enter the manufacturer: ')
        mod = input('Enter the model number: ')
        retail = float(input('Enter the retail price: '))
        print()

        phone = cellphone.CellPhone(man, mod, retail)
        phone_list.append(phone)

    return phone_list

def display_list(phone_list):
    for item in phone_list:
        print(item.get_manufact())
        print(item.get_model())
        print(item.get_retail_price())
        print()

main()

在上述代码中， make_list 函数从用户那里获取五个手机的信息，并创建相应的 CellPhone 对象，将这些对象存储在列表中。 display_list 函数则用于显示列表中每个对象的属性。

5. 传递对象作为参数

在开发处理对象的应用程序时，经常需要编写接受对象作为参数的函数和方法。例如，以下是一个接受 Coin 对象作为参数的函数：

def show_coin_status(coin_obj):
    print('This side of the coin is up:', coin_obj.get_sideup())

my_coin = coin.Coin()
show_coin_status(my_coin)

在上述代码中， show_coin_status 函数接受一个 Coin 对象作为参数，并显示该硬币当前朝上的一面。

6. 对象的序列化和反序列化

可以使用 pickle 模块对对象进行序列化和反序列化操作，将对象保存到文件中，以便后续检索。

6.1 序列化对象

以下是一个将 CellPhone 对象序列化并保存到文件中的示例：

import pickle
import cellphone

FILENAME = 'cellphones.dat'

def main():
    again = 'y'
    output_file = open(FILENAME, 'wb')

    while again.lower() == 'y':
        man = input('Enter the manufacturer: ')
        mod = input('Enter the model number: ')
        retail = float(input('Enter the retail price: '))

        phone = cellphone.CellPhone(man, mod, retail)
        pickle.dump(phone, output_file)

        again = input('Enter more phone data? (y/n): ')

    output_file.close()
    print('The data was written to', FILENAME)

main()

6.2 反序列化对象

以下是一个从文件中反序列化 CellPhone 对象的示例：

import pickle
import cellphone

FILENAME = 'cellphones.dat'

def main():
    end_of_file = False
    input_file = open(FILENAME, 'rb')

    while not end_of_file:
        try:
            phone = pickle.load(input_file)
            display_data(phone)
        except EOFError:
            end_of_file = True

    input_file.close()

def display_data(phone):
    print('Manufacturer:', phone.get_manufact())
    print('Model Number:', phone.get_model())
    print('Retail Price: $', format(phone.get_retail_price(), ',.2f'), sep='')
    print()

main()

7. 将对象存储在字典中

字典也可以用于存储自定义类的对象，每个对象作为字典的值，使用特定的键来检索对象。

7.1 创建 Contact 类

以下是一个创建 Contact 类的示例，该类用于存储联系人信息：

class Contact:
    def __init__(self, name, phone, email):
        self.__name = name
        self.__phone = phone
        self.__email = email

    def set_name(self, name):
        self.__name = name

    def set_phone(self, phone):
        self.__phone = phone

    def set_email(self, email):
        self.__email = email

    def get_name(self):
        return self.__name

    def get_phone(self):
        return self.__phone

    def get_email(self):
        return self.__email

    def __str__(self):
        return "Name: " + self.__name + \
               "\nPhone: " + self.__phone + \
               "\nEmail: " + self.__email

7.2 管理联系人信息的程序

以下是一个管理联系人信息的程序示例，该程序使用字典存储 Contact 对象，并提供了查找、添加、修改和删除联系人的功能：

import contact
import pickle

LOOK_UP = 1
ADD = 2
CHANGE = 3
DELETE = 4
QUIT = 5
FILENAME = 'contacts.dat'

def main():
    mycontacts = load_contacts()
    choice = 0

    while choice != QUIT:
        choice = get_menu_choice()

        if choice == LOOK_UP:
            look_up(mycontacts)
        elif choice == ADD:
            add(mycontacts)
        elif choice == CHANGE:
            change(mycontacts)
        elif choice == DELETE:
            delete(mycontacts)

    save_contacts(mycontacts)

def load_contacts():
    try:
        input_file = open(FILENAME, 'rb')
        contact_dct = pickle.load(input_file)
        input_file.close()
    except IOError:
        contact_dct = {}

    return contact_dct

def get_menu_choice():
    print()
    print('Menu')
    print('---------------------------')
    print('1. Look up a contact')
    print('2. Add a new contact')
    print('3. Change an existing contact')
    print('4. Delete a contact')
    print('5. Quit the program')
    print()

    choice = int(input('Enter your choice: '))

    while choice < LOOK_UP or choice > QUIT:
        choice = int(input('Enter a valid choice: '))

    return choice

def look_up(mycontacts):
    name = input('Enter a name: ')
    print(mycontacts.get(name, 'That name is not found.'))

def add(mycontacts):
    name = input('Name: ')
    phone = input('Phone: ')
    email = input('Email: ')

    entry = contact.Contact(name, phone, email)

    if name not in mycontacts:
        mycontacts[name] = entry
        print('The entry has been added.')
    else:
        print('That name already exists.')

def change(mycontacts):
    name = input('Enter a name: ')

    if name in mycontacts:
        phone = input('Enter the new phone number: ')
        email = input('Enter the new email address: ')

        entry = contact.Contact(name, phone, email)
        mycontacts[name] = entry
        print('Information updated.')
    else:
        print('That name is not found.')

def delete(mycontacts):
    name = input('Enter a name: ')

    if name in mycontacts:
        del mycontacts[name]
        print('Entry deleted.')
    else:
        print('That name is not found.')

def save_contacts(mycontacts):
    output_file = open(FILENAME, 'wb')
    pickle.dump(mycontacts, output_file)
    output_file.close()

main()

总结

通过以上示例，我们学习了Python中类的实例操作、对象的存储和传递、对象的序列化和反序列化，以及如何将对象存储在字典中进行管理。这些技术在开发复杂的应用程序时非常有用，可以帮助我们更好地组织和管理数据。

流程图

graph TD;
    A[开始] --> B[加载联系人字典];
    B --> C{选择操作};
    C -- 查找 --> D[查找联系人];
    C -- 添加 --> E[添加联系人];
    C -- 修改 --> F[修改联系人信息];
    C -- 删除 --> G[删除联系人];
    C -- 退出 --> H[保存联系人字典并退出];
    D --> C;
    E --> C;
    F --> C;
    G --> C;

表格

操作	功能
查找	根据姓名查找联系人信息
添加	添加新的联系人信息
修改	修改现有联系人的信息
删除	删除指定姓名的联系人信息
退出	保存联系人字典并退出程序

Python面向对象编程：实例操作与应用

8. 各部分代码功能总结

为了更清晰地理解上述代码的整体结构和各部分的功能，下面以表格形式进行总结：
| 代码模块 | 功能描述 |
| ---- | ---- |
| __str__ 方法使用 | 当对象传递给 print 或 str 函数时，自动调用该方法返回字符串 |
| 创建多个 Coin 类实例 | 创建多个 Coin 对象，每个对象有独立的 __sideup 属性，可调用 toss 方法改变状态 |
| 创建 CellPhone 类 | 表示手机信息，包含制造商、型号、零售价格属性，以及访问器和修改器方法 |
| 访问器和修改器方法 | 访问器返回属性值不改变，修改器存储或改变属性值 |
| 将对象存储在列表中 | 创建多个 CellPhone 对象并存储在列表中，方便管理和显示 |
| 传递对象作为参数 | 编写接受对象作为参数的函数和方法，对对象进行操作 |
| 对象的序列化和反序列化 | 使用 pickle 模块将对象保存到文件和从文件中读取对象 |
| 将对象存储在字典中 | 创建 Contact 类存储联系人信息，使用字典管理联系人，提供查找、添加、修改和删除功能 |

9. 代码操作流程分析

下面以 Contact 类管理联系人信息的程序为例，详细分析其操作流程：

graph LR;
    A[开始] --> B[加载联系人字典];
    B --> C{显示菜单并获取用户选择};
    C -- 查找 --> D[输入姓名查找联系人];
    C -- 添加 --> E[输入姓名、电话、邮箱添加联系人];
    C -- 修改 --> F[输入姓名，再输入新电话和邮箱修改信息];
    C -- 删除 --> G[输入姓名删除联系人];
    C -- 退出 --> H[保存联系人字典并退出];
    D --> C;
    E --> C;
    F --> C;
    G --> C;

具体步骤如下：
1. 加载联系人字典 ：程序启动时，尝试从文件中加载联系人字典。若文件存在，读取字典；若文件不存在，创建空字典。
2. 显示菜单并获取用户选择 ：显示操作菜单，用户输入选择的操作编号。
3. 执行相应操作 ：
- 查找 ：用户输入姓名，程序在字典中查找该联系人，若找到则显示信息，未找到则提示未找到。
- 添加 ：用户输入姓名、电话和邮箱，程序创建 Contact 对象，若姓名不存在于字典中，则添加该对象；若已存在，则提示已存在。
- 修改 ：用户输入姓名，若该姓名存在于字典中，再输入新的电话和邮箱，更新联系人信息；若不存在，则提示未找到。
- 删除 ：用户输入姓名，若该姓名存在于字典中，删除该联系人；若不存在，则提示未找到。
- 退出 ：程序将联系人字典保存到文件中，然后退出。

10. 代码优化建议

虽然上述代码已经实现了基本的功能，但在实际应用中，还可以进行一些优化：
- 错误处理 ：在用户输入数据时，增加更多的错误处理。例如，在输入零售价格或电话号码时，确保输入的是有效的数字或格式。

try:
    retail = float(input('Enter the retail price: '))
except ValueError:
    print('Invalid input for retail price. Please enter a valid number.')

• 用户界面优化 ：可以使用更友好的用户界面，如图形界面（GUI），提高用户体验。Python 中有许多 GUI 库可供选择，如 Tkinter 、 PyQt 等。
• 代码复用 ：将一些通用的功能封装成独立的函数或类，提高代码的复用性。例如，将输入验证的逻辑封装成一个函数。

def validate_input(prompt, input_type):
    while True:
        try:
            if input_type == 'float':
                value = float(input(prompt))
            elif input_type == 'int':
                value = int(input(prompt))
            else:
                value = input(prompt)
            return value
        except ValueError:
            print('Invalid input. Please try again.')

11. 实际应用场景

上述代码所涉及的技术在许多实际应用场景中都有广泛的应用：
- 库存管理系统 ：可以使用 CellPhone 类来管理手机库存，记录每部手机的信息，如制造商、型号、价格等。通过列表或字典存储手机对象，方便进行查找、添加、修改和删除操作。
- 联系人管理软件 ：使用 Contact 类管理联系人信息，用户可以方便地查找、添加、修改和删除联系人。同时，通过序列化和反序列化技术，可以将联系人信息保存到文件中，下次启动程序时加载。
- 游戏开发 ：在游戏开发中， Coin 类可以用于模拟游戏中的道具或角色状态。每个 Coin 对象可以有不同的状态，通过调用方法改变状态，增加游戏的趣味性。

总结与展望

通过本文的学习，我们深入了解了 Python 面向对象编程中类的实例操作、对象的存储和传递、序列化和反序列化等重要技术。这些技术为我们开发复杂的应用程序提供了强大的支持。

在未来的开发中，我们可以进一步拓展这些技术的应用。例如，结合数据库技术，将对象存储到数据库中，实现更高效的数据管理；使用多线程或异步编程技术，提高程序的性能和响应速度。同时，不断优化代码结构和用户界面，提高程序的易用性和可维护性。

流程图

graph LR;
    A[开始] --> B[选择应用场景];
    B -- 库存管理系统 --> C[使用 CellPhone 类管理库存];
    B -- 联系人管理软件 --> D[使用 Contact 类管理联系人];
    B -- 游戏开发 --> E[使用 Coin 类模拟道具或角色状态];
    C --> F[进行增删改查操作];
    D --> F;
    E --> F;
    F --> G[优化代码和用户界面];
    G --> H[结合其他技术拓展功能];

表格

应用场景	涉及类	主要操作
库存管理系统	CellPhone	查找、添加、修改、删除手机信息
联系人管理软件	Contact	查找、添加、修改、删除联系人信息
游戏开发	Coin	改变对象状态，增加游戏趣味性