合集篇–Python面向对象(下)-夜雨聆风

合集篇–Python面向对象(下)

3.17

Python面向对象

1、Python中多态

2、MRO属性或MRO方法

3、面向对象其他特性

4、面向对象中的单例模式

5、Python异常

6、Python内置模块

7、Python中的自定义模块

8、Python中的Package包

9、综合案例

本期内容信息量很大，小伙伴们可以先收藏，方便随时回看哦～

Python中多态

（1）什么是多态

多态指的是一类事物有多种形态。

定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。

① 多态依赖继承

② 子类方法必须要重写父类方法

首先定义一个父类，其可能拥有多个子类对象。当我们调用一个公共方法时，传递的对象不同，则返回的结果不同。

好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！

（2）多态原理图

公共接口service就是多态的体现，随着传入水果对象的不同，能返回不同的结果。

（3）多态代码实现

多态：可以基于继承也可以不基于继承

class Fruit(object):    # 公共方法    def makejuice(self):        print('i can make juice')class Apple(Fruit):    def makejuice(self):        print('i can make  apple juice')class Banana(Fruit):    def makejuice(self):        print('i can make  banana juice')class Orange(Fruit):    def makejuice(self):        print('i can make  orange juice')# 定义公共方法如servicedef service(obj):    obj.makejuice()apple = Apple()banana = Banana()orange = Orange()for i in (apple, banana, orange):    service(i)

MRO属性或MRO方法

MRO(Method Resolution Order)：方法解析顺序，我们可以通过类名.__mro__或类名.mro()获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找到。

class Car(object):    def __init__(self, brand, model, color):        self.brand = brand        self.model = model        self.color = color     def run(self):        print('i can run')class GasolineCar(Car):    def __init__(self, brand, model, color):        super().__init__(brand, model, color)    def run(self):        print('i can run with gasoline')class ElectricCar(Car):    def __init__(self, brand, model, color):        super().__init__(brand, model, color)        # 电池属性        self.battery = 70    def run(self):        print(f'i can run with electric，remain:{self.battery}')print(ElectricCar.__mro__)print(ElectricCar.mro())

说明：有MRO方法解析顺序可知，在类的继承中，当某个类创建了一个对象时，调用属性或方法，首先在自身类中去寻找，如找到，则直接使用，停止后续的查找。如果未找到，继续向上一级继承的类中去寻找，如找到，则直接使用，没有找到则继续向上寻找…直到object类，这就是Python类继承中，其方法解析顺序。

面向对象其他特性

（1）类属性

Python中，属性可以分为实例属性和类属性。

类属性就是类对象中定义的属性，它被该类的所有实例对象所共有。通常用来记录与这类相关的特征，类属性不会用于记录具体对象的特征。

在Python中，一切皆对象。类也是一个特殊的对象，我们可以单独为类定义属性。

class Person(object):    # 定义类属性    count = 0    def __init__(self, name, age):        self.name = name        self.age = agep1 = Person('Tom', 23)p2 = Person('Harry', 26)

（2）类属性代码实现

定义count类属性，用于记录实例化Person类，产生对象的数量。

class Person(object):    # 定义类属性count    count = 0    # 定义一个__init__魔术方法，用于进行初始化操作    def __init__(self, name):        self.name = name        # 对count类属性进行+1操作，用于记录这个Person类一共生成了多少个对象        Person.count += 1# 实例化对象p1p1 = Person('Tom')p2 = Person('Harry')p3 = Person('Ben')# 在类外部输出类属性print(f'我们共使用Person类生成了{Person.count}个实例对象')

（3）类方法

为什么需要类方法，在面向对象中，特别强调数据封装性。所以不建议直接在类的外部对属性进行直接设置和获取。所以我们如果想操作类属性，建议使用类方法。

基本语法：

@classmethoddef 类名称(cls):    pass

类方法需要用修饰器” @classmethod “来标识，告诉解释器这是一个类方法类方法的第一个参数应该是” cls “。

① 有哪一个类调用的方法，方法内的” cls “就是哪一个类的引用。

② 这个参数和示例方法的第一个参数是”self”类似。

③ 提示使用其他名称也可以，不过习惯使用” cls ” 通过类名.调用类方法，调用方法时，不需要传递” cls “参数。

在方法内部① 可以通过”cls.”访问类的属性 ② 也可以通过 “cls.” 调用其他的类方法。

案例：

class Tool(object):    # 定义一个类属性count    count = 0    # 定义一个__init__初始化方法    def __init__(self, name):        self.name = name        Tool.count += 1    # 封装一个类方法，专门实现对Tool.count类属性进行操作    @classmethod    def get_count(cls):        print(f'我们使用Tool类共实例化了{cls.count}个工具')t1 = Tool('斧头')t2 = Tool('榔头')t3 = Tool('铁锹')Tool.get_count()

类方法主要用于操作类属性或类中的其他方法

（4）静态方法

在开发时，如果需要在类中封装一个方法，这个方法：

① 既不需要访问实例属性或者调用实例方法

② 也不需要访问类属性或者调用类方法

这个时候，可以把这个方法封装成一个静态方法

基本语法：

@staticmethoddef 静态方法名():    pass

案例：

# 开发一款游戏class Game(object):    # 开始游戏，打印游戏功能菜单    @staticmethod    def menu():        print('1、开始游戏')        print('2、游戏暂停')        print('3、退出游戏')# 开始游戏、打印菜单Game.menu()

面向对象中的单例模式

（1）什么是设计模式

设计模式就是前人根据实际的问题提出的问题解决方案，我们把这种就称之为设计模式。

（2）单例模式

单例模式是一种常见的设计模式！

所谓的设计模式，不是一种新的语法，而是人们在实际的应用中，面对某种特定的情形而设计出来的某种常见的有效的解决方案，所以，设计模式只是经验的总结！

什么又是单例模式？单例，就是单一实例！

在实际的运用中，存在一些类，只需要实例化一个对象，就可以完成其所有的功能操作。所以，如果我们能够通过某些技巧，使得一个类只能开辟一个对象空间的话，这样就可以节省相应的对象资源，这种模式就叫作单例模式！

应用场景：音乐播放器对象、回收站对象、打印机对象

（3）__new__()方法

在Python中，我们目前已经学了3个魔术方法了，分别是__init__()、__str__()、__del__()，接下来介绍一下__new__()方法。

使用类名()创建对象时，Python的解释器首先会调用__new__方法为对象分配空间。

__new__是一个由object积累提供的内置的静态方法，主要作用有两个：

○ 在内存中为对象分配空间

○ 返回对象的引用

Python解析器获得对象的引用后，将引用作为第一个参数，传递给__init__方法重写__new__方法的代码非常固定，一定要使用return super(). __new__(cls)，否则Python解释器得不到分配了空间的对象引用，就不会调用对象的初始化方法。

__new__方法是一个静态方法，在调用时，要求将自身类信息cls作为参数传递到这个方法中，这个方法属于object类中的一个静态方法。

案例：

# 定义一个播放器类class MusicPlayer(object):    # 重写__new__()魔术方法    def __new__(cls, *args,48 **kwargs):        print('1、开辟内存空间')        print('2、返回实例对象引用地址')        returnsuper().__new__(cls)    def __init__(self, name):        self.name = name# 1、实例化mp1对象mp1 = MusicPlayer('红色的高跟鞋')print(mp1)# 2、实例化mp2对象mp2 = MusicPlayer('春夏秋冬')print(mp2)

（4）单例模式的代码实现

# 定义一个播放器类class MusicPlayer(object):    instance = None    # 重写__new__()魔术方法    def __new__(cls, *args, **kwargs):        # 判断实例化时有没有分配内存空间        if cls.instance is None:            cls.instance = super().__new__(cls)        return cls.instance    def __init__(self, name):        self.name = name# 1、实例化mp1对象mp1 = MusicPlayer('红色的高跟鞋')print(mp1)# 2、实例化mp2对象mp2 = MusicPlayer('春夏秋冬')print(mp2)

注：类属性在内存中是一个特殊的存在，其不用于以前讲过的局部变量（局部变量当函数执行完毕后，其会被内存所销毁）。但是类属性一旦定义，除非对象以及这个类在内存中被销毁了，否则其不会自动销毁。

Python异常

（1）什么是异常

当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的”异常”。

（2）异常演示

# 运算符# print(10/0)# 文件异常f = open('python.txt', 'r')content = f.readlines()print(content)

（3）异常捕获

基本语法：

try:    可能发生错误的代码except(捕获):    如果出现异常执行的代码

try...except主要用于捕获代码运行时异常

案例：

try:    f = open('python.txt', 'r')    content = f.readline()    print(content, end='')except:    f = open('python.txt', 'w', encoding='utf-8')    f.write('发生异常，执行except语句中的代码')f.close()

（4）捕获指定异常

在以上案例代码中，except相当于捕获了所有异常，无论遇到什么错误都会自动执行except中封装的代码。但是有些情况下，我们向针对性的捕获异常，并执行相应的代码。

基本语法：

try:    可能遇到异常的代码except 异常类型:    捕获到对应的错误以后，执行的代码

① 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。

② 一般try下方只放一行尝试执行的代码。

案例：捕获FileNotFoundError异常

try:    print(name)    # print(10/0)except (NameError, ZeroDivisionError) as e:    print(e)

（5）同时捕获多个异常

try:    print(name)    # print(10/0)except (NameError, ZeroDivisionError) as e:    print(e)

（6）捕获未知异常

无论我们在except后面定义多少个异常类型，实际应用中，也可能会出现无法捕获的未知异常。这个时候，我们考虑使用Exception异常类型捕获可能遇到的所有未知异常：

try:    可能遇到的错误代码except Exception as e:    print(e)

案例：打印一个未定义变量，使用Exception异常类进行捕获

try:    print(name)except Exception as e:    print(e)

（7）异常捕获中的else语句

else语句：表示的是如果没有异常要执行的代码

try:    print(1)except Exception as e:    print(e)else:    print('没有异常')

案例：

try:    f = open('python.txt', 'r', encoding='utf-8')except Exception as e:    print(e)else:    content = f.readlines()    print(content, end='')    f.close()

（8）异常捕获中的finally语句

finally表示的是无论是否异常都要执行的代码，例如关闭文件、关闭数据库连接。

try:    f = open('python.txt', 'r')except:    f = open('python.txt', 'w')else:    print('没异常')finally:    print('关闭文件')    f.close()

（9）异常的综合案例

异常的传递

需求：

① 尝试只读方式打开python.txt文件，如果文件存在则读取文件内容，文件不存在则提示用户即可。

② 读取内容要求：尝试循环读取内容，读取过程中如果检测到用户意外终止程序，则except捕获

import timetry:    f = open('python.txt', 'r', encoding='utf-8')try:while True:            content = f.readline()if len(content) == 0:break            time.sleep(3)            print(content, end='')    except:        # Ctrl + C（终端里面，其代表终止程序的继续执行）        print('python.txt未全部读取完成，中断了...')    finally:        f.close()except:    print('python.txt文件未找到...')

python.txt内容：

程序还没运行完后点击暂定后输出结果：

（10）raise抛出自定义异常

在Python中，抛出自定义异常的语法为raise 异常类对象。

需求：密码长度不足，则报异常（用户输入密码，如果输入的长度不足6位，则报错，即抛出自定义异常，并捕获该异常）。

原生方法：

def input_password():    password = input('请输入您的密码，不少于6位：')    iflen(password) < 6:        raise Exception('您的密码长度少于6位')        return    # 如果密码长度正常，则直接显示密码    print(password)input_password()

面向对象抛出自定义异常：

class ShortInputError(Exception):    # length代表输入密码长度，min_length代表ShortInputError最小长度    def __init__(self, length, min_length):        self.length = length        self.min_length = min_length    # 定义一个__str__方法，用于输出字符串信息    def __str__(self):        return f'您输入的密码长度为{self.length}, 不能少于{self.min_length}个字符'try:    password = input('请输入您的密码，不少于6位：')    if len(password) < 6:        raise ShortInputError(len(password), 6)except Exception as e:    print(e)else:    print(f'输入完成，您的密码是{password}')

Python内置模块

（1）什么是Python模块

Python 模块(Module)，是一个Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。模块能定义函数，类和变量，模块里也能包含可执行的代码。

（2）模块的分类

在Python中，模块通常可以分为两大类：内置模块(目前使用的) 和自定义模块

（3）模块的导入方式

import 模块名

from 模块名 import 功能名

from 模块名 import *

import 模块名 as 别名

from 模块名 import 功能名 as 别名

（4）使用import导入模块

基本语法：

import 模块名或import 模块名1, 模块名2,...

使用模块中封装好的方法：

模块名称.方法()

案例：使用import导入math模块

import math# 求数字9的平方根 = 3print(math.sqrt(9))  # 输出结果：3

案例：使用import导入math与random模块

import math, randomprint(math.sqrt(9))print(random.randint(-100, 100))

（5）使用from 模块名 import 功能名

提问：已经有了import导入模块，为什么还需要使用from 模块名 import 功能名这样的导入方式？

答：import代表导入某个或多个模块中的所有功能，但是有些情况下，我们只希望使用这个模块下的某些方法，而不需要全部导入。这个时候就建议采用from 模块名 import 功能名

from 模块名 import *

这个导入方式代表导入这个模块的所有功能（等价于import 模块名）

from math import *

from 模块名 import 功能名（推荐）

from math importsqrt, floor

注意：以上两种方式都可以用于导入某个模块中的某些方法，但是在调用具体的方法时，我们只需要功能名()即可

功能名()

案例：

# from math import *# 或from math importsqrt, floor# 调用方式print(sqrt(9))print(floor(10.88))

（6）使用as关键字为导入模块定义别名

在有些情况下，如导入的模块名称过长，建议使用as关键字对其重命名操作，以后在调用这个模块时，我们就可以使用别名进行操作。

import time as t# 调用方式t.sleep(10)

在Python中，如果给模块定义别名，命令规则建议使用大驼峰。

（7）使用as关键字为导入功能定义别名

from 模块 import 功能名 as 功能名别名

案例：

from time import sleep as sl, time as t# 调用方式print('hello world')sl(10)print('hello python')

（8）扩展：time模块中的time()方法

在Python中，time模块除了sleep方法以外，还有一个方法叫做time()方法。

time.time()

主要功能：就是返回格林制时间到当前的秒数（时间戳）

案例：求运行递归代码的执行时间

import time# 返回：格林制时间到当前时间的秒数start = time.time()# 编写递归函数def func(n):    if n == 10:        return1    return (func(n+1) + 1) * 2print(func(1))end = time.time()print(f'以上代码共执行了{end - start}s')

Python中的自定义模块

（1）什么是自定义模块

在Python中，模块一共可以分为两大类：

内置系统模块和自定义模块

模块的本质：在Python中，模块的本质就是一个Python的独立文件（后缀名.py），里面可以包含全局变量、函数以及类。

注：在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。也就是说自定义模块名必须要符合标识符命名规则。

（2）定义一个自定义模块

案例：

在Python项目中创建一个自定义文件，如my_module1.py

def sum_num(num1, num2):    return num1 + num2

（3）导入自定义模块

import 模块名称或from 模块名称 import 功能名

案例：

import my_module1# 调用my_module1模块中自定义的sum_num方法print(my_module1.sum_num(10, 20))

（4）自定义模块中功能测试

在我们编写完自定义模块以后，最好在模块中对代码进行提前测试，以防止有任何异常。

引入一个魔方方法：__name__，其保存的内存就是一个字符串类型的数据。

随着运行页面的不同，其返回结果也是不同的：

① 如果__name__是在当前页面运行时，其返回结果为__main__

② 如果__name__在第三方页面导入运行时，其返回结果为模块名称

基于以上特性，我们可以把__name__编写在自定义模块中，其语法如下：

if __name__ == '__main__':    # 执行测试代码

__name__魔术方法除了可以在自定义模块中测试使用，还可以用于编写程序的入口：

# 定义一个main方法（入口文件）def main():    # 执行我们要执行的功能    # ① 打印选择菜单    # ② 添加学员信息    # ③ 删除学员信息    # ...# 调用执行入口if __name__ == '__main__':    main()

（5）多模块中功能命名冲突问题

命名冲突

当我们编写了多个模块时，可能在导入到其他页面时，会产生一个问题：全局变量、函数、类出现重名情况，我们把这个情况就称之为“命名冲突”。

如导入my_module2和my_module3，里面都封装了一个func()方法，其在导入以后，my_module3中的func()方法就会覆盖my_module2中的func()方法。

my_module2.py

def func():    print('my_module2中的func方法')

my_module3.py

def func():    print('my_module3中的func方法')

导入到其他Python文件中，测试效果：

from my_module2 import funcfrom my_module3 import funcfunc()

解决方案

① 把所有模块的导入方式都写入文件的最上面，如果发现命名冲突了，马上和模块的开发人员进行功能核对

② 给重名的方法进行as重命名

③ 用import 模块名导入

方法1：

import my_module2import my_module3my_module2.func()my_module3.func()

方法2：

from my_module2 import func as my_module2_funcfrom my_module3 import func as my_module3_funcmy_module2_func()my_module3_func()

（6）模块命名的注意事项

在实际项目开发中，一定要特别注意：我们自定义的模块名称一定不能和系统内置的模块名称相同，否则会导致代码无法正常执行。

举个栗子：定义一个与系统内置模块同名的模块

random.py

# 空代码

test.py

import randomprint(random.randint(-100, 100))

以上代码运行结果：

randint属于random模块的内置方法，不可能存在找不到的情况。之所以出现以上问题的主要原因在于：我们的项目中存在了一个与系统模块同名的模块文件。所以其在引用random模块式，其执行顺序：

引入某个模块 => 当前项目中寻找是否有同名的文件 => 如果找到则直接使用，未找到 => 继续向上寻找 => Python解析器中

如何证明：模块的引用一定是按照你说的这个顺序呢？

答：使用__file__魔术方法

print(random.__file__)

（7）__all__魔术方法

如果一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素。

主要功能：限制使用模块中的某些功能，也就是说你导入后可以使用的方法只能是__all__中封装好的方法。

案例：

my_module.py

__all__ = ['func1']def func1():    print('func1方法')def func2():    print('func2方法')

test.py

from my_module import *func1()func2()  # 报错

这个__all__只针对from xxx import *，其他的正常。

Python中的Package包

（1）什么是包

包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py 文件，那么这个文件夹就称之为包。

（2）包的制作

所有的包文件，默认都会自带一个__init__.py文件。

（3）在包中创建多个模块

在mypackage包中创建多个模块：my_module1和my_module2

my_module1.py

print('my_module1')def func1():print('mypackage包中的my_module1模块的func1方法')

my_module2.py

print('my_module2')def func2():    print('mypackage包中的my_module2模块的func2方法')

（4）在项目代码中导入包Package

方法一：使用import导入包

import 包名.模块名# 调用模块中的方法包名.模块名.方法名()

方法二：使用from导入包

from 包名 import *# 调用模块方法模块名.方法名()

注意：必须在__init__.py文件中添加__all__ = []，控制允许导入的模块列表。

综合案例

（1）系统需求分析

a、需求分析

使用面向对象编程思想完成学员管理系统的开发，具体如下：

① 系统要求：学员数据存储在文件中

② 系统功能：添加学员、删除学员、修改学员信息、查询学员信息、显示所有学员信息、保存学员信息及退出系统等功能。

b、角色分析

在面向对象编程思想中，必须找到要具体实现操作的实体。

通过系统实现添加学员操作

通过系统实现删除学员操作

….

最终可以得出一个结论：这个通讯管理系统，其主要的实体就是通讯录管理系统本身

注意事项

① 为了方便维护代码，一般一个角色一个程序文件

② 项目要有主程序入口，习惯为main.py

c、创建项目

创建类文件 => studentManager.py

创建项目入口文件 => main.py

（2）系统的代码开发

a、学员信息存储代码分析

students = [{}, {}, {}]

学员姓名

学员年龄

学员电话

学员信息（姓名、年龄、电话），可以使用字典来表示。但是我们已经学习了面向对象，其学员信息可以完全用对象来进行实现。

学员（主体） => 属性（姓名、年龄、电话）

b、student.py类文件编写

需求：

学员信息包含：姓名、年龄、电话

添加__str__魔法方法，方便查看学员对象信息

student.py

# 定义一个Student类class Student():    # 定义魔术方法，用于初始化属性信息    def __init__(self, name, age, mobile):        self.name = name        self.age = age        self.mobile = mobile    # 定义魔术方法，用于打印输出学员信息    def __str__(self):        return f'{self.name}, {self.age}, {self.mobile}'

c、编写studentManager.py代码

studentManager.py

class StudentManager(object):    # 定义__init__魔术方法，用于初始化操作    def __init__(self):        # 定义一个列表，将来用于保存所有学员信息        self.student_list = []

未来数据的存储格式如下：

self.student_list = [p1, p2, p3, p4, ...]

d、学员管理系统具体功能说明

需求：

存储数据的位置：文件(student.data)

加载文件数据

修改数据后保存到文件

存储数据的形式：列表存储学员对象

系统功能：

① 添加学员信息

② 删除学员信息

③ 修改学员信息

④ 查询学员信息

⑤ 显示所有学员信息

⑥ 保存学员信息

⑦ 退出系统

编写程序代码，用于实现以上的所有功能：

基础逻辑代码

class StudentManager(object):    # 定义一个__init__魔术方法，用于初始化数据    def __init__(self):        # 初始化一个student_list属性，用于将来保存所有学员对象信息        self.student_list = []    # 定义load_student()方法    def load_student(self):        pass    # 定义静态show_help()方法    @staticmethod    def show_help():        print('-' * 40)        print('传智教育通讯录管理系统V2.0')        print('1.添加学员信息')        print('2.删除学员信息')        print('3.修改学员信息')        print('4.查询学员信息')        print('5.显示所有学员信息')        # V2.0新增功能        print('6.保存学员信息')        print('7.退出系统')        print('-' * 40)    def add_student(self):        pass    def del_student(self):        pass    def mod_student(self):        pass    def show_student(self):        pass    def show_all(self):        pass    def save_student(self):        pass    # 定义一个run()方法，专门用于实现对管理系统中各个功能调用    def run(self):        # 1、调用一个学员加载方法，用于加载文件中的所有学员信息，加载完成后，把得到的所有学员信息保存在student_list属性中        self.load_student()        # 2、显示帮助信息，提示用户输入要实现的功能编号        while True:            # 显示帮助信息            self.show_help()            # 提示用户输入要操作功能编号            user_num = int(input('请输入要操作功能的编号：'))            if user_num == 1:                self.add_student()            elif user_num == 2:                self.del_student()            elif user_num == 3:                self.mod_student()            elif user_num == 4:                self.show_student()            elif user_num == 5:                self.show_all()            elif user_num == 6:                self.save_student()            elif user_num == 7:                print('感谢您使用传智教育通讯录管理系统V2.0，欢迎下次使用！')                break            else:                print('信息输入错误，请重新输入...')

main.py入口文件的编写

# 从studentManager模块中导入StudentManager类功能from studentManager import StudentManager# 定义入口代码if __name__ == '__main__':    student_manager = StudentManager()    student_manager.run()

编写add_student()学员添加方法实现

需求：用户输入学员姓名、年龄、手机号，将学员添加到系统。

步骤：

① 用户输入姓名、年龄、手机号

② 创建该学员对象（真正添加到列表中的是对象）

③ 将该学员对象添加到列表[] => append()

 from student import Student  ...        ...    ...    def add_student(self):        # 提示用户输入学员信息        name = input('请输入学员的姓名：')        age = int(input('请输入学员的年龄：'))        mobile = input('请输入学员的电话：')        # 使用Student类实例化对象        student = Student(name, age, mobile)        # 调用student_list属性，追加student对象信息        self.student_list.append(student)        print('学员信息已添加成功')

编写del_student()学员删除方法实现

需求：用户输入目标学员姓名，如果学员存在则删除该学员。

步骤：

① 用户输入目标学员姓名

② 遍历学员数据列表，如果用户输入的学员姓名存在则删除，否则则提示该学员不存在。

def del_student(self):        # 提示用户输入要删除的学员姓名        name = input('请输入要删除的学员姓名：')        # 对student_list属性（本质列表）进行遍历        for i in self.student_list:            if i.name == name:                # 找到了要删除的学员，删除                self.student_list.remove(i)                print(f'学员{name}信息删除成功')                break        else:            print('您要删除的学员不存在...')

编写mod_student()学员修改方法实现

def mod_student(self):        # 提示用户输入要修改的学员姓名        name = input('请输入要修改的学员姓名：')        # 对student_list属性进行遍历，判断要修改的学员姓名是否存在        for i in self.student_list:            if i.name == name:                i.name = input('请输入修改后的学员姓名：')                i.age = int(input('请输入修改后的学员年龄：'))                i.mobile = input('请输入修改后的学员电话：')                print(f'学员信息修改成功，修改后信息如下 => 学员姓名：{i.name}，学员年龄：{i.age}，学员电话：{i.mobile}')                break        else:            print('您要修改的学员信息不存在...')

编写show_student()学员查询方法实现

def show_student(self):        # 提示用户输入要查询的学员姓名        name = input('请输入要查询的学员姓名：')        # 对student_list属性进行遍历        for i in self.student_list:            if i.name == name:                print(i)                break        else:            print('您要查找的学员信息不存在...')

编写show_all()方法查询所有学员实现

def show_all(self):        # 直接对列表进行遍历        for i in self.student_list:            print(i)

编写save_student()方法学员信息保存功能实现

需求：将所有学员信息都保存到存储数据的文件。

步骤：

① 打开文件 ② 读写文件 ③ 关闭文件

思考：

① 文件写入的数据是学员对象的内存地址吗？

答：一定不能是对象的内存地址，因为随着系统的运行，内存地址可能会随时改变。

② 文件内数据要求的数据类型是什么？答：必须是字符串，可以使用str()转换

扩展：把对象转换为dict字典格式 => __dict__

class A(object):    a = 0    def __init__(self):        self.b = 1aa = A()# 返回实例属性和值组成的字典print(aa.__dict__)

案例：demo.py

from student import Studentstudent_list = []student = Student('Tom', 23, '10086')student_list.append(student)print(student.__dict__)  # {'name': 'Tom', 'age': 23, 'mobile': '10086'}

案例：把[对象1, 对象2, 对象3]中的所有对象都转换为字典

from student import Studentstudent_list = []student = Student('Tom', 23, '10086')student_list.append(student)student = Student('Harry', 25, '10010')student_list.append(student)# [student1, student2, student3, ...]# list1 = []# for i in student_list:#     list1.append(i.__dict__)# print(list1)list1 = [i.__dict__ for i in student_list]print(list1)

最终代码：

# 把self.student_list转换为字符串保存到student.data文件中    def save_student(self):        # 打开文件        f = open('student.data', 'w', encoding='utf-8')        # 把列表中的对象转换为字典        new_list = [i.__dict__ for i in self.student_list]        # 文件读写（写入）        f.write(str(new_list))        # 关闭文件        f.close()        # 提示用户数据已经保存成功了        print('学员信息保存成功')

编写load_student()方法学员加载功能实现

load_student()方法的作用：在系统启动以后，运行run()方法以后，把student.data文件中保存好的学员信息 => 加载 => self.student_list列表中

student.data => 张三、李四、王五

下次重新运行系统

self.student_list = [张三, 李四, 王五]

添加赵六

self.student_list = [张三, 李四, 王五, 赵六]

需求：每次进入系统后，修改的数据是文件里面的数据

步骤：

☆ 尝试以”r”模式打开学员数据文件，如果文件不存在则以”w”模式打开文件

① 如果文件存在则读取数据

② 读取数据 => str字符串类型 [{}, {}, {}]

③ 转换数据类型为列表并转换列表内的字典i[‘name’]为对象i.name

④ 存储学员数据到学员列表self.student_list

☆ 关闭文件

# 定义load_student()方法    def load_student(self):        # 捕获异常        try:            f = open('student.data', 'r', encoding='utf-8')        except:            f = open('student.data', 'w', encoding='utf-8')        else:            # 如果文件存在，没有异常，则执行else语句            content = f.read()            # 把字符串转换为原数据类型[{}, {}, {}]            data = eval(content)            # 把列表中的所有字典 => 转换为对象            self.student_list = [Student(i['name'], i['age'], i['mobile']) for i in data]        finally:            f.close()

合集篇–Python面向对象(下)

wang

猜你喜欢