一、Python中的类与对象（类的三要素：类名、属性、方法）
1、类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 类是一个图纸、模板（例如：飞机图纸） 类不能直接使用，类的行为叫方法，类的特性是属性 2、属性称为变量（变量在类里面叫属性）==》类中的变量成为属性 3、方法称为行为（函数在类里面叫方法）==》类中的函数成为方法 4、对象就是类的实例、在教室里面的每一个同学都是人类，这个类是指一个具体的对象，然后对象又称为实例（实际存在的例子） 根据类制造出来，可以直接使用的 一个类可以制造多个对象（例如：飞机） 每个对象的属性值可能有所不同（例如：颜色） 一定是先有类才有对象 实例：通过类创建出来的对象叫做实例 5、实例化：根据一个类创建对象的过程叫做实例化 6、方法：就是类里面的定义函数 7、类变量：人类共有的属性 8、实例变量：对象或者实例所独有的 9、Class 来定义类 10、类里面定义一个方法需要空一格tab键 11、类只能一个，对象可以多个
创建类的语法格式
class 类名: # 定义一个类，这个类不能直接使用
def 方法名(self,参数1,参数2,...): # 方法必须要有self，self表示对象自己
pass
# 创建对象的语法格式
对象名p = 类名(参数) # 根据类创建一个对象p，对象名p类似于变量名
# 调用对象的方法
对象名p.方法名()设计一个猫类
类名：cat
属性：name（名字）、color（颜色）、height（身高）、weight（体重）、sex（性别）
方法：eat（吃）、drink（喝）、sleep（睡）
class cat: # cat 类
def eat(self): # eat 方法
print('猫吃饭')
def drink(self): # drink 方法
print('猫喝水')
p = cat() # 对象p，p是cat类的实例 # 这个动作就叫实例化，实例化的结果是给cat类创建一个对象p
p.eat() # 调用对象p的eat方法
# 注意：方法只能通过对象调用，不能通过类去调用self参数和属性
class cat:
def set_name(self):
self.name = 'tom' # 定义了一个属性，名叫name，值是tom
def eat(self): # 第一个参数必须是self
print('%s吃饭' % self.name) # 使用了name属性
def drink(self):
print('%s喝水' % self.name) # 使用了name属性
def demo(self): # 这个方法在类的内部调用其他方法（方法的嵌套调用）
self.eat()
self.drink()
p = cat() # 对象p p是cat类的实例
p.set_name() # 通过对象调用set_name方法
p.drink() # 通过对象调用drink方法
p.eat() # 通过对象调用eat方法
p.name = '张三' # 通过对象p给属性name赋予新的值 张三
p.drink()
p.eat()
p.demo()self作用
self可以在方法内部定义和使用属性 self可以在方法内部嵌套调用其他方法 在类的外部不能单个使用self 在类的外部调用方法：对象名.方法名 在类的外部使用属性：对象名.属性名
二、init方法 就是对象初始化方法，对象的内置方法，也就是定义对象时会自动调用init方法
作用：就是给类添加属性，同时通过init方法的参数为属性赋值，init方法一但有了形参，对象实例化的时候就必须提供实参为了避免实例化的时候必须提供实参，init的形参总是有缺省值也就是默认值
class cat:
def __init__(self):
print('cat被创建')
def eat(self):
print('小猫爱吃鱼')
c = cat() # 实例化对象的时候，init方法自动调用
c.eat() # 必须明确的通过代码调用普通代码class cat():
def __init__(self):
self.name = 'tom'
# print(self.name)
def set_name(self,name):
self.name = name
def show_name(self):
print(self.name)
c = cat() # init自动已经调用，所以name的属性已经有了
c.__init__()
c.show_name()class cat():
def __init__(self,name = 'tom'): # 给name属性设置了默认值
self.name = name # self.name 属性
def show_name(self):
print(self.name)
c = cat('张三') # init自动已经调用，所以name的属性已经有了
c.show_name()class cat:
def __init__(self,name = 'tom',color = 'red'):
self.name = name
self.color = color
def show_name(self):
print(self.name)
def show_color(self):
print(self.color)
c1 = cat('小猫','white')
c1.show_name()
c1.show_color()
c2 = cat('大猫','black')
c2.show_name()
c2.show_color()
c3 = cat()
c3.show_name()
c3.show_color()
c4 = cat('猫猫')
c4.show_name()
c4.show_color()私有方法和私有属性
class woman:
def __init__(self):
self.name = "玛丽"
self.__weight = 200 # __weigth是一个私有属性
def __eat(self): # __eat方法为私有方法
print("吃的很多")
w = woman()
print(w.name)
# print(w.__weight) # 不能在类的外部访问类的私有属性
# w.__eat() # 不能在类的外部调用私有方法三、del 方法 只能有一个参数self，del代表对象销毁的时候调用，init代表对象出现的时候调用
class cat:
def __init__(self,name = 'tom'):
self.name = name
def show_name(self):
print(self.name)
def __del__(self):
print('%s销毁了'% self.name)
c = cat() # c是一个对象，同时也是一个变量
c.show_name() # 这里显示了tom，然后自动调用del销毁如果对象是局部的，那么函数执行完毕后，会自动调用del
如果对象是全局的，那么程序执行完毕后，也会自动调用del
class cat:
def __init__(self,name = 'tom'):
self.name = name
def show_name(self):
print(self.name)
def __del__(self):
print('%s销毁了' % self.name)
def my_test1():
c1 = cat('小猫')
c1.show_name()
my_test1() # 程序的第一句执行语句
c = cat() # c是一个对象，同时也是一个变量
c.show_name() # 这里显示了tom练习
class dog:
def __init__(self,name = '哈士奇',age = 2):
self.name = name
self.age = age
def set_name(self,name):
self.name = name
def get_name(self):
return self.name
def show_name(self):
print(self.name)
def set_age(self,age):
self.age = age
def get_age(self):
return self.age
def show_age(self):
print(self.age)
d = dog('比熊',3) # 实例化的时候设置的属性值
print(d) # 把对象直接放在print里面，显示的是对象在内存的地址编号
print(d.get_name())
d.set_name('泰迪') # 实例化以后在设置属性值
print(d.get_name())四、str 作用：把对象直接放在print里面，就会打印出属性值
class demo:
def __init__(self,name = '李四'):
self.name = name
def __str__(self): # 只用一个self参数
return self.name # 必须有return 返回的是字符串
d = demo()
print(d)当把一个带有str方法的对象放到print里面，print函数会显示str方法return返回的字符串
class calc:
def __init__(self,oper = '+'):
self.oper = oper
def calc(self,a,b):
if self.oper == '+':
return a + b
elif self.oper == '-':
return a - b
elif self.oper == '*':
return a * b
elif self.oper == '/':
if b != 0:
return a / b
else:
return None
else:
return None
c = calc()
print(c.calc(3,4))
d = calc('*')
print(d.calc(3,4))烤地瓜案例
# 1. 定义类：初始化属性、被烤和添加调料的方法、显示对象信息的str
class SweetPotato():
def __init__(self):
# 被烤的时间
self.cook_time = 0
# 烤的状态
self.cook_state = '生的'
# 调料列表
self.condiments = []
def cook(self, time):
"""烤地瓜方法"""
# 1. 先计算地瓜整体烤过的时间
self.cook_time += time
# 2. 用整体烤过的时间再判断地瓜的状态
if 0 <= self.cook_time < 3:
# 生的
self.cook_state = '生的'
elif 3 <= self.cook_time < 5:
# 半生不熟
self.cook_state = '半生不熟'
elif 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}'
# 2. 创建对象并调用对应的实例方法
digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
digua1.add_condiments('辣椒面儿')
print(digua1)
digua1.cook(2)
digua1.add_condiments('酱油')
print(digua1)搬家具案例
class Furniture():
def __init__(self, name, area):
self.name = name
self.area = area
class Home():
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, item):
"""容纳家具"""
# 如果 家具占地面积 <= 房子剩余面积：可以搬入(家具列表添加家具名字数据并房子剩余面积更新：
# 房屋剩余面积 - 该家具的占地面积
# 否则：提示用户家具太大，剩余面积不足，无法容纳
# )
if item.area <= self.free_area:
self.furniture.append(item.name)
self.free_area -= item.area
else:
print('家具太大，剩余面积不足，无法容纳')
# 双人床， 6
bed = Furniture('双人床', 6)
sofa = Furniture('沙发', 10)
# 房子1： 北京, 1000
jia1 = Home('北京', 1000)
print(jia1)
jia1.add_furniture(bed)
print(jia1)
ball = Furniture('篮球场', 2000)
jia1.add_furniture(ball)
print(jia1)python的三大特性
1、封装：就是把类的属性和方法封装到类的内部，只能在内部使用，不能在类的外部使用，把属性和方法名前面加两个下划线，这个属性和方法就成为了类的私有属性和方法
class people:
def __init__(self):
pass
def set_name(self,name):
self.__name = name # __name私有属性
def get_name(self):
return self.__name
p = people()
p.set_name('小王')
print(p.get_name())
# print(p.__name) # 报错：不能在类的外部访问类的私有属性class woman:
def __init__(self):
self.name = '玛丽'
self.__weight = 200 # __weight私有属性
def __eat(self): # __eat 私有方法
print('吃的很多')
p = woman()
print(p.name)
# print(p.__weight) # 报错：不能在类的外部访问类的私有属性
# p.__eat # 报错：不能在类的外部调用私用方法2、继承：一个父类可以有多个子类
dog类是animal类的子类，也叫派生类 animal类是dog类的父类，也叫基类 dog类继承animal类，也叫dog类派生animal类。
class animal:
def sleep(self):
print('睡')
def eat(self):
print('吃')
class dog(animal): # animal这个类继承给dog类（animal称为父类，dog称为子类）
def run(self):
print('跑')
d = dog()
d.sleep()
d.eat()
d.run()单继承
class Father(object): # 父类
def __init__(self):
pass
def smoke(self):
print('喜欢抽烟')
def rich(self):
print('非常有钱')
def drink(self):
print('喜欢喝酒')
class Son(Father): # 子类
def __init__(self):
Father.__init__(self) # 继承父类的构造方法
def meinv(self):
print('喜欢美女')
def car(self):
print('非常开车')
def bar(self):
print('喜欢泡吧')
s = Son()
s.rich()
s.drink()
s.meinv()
s.bar()
s.car()
print(isinstance(s,Son)) # True 判断s是否为Son的一个对象或实例
print(issubclass(Son,Father)) # True 判断Son类是否为Father的子类一个父类多个子类
class animal:
def sleep(self):
print("睡")
def eat(self):
print("吃")
class dog(animal):
def run(self):
print("跑")
class fish(animal):
def swimming(self):
print("游泳")
class bird(animal):
def fly(self):
print("飞")
b = bird()
b.sleep()
f = fish()
f.swimming()多层（级）继承
class animal:
def sleep(self):
print("睡")
def eat(self):
print("吃")
class dog(animal):
def run(self):
print("跑")
class fish(animal):
def swimming(self):
print("游泳")
class erha(dog):
def kawayi(self):
print("萌")
class cangao(dog):
def yaoren(self):
print("咬人")
class shark(fish):
def chiren(self):
print("吃人")
s = shark()
s.sleep()
s.eat()
s.swimming()
s.chiren()
c = cangao()
c.sleep()
c.eat()
c.run()
c.yaoren()多继承
# 1. 师父类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 为了验证多继承，添加School父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 2. 定义徒弟类，继承师父类 和 学校类
class Prentice(School, Master):
pass
# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
# 结论：如果一个类继承多个父类，优先继承第一个父类的同名属性和方法覆盖父类方法
class animal:
def sleep(self):
print("睡")
def eat(self):
print("吃")
class dog(animal):
def eat(self): # 出现和父类同名方法,在子类dog中,就没有父类的eat方法了
print("吃肉")
d = dog()
d.sleep()
d.eat() # 由于覆盖了父类的eat方法,,所以这里调用的是dog类的eat方法init方法重写、子类方法覆盖了父类的方法时，super方法可以再次调用父类方法
class animal:
def __init__(self):
print("张三")
def eat(self):
print("吃")
class dog(animal):
def __init__(self):
super(animal,self).__init__() # 父类已经有init方法时，子类还需要用到init方法时：需要super 重写init方法
print("李四")
def eat(self): # 出现和父类同名方法,在子类dog中,就没有父类的eat方法了
print("吃肉")
def eatA(self):
super().eat() # 子类已经覆盖了父类的eat方法，还是要用父类的eat方法是需要使用super()
d = dog()
d.eat() # 由于覆盖了父类的eat方法,,所以这里调用的是dog类的eat方法
d.eatA() # super()拿到了父类的eat方法查看类的继承关系 __mro__
# 1. 师父类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__) # (<class '__main__.Prentice'>, <class '__main__.Master'>, <class 'object'>)子类调用父类同名方法和属性
# 1. 师父类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 为了验证多继承，添加School父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
# 2. 定义徒弟类，继承师父类 和 学校类， 添加和父类同名的属性和方法
class Prentice(School, Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
# 加自己的初始化的原因：如果不加这个自己的初始化，kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
# 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
def make_master_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因：这里想要调用父类的同名方法和属性，属性在init初始化位置，所以需要再次调用init
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
# 3. 用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()三、多态：不同的对象，调用相同的父类方法，产生不同的结果
多态的前提，不同的子类来自相同的一个父类，子类会覆盖父类的方法
class Animal(object):
def say(self):
print('欢迎来到动物世界')
class Dog(Animal):
def say(self):
print('汪汪')
class Cat(Animal):
def say(self):
print('喵')
d = Dog()
d.say()
c = Cat()
c.say()class animal:
def food(self):
pass
def eat(self):
self.food()
class dog(animal):
def food(self):
print('吃肉')
class cattle(animal):
def food(self):
print('吃草')
d = dog()
d.eat()
c = cattle()
c.eat()四、类属性：定义在类里面，方法的外面。
类方法：类方法不需要吧类实例化对象，通过类名.类方法名调用 用@classmethod来修饰的就是类方法，类方法的第一个参数是cls，在类方法里面使用类属性用cls.类属性名 类方法内部不能使用普通属性，也不能调用普通方法，因为类方法不需要通过对象调用
类方法
class dog:
name = '小白' # 类属性
@classmethod
def get_name(cls): # 类方法
return cls.name
def __init__(self):
self.age = 0
def get_age(self):
return self.age
# 要把类属性name的值改为'小黑'
dog.name = '小黑'
print(dog.name)
# 调用类方法get_name,并显示name的值
print(dog.get_name())
# 要把普通属性age的值改为10
d = dog()
d.age = 10
print(d.age)
# 用普通方法get_age显示age的值
d = dog()
print(d.get_age())静态方法：不能访问类里面的任何成员
使用场景：当代码量特别大时，函数也会特别多，
为了避免函数名的重名，可以把同名函数放到不同的类里面
class dog:
def a(self):
self.name = '张三'
@staticmethod
def help():
print('这是一个静态方法')
class A:
@staticmethod
def help():
print('这是一个静态方法')
dog.help()
A.help()# 统计类实例化次数
class dog:
index = 0 # 定义一个类属性
@classmethod
def count(cls): # 返回值为属性index
return cls.index
def __init__(self): # 实例化的时候自动调用init
dog.index += 1 # 每次实例化的时候 类属性 index + 1
d1 = dog()
d2 = dog()
d3 = dog()
d4 = dog()
print(dog.count())总结
# class people(object) 新式类 2.7
# class people 经典类
class people(): # people 称为父类、基类、也是一切类的父亲
head = 1 # 类的变量也就是类属性
# 构造函数,__init__ 初始化方法
def __init__(self,name): # 构造函数、构造方法，双下划线表示私有的 -- 作用为了创建对象
self.name = name # self.name称为实例变量，self是当前类的对象本身
# 实例方法
def play(self): # 实例方法
print(self.name + '去打篮球')
# 类方法
@classmethod # 类的方法，@classmethod修饰的就是类方法，类方法只能访问类属性和类方法
# @符号称为装饰器：为了不影响原有方法的功能基础上给原有的方法增加新功能
def func1(cls): # cls就是代表class的缩写
cls.name = '这是一个类的方法'
print(cls.name)
# 静态方法
@staticmethod
def func2():
print('这是一个静态方法')
# 私有方法、只能在类的类不是有
def __func3(self):
print('这是一个私有方法')
# 可以通过常见一个实例方法来引用私有方法得结果
def fun4(self):
return self.__func3()
# 创建一个对象、实例化一个对象
p = people('小王') # 创建一个对象p，实例化,这个对象名字叫小王
p.play()
1、类和对象调用类变量、实例变量
print(people.head) # 类调用类变量
# print(people.name) # 报错：类调用实例变量、实例变量是对象和实例独有的
print(p.head) # 对象调用类变量
print(p.name) # 对象调用实例变量
2、类和对象调用实例方法、类方法、静态方法
people.play(p) # 类调用实例方法报错，要传入一个参数进去，这个参数就是那个对象去打篮球
people.func1() # 类调用类方法、这是一个类方法
people.func2() # 类调用静态方法、这是一个静态方法
p.play() # 对象调用实例方法
p.func1() # 对象调用类方法
p.func2() # 对象调用静态方法
3、类和对象调用私有方法
people.fun4(p)
p.fun4()
class Student(object):
def __init__(self, name, gender, tel):
# 姓名、性别、手机号
self.name = name
self.gender = gender
self.tel = tel
def __str__(self):
return f'{self.name}, {self.gender}, {self.tel}'
# aa = Student('aa', 'nv', 111)
# print(aa)from StudentManagerSystem.student import *
class StudentManager(object):
def __init__(self):
# 存储学员数据 -- 列表
self.student_list = []
# 一. 程序入口函数
def run(self):
# 1. 加载文件里面的学员数据
self.load_student()
while True:
# 2. 显示功能菜单
self.show_menu()
# 3. 用户输入目标功能序号
menu_num = int(input('请输入您需要的功能序号：'))
# 4. 根据用户输入的序号执行不同的功能 -- 如果用户输入1，执行添加
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
# 二. 系统功能函数
# 2.1 显示功能菜单 -- 打印序号的功能对应关系 -- 静态
@staticmethod
def show_menu():
print('请选择如下功能：')
print('1:添加学员')
print('2:删除学员')
print('3:修改学员信息')
print('4:查询学员信息')
print('5:显示所有学员信息')
print('6:保存学员信息')
print('7:退出系统')
# 2.2 添加学员
def add_student(self):
# 1. 用户输入姓名、性别、手机号
name = input('请输入您的姓名：')
gender = input('请输入您的性别：')
tel = input('请输入您的手机号：')
# 2. 创建学员对象 -- 类 ？类在student文件里面 先导入student模块，再创建对象
student = Student(name, gender, tel)
# 3. 将该对象添加到学员列表
self.student_list.append(student)
print(self.student_list)
print(student)
# 2.3 删除学员
def del_student(self):
# 1. 用户输入目标学员姓名
del_name = input('请输入要删除的学员姓名：')
# 2. 遍历学员列表，如果用户输入的学员存在则删除学员对象，否则提示学员不存在
for i in self.student_list:
if del_name == i.name:
# 删除该学员对象
self.student_list.remove(i)
break
else:
# 循环正常价结束执行的代码：循环结束都没有删除任何一个对象，所以说明用户输入的目标学员不存在
print('查无此人！')
print(self.student_list)
# 2.4 修改学员信息
def modify_student(self):
# 1. 用户输入目标学员姓名
modify_name = input('请输入要修改的学员姓名：')
# 2. 遍历列表数据，如果学员存在修改姓名性别手机号，否则提示学员不存在
for i in self.student_list:
if modify_name == i.name:
i.name = input('姓名：')
i.gender = input('性别：')
i.tel = input('手机号：')
print(f'修改学员信息成功，姓名{i.name}, 性别{i.gender}, 手机号{i.tel}')
break
else:
print('查无此人！')
# 2.5 查询学员信息
def search_student(self):
# 1. 用户输入目标学员姓名
search_name = input('请输入您要搜索的学员姓名：')
# 2. 遍历列表。如果学员存在打印学员信息，否则提示学员不存在
for i in self.student_list:
if search_name == i.name:
print(f'姓名是{i.name}, 性别是{i.gender}, 手机号是{i.tel}')
break
else:
print('查无此人！')
# 2.6 显示所有学员信息
def show_student(self):
# 1. 打印表头
print('姓名\t性别\t手机号')
# 2. 打印学员数据
for i in self.student_list:
print(f'{i.name}\t{i.gender}\t{i.tel}')
# 2.7 保存学员信息
def save_student(self):
# 1. 打开文件
f = open('student.data', 'w')
# 2. 文件写入数据
# 2.1 [学员对象] 转换成 [字典]
new_list = [i.__dict__ for i in self.student_list]
# 2.2 文件写入 字符串数据
f.write(str(new_list))
# 3. 关闭文件
f.close()
# 2.8 加载学员信息
def load_student(self):
# 1. 打开文件：尝试r打开，如果有异常w
try:
f = open('student.data', 'r')
except:
f = open('student.data', 'w')
else:
# 2. 读取数据：文件读取出的数据是字符串还原列表类型；[{}] 转换 [学员对象]
data = f.read() # 字符串
new_list = eval（data)
self.student_list = [Student(i['name'], i['gender'], i['tel']) for i in new_list]
finally:
# 3. 关闭文件
f.close()# 1. 导入管理系统模块
from StudentManagerSystem.managerSystem import *
# 2. 启动管理系统
# 保证是当前文件运行才启动管理系统：if --创建对象并调用run方法
if __name__ == '__main__':
student_manager = StudentManager()
student_manager.run()本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
