目录：
- 面向对象
- 继承
- 多态
- 异常
- 模块与包
- 面向对象应用
1. 面向对象
#封装：将属性和方法写到类达里面的操作 / 可以为属性和方法添加私有属性
#1)类和对象：用类去创建一个对象/用类实例化对象
print('类和对象：')
#1.定义类
class Washer():
def wash(self):
#self指的是调用该函数的对象
print('能洗衣服')
print(self) #<__main__.Washer object at 内存地址>
def print_info(self):
'''self.属性名'''
#3.2)在类的内部添加对象属性/实例属性
print(f'类的内部：洗衣机的宽度是：{self.width}，洗衣机的高度是：{self.height}')
#2.创建对象
haier1 = Washer()
print(haier1) #<__main__.Washer object at 内存地址>同self
#3.使用对象
haier1.wash() #实例方法/对象方法
#2)用一个类去创建多个对象
haier2 = Washer()
print(haier2) #用一个类创建多个对象时，self地址不相同
haier2.wash()
#3.1)在类的外部添加对象属性
haier1.width = 400
haier1.height = 500
print(f'类的外部：洗衣机的宽度是：{haier1.width}，洗衣机的高度是：{haier1.height}')
#3.2)在类的内部添加对象属性
haier1.print_info() #__main__已经添加实例属性
#4)魔法方法
print('\n魔法方法：')
#1.__init__() #初始化对象
print('1.__init__()：',end='')
class Firer():
def __init__(self):
#添加实例属性
self.width = 300
self.height = 200
def print_info1(self):
#类里面调用实例属性
print(f'微波炉机的宽度是：{self.width}，微波炉的高度是：{self.height}')
xiaomi1 = Firer()
xiaomi1.print_info1()
#2.带参数的__init__()
print('2.带参数的__init__()：',end='')
class Firer2():
def __init__(self,width,height):
self.width = width
self.height = height
def print_info2(self):
print(f'微波炉机的宽度是：{self.width}，微波炉的高度是：{self.height}')
xiaomi2 = Firer2(20,30)
xiaomi2.print_info2()
#3.__str__() #解释说明
print('3.__str__()：',end='')
class Firer3():
def __init__(self):
self.width = 300
def __str__(self):
return '解释说明：类的说明或对象状态的说明'
xiaomi3 = Firer3()
print(xiaomi3) #默认打印对象的内存地址，如果类定义了__str__方法，则打印该方法的return数据
#4.__del__() #删除对象时调用
print('4.__del__()：',end='')
class Firer4():
def __init__(self):
self.width = 300
def __del__(self):
print('对象已经删除')
xiaomi4 = Firer4()
del xiaomi4
#5)综合应用
#1.烤地瓜
print('\n烤地瓜：')
class SweetPotato():
def __init__(self):
#被烤的时间
self.cook_time = 0
#烤的状态
self.cook_state = '生的'
#调料列表
self.condiments = []
def cook(self,time):
"""烤地瓜的方法"""
self.cook_time += time #烤地瓜整体烤过的时间
if (0 <= self.cook_time < 3):
self.cook_state = '生的'
if (3 <= self.cook_time < 5):
self.cook_state = '半生不熟'
if (5 <= self.cook_time < 8):
self.cook_state = '熟了'
elif(self.cook_time >= 8):
self.cook_state = '糊了'
def add_condiments(self,condiment):
"""添加的调料"""
self.condiments.append(condiment)
def __str__(self):
"""输出对象状态"""
return (f'这个地瓜被烤的时间是：{self.cook_time}，状态是：{self.cook_state}，调料有{self.condiments}')
potato1 = SweetPotato()
print(potato1) #__init__()：cook_time = 0
potato1.cook(2) #cook_time = 2
potato1.add_condiments('胡椒') #condiments['胡椒']
print(potato1)
potato1.cook(2) #cook_time = 4
potato1.add_condiments('花生油') #condiments['胡椒','花生油']
print(potato1)
#2.搬家具
print('\n搬家具：')
class Furniture():
def __init__(self,name,area):
#家具名字
self.name = name
#家具占地面积
self.area = area
class House():
def __init__(self,address,area):
#地理位置
self.address = address
#房屋面积
self.area = area
#剩余面积
self.free_area = area
#家具列表
self.furniture = []
def __str__(self):
return (f'房子地理位置在{self.address}，房屋面积是{self.area}，房屋剩余面积{self.free_area}，家具有{self.furniture}')
def add_furniture(self,furniture): #item是Furniture类的对象
"""容纳家具"""
#如果家具占地面积 <= 房屋剩余面积： 可以搬入
if (furniture.area <= self.free_area):
self.furniture.append(furniture.name) #添加家具
self.free_area -= furniture.area #房屋剩余面积 = 房屋面积 - 家具面积
else:
print(f'{furniture.name}占地面积太大，房屋无法容纳')
#家具
bed = Furniture('双人床',6)
sofa = Furniture('沙发',10)
piano = Furniture('钢琴',100)
#房子
house = House('深圳',100)
print(house)
#添加家具
house.add_furniture(bed)
print(house)
house.add_furniture(sofa)
print(house)
house.add_furniture(piano)
print(house)
#扩展：__dict__
print('\n扩展：__dict__')
#1.定义类
class A(object):
a = 0
def __init__(self):
self.b = 1
#2.创建对象
aa = A()
#3.调用__dict__
print('1.类：')
print(A.__dict__) #返回类内部所有属性和方法对应的字典
print('2.实例：')
print(aa.__dict__) #返回实例属性和值组成的字典输出结果：
2. 继承
#继承：子类默认继承父类的所有属性和方法 / 子类可以重写父类属性和方法
#经典类：class 类名 / 新式类：class 类名(object)
#父类A
class A(object):
def __init__(self):
self.num = 1
def info_print(self):
print(self.num)
#子类B
class B(A):
pass
result = B()
result.info_print() #1，说明B继承了A
#1)单继承
print('1)单继承：')
#师父类
class Master1(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student1(Master1):
pass
Bruce = Student1()
print(Bruce.kungfu) #[咏春]
Bruce.fight() #在下[咏春]，请赐教
#2)多继承
print('\n2)多继承：')
#师父类
class Master2(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#学校类
class School2(object):
def __init__(self):
self.kungfu = '[扫地]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student2(School2,Master2):
pass
Lee = Student2()
print(Lee.kungfu) #一个类继承多个父类时，默认使用第一个父类的同名属性和方法
Lee.fight()
#3)子类重写父类同名方法和属性
print('\n3)子类重写父类同名方法和属性：')
#师父类
class Master3(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#学校类
class School3(object):
def __init__(self):
self.kungfu = '[扫地]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student3(School3,Master3):
def __init__(self):
self.kungfu = '[自学]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
Bruce_Lee = Student3()
print(Bruce_Lee.kungfu) #子类重写父类同名方法和属性，优先调用子类的同名方法和属性
Bruce_Lee.fight()
#4)mro顺序
print('\n4)mro顺序：') #查看继承关系、顺序
print(Student3.__mro__) #(<class '__main__.Student3'>, <class '__main__.School3'>, <class '__main__.Master3'>, <class 'object'>)
#5)子类调用父类的同名方法和属性
print('\n5)子类调用父类的同名方法和属性：')
#师父类
class Master5(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#学校类
class School5(object):
def __init__(self):
self.kungfu = '[扫地]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student5(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
def fight(self):
#如果先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用属性前，先调用自己子类的初始化
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
#调用父类方法，为了保证调用到的是父类的属性，必须在调用方法前调用父类的初始化
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
Lee_Bruce = Student5()
Lee_Bruce.fight() #自学
Lee_Bruce.school_fight() #调用School的同名方法和属性
Lee_Bruce.master_fight() #调用Master的同名方法和属性
Lee_Bruce.fight() #自学，120行的作用
#6)多层继承
print('\n6)多层继承：')
#徒孙类
class LittleStudent6(Student5):
pass
Ye = LittleStudent6()
Ye.fight()
Ye.master_fight()
#7)super()调用父类方法
print('\n7)super()调用父类方法：')
#徒弟类
class Student7(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
def fight(self):
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
#一次性调用父类School5和Master5的方法
#方法1：代码量大，冗余
def complex_fight1(self):
School5.__init__(self)
School5.fight(self)
Master5.__init__(self)
Master5.fight(self)
#方法2：super(当前类名,self).函数()
def complex_fight2(self):
super(Student7,self).__init__() #调用父类方法，优先调用第一个父类的方法
super(Student7,self).fight()
#方法3：无参数super().函数()
def complex_fight3(self):
super().__init__() #调用父类方法，优先调用第一个父类的方法
super().fight()
Wen = Student7()
print('方法1：')
Wen.complex_fight1()
print('方法2：')
Wen.complex_fight2()
print('方法3：')
Wen.complex_fight3()
#8)私有权限
print('\n8)私有权限：') #__前缀
#徒弟类
class Student8(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
self.__money = 88888888 #私有属性
def __info_print(self): #私有方法
print('这是独门秘籍')
def fight(self):
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
#徒孙类
class Little_Student8(Student8):
pass
Lee_Dragon = Student8()
Dragon_Lee = Little_Student8()
#print(Lee_Dragon.__money)
#print(Dragon_Lee.__money)
print('私有属性和私有方法只能在自己的类内部使用')
#9)获取和修改私有属性值
print('\n9)获取和修改私有属性值：')
#徒弟类
class Student9(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
self.__money = 88888888 #私有属性
#获取私有属性
def get_money(self):
return self.__money
#修改私有属性
def set_money(self):
self.__money = 666666
def __info_print(self): #私有方法
print('这是独门秘籍')
def fight(self):
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
#徒孙类
class Little_Student9(Student9):
pass
Little_Dragon = Little_Student9()
print(Little_Dragon.get_money()) #88888888
Little_Dragon.set_money() #__money -> 666666
print(Little_Dragon.get_money()) #666666输出结果：
3. 多态
#继承：子类默认继承父类的所有属性和方法 / 子类可以重写父类属性和方法
#经典类：class 类名 / 新式类：class 类名(object)
#父类A
class A(object):
def __init__(self):
self.num = 1
def info_print(self):
print(self.num)
#子类B
class B(A):
pass
result = B()
result.info_print() #1，说明B继承了A
#1)单继承
print('1)单继承：')
#师父类
class Master1(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student1(Master1):
pass
Bruce = Student1()
print(Bruce.kungfu) #[咏春]
Bruce.fight() #在下[咏春]，请赐教
#2)多继承
print('\n2)多继承：')
#师父类
class Master2(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#学校类
class School2(object):
def __init__(self):
self.kungfu = '[扫地]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student2(School2,Master2):
pass
Lee = Student2()
print(Lee.kungfu) #一个类继承多个父类时，默认使用第一个父类的同名属性和方法
Lee.fight()
#3)子类重写父类同名方法和属性
print('\n3)子类重写父类同名方法和属性：')
#师父类
class Master3(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#学校类
class School3(object):
def __init__(self):
self.kungfu = '[扫地]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student3(School3,Master3):
def __init__(self):
self.kungfu = '[自学]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
Bruce_Lee = Student3()
print(Bruce_Lee.kungfu) #子类重写父类同名方法和属性，优先调用子类的同名方法和属性
Bruce_Lee.fight()
#4)mro顺序
print('\n4)mro顺序：') #查看继承关系、顺序
print(Student3.__mro__) #(<class '__main__.Student3'>, <class '__main__.School3'>, <class '__main__.Master3'>, <class 'object'>)
#5)子类调用父类的同名方法和属性
print('\n5)子类调用父类的同名方法和属性：')
#师父类
class Master5(object):
def __init__(self):
self.kungfu = '[咏春]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#学校类
class School5(object):
def __init__(self):
self.kungfu = '[扫地]'
def fight(self):
print(f'在下{self.kungfu}，请赐教')
#徒弟类
class Student5(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
def fight(self):
#如果先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用属性前，先调用自己子类的初始化
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
#调用父类方法，为了保证调用到的是父类的属性，必须在调用方法前调用父类的初始化
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
Lee_Bruce = Student5()
Lee_Bruce.fight() #自学
Lee_Bruce.school_fight() #调用School的同名方法和属性
Lee_Bruce.master_fight() #调用Master的同名方法和属性
Lee_Bruce.fight() #自学，120行的作用
#6)多层继承
print('\n6)多层继承：')
#徒孙类
class LittleStudent6(Student5):
pass
Ye = LittleStudent6()
Ye.fight()
Ye.master_fight()
#7)super()调用父类方法
print('\n7)super()调用父类方法：')
#徒弟类
class Student7(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
def fight(self):
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
#一次性调用父类School5和Master5的方法
#方法1：代码量大，冗余
def complex_fight1(self):
School5.__init__(self)
School5.fight(self)
Master5.__init__(self)
Master5.fight(self)
#方法2：super(当前类名,self).函数()
def complex_fight2(self):
super(Student7,self).__init__() #调用父类方法，优先调用第一个父类的方法
super(Student7,self).fight()
#方法3：无参数super().函数()
def complex_fight3(self):
super().__init__() #调用父类方法，优先调用第一个父类的方法
super().fight()
Wen = Student7()
print('方法1：')
Wen.complex_fight1()
print('方法2：')
Wen.complex_fight2()
print('方法3：')
Wen.complex_fight3()
#8)私有权限
print('\n8)私有权限：') #__前缀
#徒弟类
class Student8(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
self.__money = 88888888 #私有属性
def __info_print(self): #私有方法
print('这是独门秘籍')
def fight(self):
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
#徒孙类
class Little_Student8(Student8):
pass
Lee_Dragon = Student8()
Dragon_Lee = Little_Student8()
#print(Lee_Dragon.__money)
#print(Dragon_Lee.__money)
print('私有属性和私有方法只能在自己的类内部使用')
#9)获取和修改私有属性值
print('\n9)获取和修改私有属性值：')
#徒弟类
class Student9(School5,Master5):
def __init__(self):
self.kungfu = '[自学]'
self.__money = 88888888 #私有属性
#获取私有属性
def get_money(self):
return self.__money
#修改私有属性
def set_money(self):
self.__money = 666666
def __info_print(self): #私有方法
print('这是独门秘籍')
def fight(self):
self.__init__()
print(f'在下{self.kungfu}，请赐教')
def master_fight(self):
Master5.__init__(self)
Master5.fight(self)
def school_fight(self):
School5.__init__(self)
School5.fight(self)
#徒孙类
class Little_Student9(Student9):
pass
Little_Dragon = Little_Student9()
print(Little_Dragon.get_money()) #88888888
Little_Dragon.set_money() #__money -> 666666
print(Little_Dragon.get_money()) #666666输出结果：
4. 异常
import time
#1)捕获异常
print('1)捕获异常：')
#1.1捕获指定异常类型
print('1.1捕获指定异常类型：',end='')
try:
print(num) #可能发生错误的代码
except NameError: #异常类型
print('有错误') #如果捕获到该异常类型执行的代码
#1.2捕获多个指定异常类型
print('1.2捕获多个指定异常类型：',end='')
try:
print(1/0)
except (NameError,ZeroDivisionError): #元组
print('有错误')
#2.1捕获异常描述信息
print('2.1捕获异常描述信息：',end='')
try:
print(1/0)
except (NameError,ZeroDivisionError) as result:
print(result)
#2.2捕获所有异常
print('2.2捕获所有异常：',end='')
try:
print(num)
except Exception as result: #Exceptio是所有程序异常类的父类
print(result)
#2)异常的else
print('\n2)异常的else：')
try:
print(1)
except Exception as result:
print(result)
else: #如果没有异常要执行的代码
print('我是else，当没有异常的时候执行的代码')
#3)异常finally
print('\n3)异常finally：')
try:
print(num) #可能发生错误的代码
except Exception as error:
print(f'try程序错误，错误信息是：{error}')
else:
print('try程序没有错误')
finally:
print('try程序有错没错我都要执行')
#4)异常的传递
print('\n4)异常的传递：')
try:
f = open('python.txt')
try:
while True:
content = f.readline() #逐行读'python.py'文件
if (len(content) == 0):
break
time.sleep(1) #间隔1秒钟
print(content)
except:
#如果在读取文件的过程中，产生了异常，那么就会捕获到
#比如按下了 Ctrl + C
print('意外地终止了读取数据')
finally:
f.close()
print('关闭文件')
except:
print('没有这个文件')
#5)自定义异常
print('\n5)自定义异常：') #raise 异常类对象
#自定义异常类，继承Exception
class ShortInputError(Exception): #输入密码太短
def __init__(self,length,min_len):
self.length = length
self.min_len = min_len
#设置抛出异常的描述信息
def __str__(self):
return (f'你输入的长度是{self.length}，不能少于{self.min_len}个字符') #result
def main():
try:
content = input('请输入密码，长度不小于3：')
if len(content) < 3: #如果密码长度小于3
raise ShortInputError(len(content),3)
except Exception as result:
print(f'错误信息是：{result}') #__str__
else:
print('密码输入完成')
main()输出结果：
5. 模块与包
#模块Module是一个Python文件，以.py结尾，包含了Python对象定义和Python语句
#1)导入模块
print('1)导入模块：')
#1.import 模块名
print('1.方法①：',end ='')
import math
print(math.sqrt(9)) #开方3.0
#2.from 模块名 import 功能1,功能2,功能3...
print('2.方法②：',end ='')
from math import ceil
print(ceil(2.4)) #向上取整3
#3.from 模块名 import *
print('3.方法③：',end ='')
from math import *
print(floor(2.6)) #向下取整2
#4.import 模块名 as 别名
print('4.模块别名：',end ='')
import time as tt
tt.sleep(2) #等待2秒钟
print('hello wor1d')
#print(time.sleep(2)) #模块名time失效
#print('hello wor2d')
#5.from 模块名 import 功能名 as 别名
print('5.功能别名：',end ='')
from random import randint as other
print(other(0,2))
#print(randint(0,2)) #功能名randint失效
#2)制作模块
print('\n2)制作模块：')
import python23_mymodule1 #导入自定义模块
python23_mymodule1.add_num(2,2) #4
#模块定位顺序：
#自己的文件名不要和已有的模块名重复，否则导致模块功能无法使用
#使用'from 模块名 import 功能'时，如果功能名重复，调用到的是 最后定义或导入的功能
#3)__all__
print('\n3)__all__：')
#如果一个模块文件 有__all__变量，当使用'from xxx import *'导入时，只能导入这个列表中的元素
from python23_mymodule2 import *
testA() #在__all__列表，正常使用
#testB() #不在__all__列表，无法使用
#4)包的使用方法
print('\n4)包的使用方法：') #有联系的模块(文件夹)
#[New]-[Python Package]-输入包名-[OK]-新建功能模块(有联系的模块)
#新建包后，包内部会自动创建__init__.py文件，这个文件控制着包的导入行为
print('1.方法①：')
import python23_mypackage.my_module1
python23_mypackage.my_module1.info_print1() #'my_module1'
print('2.方法②：')
#必须在'__init__.py'文件中添加'__all__ = []'，控制允许导入的模块列表
from python23_mypackage import *
my_module1.info_print1() #'my_module1'，正常使用
#my_module2.info_print2() #不在'__init__.py'文件中__all__列表里，无法使用python23_mymodule1.py文件：
#2)制作模块
#定义功能
def add_num(a,b):
print(a+b)
#测试功能
#__name__是系统变量，是模块的标识符：
#本py模块文件运行时，__name__ == __main__
#在其他py文件运行时，__name__ == '本py模块文件名'
if (__name__ == '__main__'): #在本py模块文件运行下才执行
add_num(1,1)python23_mymodule2.py文件：
#3)__all__
__all__ = ['testA']
def testA():
print('testA')
def testB():
print('testB')python23_mypackage包：
- init.py文件
__all__ = ['my_module1']- my_module1.py文件：
print(1)
def info_print1():
print('my_module1')- my_module2.py文件：
print(2)
def info_print2():
print('my_module2')输出结果：
6. 面向对象应用
- main.py文件：
#导入StudentSystem模块
from StudentSystem import *
#启动学生管理系统
if __name__ == '__main__':
os.chdir('python24_面向对象应用') #改变目录路径：'python24_面向对象应用'文件夹
teacher = StudentSystem()
teacher.run()- Student.py文件：
class Student(object):
def __init__(self,name,sex,tel):
self.name = name
self.sex = sex
self.tel = tel
def __str__(self): #查看学生信息
return (f'姓名是：{self.name}，性别是：{self.sex}，手机号码是：{self.tel}')
#测试
if (__name__ == '__main__'):
aa = Student('Tom','male','12345678900')
print(aa)- StudentSystem.py文件
import os
from Student import *
#1.存储数据的文件(student.data) #加载文件数据 / #修改数据后保存到文件
#2.存储数据的形式：列表存储学员对象
#3.系统功能：#添加学生 #删除学生 #修改学生 #查询学生信息 #显示所有学生信息 #保存学生信息 #退出系统
class StudentSystem(object):
def __init__(self):
#存储数据所用的列表
self.student_list = []
#程序入口函数，启动程序后执行的函数
def run(self):
#1.加载学生信息
self.load_student() #加载'student.txt'文件
while True:
#2.显示菜单
self.show_menu()
#3.用户输入功能序号
menu_num = int(input('请输入要使用的功能序号：'))
#4.根据用户输入的功能序号执行不同的功能
if(menu_num == 1):
#添加学生
self.add_student()
elif(menu_num == 2):
#删除学生
self.del_student()
elif(menu_num == 3):
#修改学生
self.modify_student()
elif(menu_num == 4):
#查询学生信息
self.search_student()
elif(menu_num == 5):
#显示所有学生信息
self.show_student()
elif(menu_num == 6):
#保存学生信息
self.save_student()
elif(menu_num == 7):
#退出系统
break
#系统功能函数
#1.显示功能菜单 -- 打印序号的功能对应关系 --静态方法
@staticmethod
def show_menu():
print('请选择功能--------------------')
print('1.添加学生：')
print('2.删除学生：')
print('3.修改学生：')
print('4.查询学生信息：')
print('5.显示所有学生信息：')
print('6.保存学生信息：')
print('7.退出系统：')
print('-' * 30)
#2.添加学生
def add_student(self):
print('添加学生：')
name = input('请输入姓名：')
sex = input('请输入性别：')
tel = input('请输入手机号：')
student = Student(name,sex,tel)
self.student_list.append(student)
#print(f'所有学生信息：{self.student_list}')
print(f'添加的学生信息是：{student}')
#3.删除学生
def del_student(self):
print('删除学生：')
del_name = input('请输入要删除的学生姓名：')
for i in self.student_list:
if (i.name == del_name):
self.student_list.remove(i)
print(f'删除成功，删除的学生{i}')
break
else:
print('该学生不存在！')
#print(f'所有学生信息：{self.student_list}')
#4.修改学生
def modify_student(self):
print('修改学生信息：')
modify_name = input('请输入你要修改学生信息的姓名：')
for i in self.student_list:
if (i.name == modify_name):
i.sex = input('输入新的性别：')
i.tel = input('输入新的手机号：')
print(f'修改学生信息成功，姓名是：{i.name}，性别是：{i.sex}，手机号码是：{i.tel}')
break
else:
print('该学生不存在！')
#print(f'所有学生信息：{self.student_list}')
#5.查询学生信息
def search_student(self):
print('查询学生信息：')
search_name = input('请输入要查询的学生姓名：')
for i in self.student_list:
if (i.name == search_name):
print(f'学生{i}')
break
else:
print('查无此人！')
#6.显示所有学生信息
def show_student(self):
print('显示所有学生信息：')
print('姓名\t性别\t手机号码')
for i in self.student_list:
print(f'{i.name}\t{i.sex}\t{i.tel}')
#7.保存学生信息
def save_student(self):
print('保存学生信息：')
#7.1打开文件
f = open('student.txt','w')
#7.2文件写入学生信息
#7.21[学生对象]转换成[字典]
new_list = [i.__dict__ for i in self.student_list] #推导式
#7.22文件写入 字符串数据
f.write(str(new_list))
#7.3关闭文件
f.close()
print('保存成功！')
#8.加载学生信息
def load_student(self):
print('加载学生信息：')
try:
f = open('student.txt','r')
except:
f = open('student.txt','w')
else:
#1.读取数据
data = f.read() #字符串(字典)
#2.文件中读取的数据是字符串，而且字符串内部为字典数据，所以需要转换数据类型
new_list = eval（data) #字符串(字典) 转换为 列表(字典)
#转换字典为对象后存储到学生列表
self.student_list = [Student(i['name'],i['sex'],i['tel']) for i in new_list] #推导式
finally:
#3.关闭文件
f.close()输出结果：
目录下出现新的student.txt文件：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
