1 面向对象
1.1 类和对象（用类创建对象）
类的语法：
class 类名():
执行的代码
对象的语法：
对象名 = 类名()
class Washer(): # 定义类
def wash(self):
print("可以洗衣服")
print(self) # 返回结果是跟下面gree的地址一样
gree1 = Washer() # 创建对象1
gree2 = Washer() # 创建对象2
print(gree1) # 返回结果是：对象gree的地址
gree1.wash() # 返回结果是：可以洗衣服，此时wash()叫做实例方法/对象方法
注意：
- self：表示调用该函数的对象
- 一个类可以任意创建多个对象
对象属性的获取与添加：
类外面添加对象属性：对象名.属性名 = 值
类外面获取对象属性：对象名.属性名
gree1.width = 100
print(f'洗衣机的宽度是：{gree1.width}')
类内部获取对象属性：self.属性名
class Washer():
def wash(self):
print("可以洗衣服")
print(f'gree洗衣机的宽度是{self.widtf}') # 返回结果是:gree洗衣机的宽度是500
gree = Washer() # 创建对象
gree.width = 500 #添加实例属性
1.2 魔法方法
魔法方法：有特殊功能的函数，语法是：__xx__
1 __init__()，作用是初始化对象
class Washer(): # 定义类
def __init__(self):
self.width = 500
def print_info(self)： # 类里面调用实例属性
print(f'洗衣机宽度是{self.width}')
gree = Washer()
gree.print_info()
注意：
__init__()方法，在创建一个对象时默认被调用，不需要手动调用__init__(self)的 self 参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去
2 带参数的__init__()：一个类创建多个对象，并对不同对象设置不同的初始化属性
class Washer():
def __init__(self，width,heigth):
self.width = width
self.heigth = height
def print_info(self):
print(f'洗衣机宽度是{self.width}',f'洗衣机宽度是{self.heigth}')
gree1 = Washer(10,20)
gree1.print_info()
gree2 = Washer(100,200)
gree2.print_info()
3 __str__：使用print输出对象的时候，打印在这个方法中return的数据
class Washer():
def __init__(self，width,heigth):
self.width = width
self.heigth = height
def __str__(self)：
rentun '这是格力洗衣机'
gree = Washer(10,20)
print(gree) # 此时返回的是：这是格力洗衣机
4 __del__：删除对象，python解释器会默认调用__del__方法
class Washer():
def __init__(self，width,heigth):
self.width = width
self.heigth = height
def __del__(self)：
print(f'{self}对象已经被删除')
gree = Washer(10,20)
del gree # 删除 gree 对象
案例1：烤地瓜
class SweetPotato():
def __init__(self):
self.cook_time = 0 # 被烤的时间
self.cook_static = "生的" # 地瓜的状态
self.condiments = [] # 调料列表
def cook(self,time): # 烤地瓜的方法
"""烤地瓜的方法"""
self.cook_time += time
if 0 <= self.cook_time < 3
self.cook_static = '生的'
elif 3 <= self.cook_time < 5
self.cook_static = '半生不熟'
elif 5 <= self.cook_time < 8
self.cook_static = '熟了'
else self.cook_time >= 8:
self.cook_static = '烤糊了'
def cook(self,time): # 添加调料的方法
"""添加调料的方法"""
self.condiments.append(condiment)
if 0 <= self.cook_time < 3
def __str__(self): # 用于输出对象状态
return f'这个地瓜考了{self.cook_time}分钟,状态是{self.cook_static},\n
调料有{self.cook_condiments}'
# 创建对象，测试实例属性和实例方法
digua = SweetPotato()
print(digua)
digua.cook(2)
digua.add_condiments('酱油')
print(digua)
案例2：搬家具
class Furniture(): # 定义家居类
def __init__(self，name,area):
self.time = 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},\n
剩余面积{self.free_area},家居有{self.furniture}'
def add_funiture(self,item): # 容纳家具
if self.free_area >= item.area:
self.furniture.append(ite,.name)
self.free_area -= item.area
else:
print('家具太大了，剩余面积不足，无法容纳')
# 创建对象，测试实例属性和实例方法
bed = Funiture('双人床'，6)
jia = Home('北京',1200)
print(jia)
jia.add_furniture(bed)
print(jia)
2 继承
2.1 认识继承
继承：多个类之间的所属关系，子类默认继承父类的所有属性和方法
- 所有类默认继承object类，object类是顶级类或者基类，其他子类叫做派生类
- 继承分为单继承和多继承
# 单继承
class A(object): # 这个是父类
def __init__(self):
self.num = 1
def info_print(self)：
print(self.num)
class B(A): # 这个是子类
pass
result = B()
result.info_print() # 返回结果是：1
注意：
1 当一个类具有多个父类的时候，默认使用第一个父类的同名属性和方法
2 若子类和父类具有同名属性和方法，调用的是子类的属性和方法
3 类名.__mro__：查看类的层级关系
# 多继承
class Master(object): # 这个是父类1
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}做了煎饼果子')
# 创建学校类
class School(object): # 这个是父类2
def __init__(self):
self.kongfu = '小明煎饼果子配方'
def make_cake(self):
print('f'运用了{self.kongfu}制作了煎饼果子')
class Prentice(School,Mater): # 这个是子类
pass
daqiu = Prentice()
print(daqiu.kongfu())
daqiu.make_cake() # 返回结果是：运用[小明煎饼果子配方]做了煎饼果子
print(prentice.__mro__)
2.2 继承中子类的调用
- 子类调用属性和方法时，可以自定义调用子类或者父类的属性和方法
- 多层继承子类的子类也可以继承子类和父类
# 多继承
class Master(object): # 这个是父类1
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}做了煎饼果子')
# 创建学校类
class School(object): # 这个是父类2
def __init__(self):
self.kongfu = '小明煎饼果子配方'
def make_cake(self):
print('f'运用了{self.kongfu}制作了煎饼果子')
class Prentice(School,Mater): # 这个是子类
def __init__:
self.kongfu = '[独创煎饼果子配方]'
# 调用子类方法
def make_cake(self):
self.__init___() # 为了保证调用的子类方法属性，需要将子类进行初始化
print(f.'运用{self.kongfu}做了煎饼果子')
# 调用父类方法
def make_master_cake(self):
Master.__init__(self)
Master.make_cake(self)
class Tusun(Prentice): # 这是多层继承的使用
pass
daqiu = Prentice()
daqiu.make_cake() # 返回结果是：运用[独创煎饼果子配方]做了煎饼果子
daqiu.make_master_cake() # 返回结果是：运用[古法煎饼果子配方]做了煎饼果子
xiaoqiu = Tusun()
xiaoqiu.make_school_cake()
- 利用
super()方法调用父类方法和属性
# 需求：一次性调用两个父类
class Master(object):
class School(Maater):
# 如果要调用Mater里面的方法与属性，需要在此处加上super()方法
# 后面测试案例返回结果为：运用[小明煎饼果子配方]做了煎饼果子 运用[古法煎饼果子配方]做了煎饼果子
# super() 带参数写法：
super(School,self).__init__()
super(School,self).make_cake()
# super() 无参数写法
super().__init__
super().make.cake()
class Prentice(School):
......
def make_old_cake(self):
# 方法1(带参数)：super(当前类名，self).函数()
super(Prentice,self).__init__()
super(Prentice,self).makecake() 返回结果是：运用[小明煎饼果子配方]做了煎饼果子
# 方法2（无参数）：super(当前类名，self).函数()
super.__init__()
super.makecake() 返回结果是：运用[小明煎饼果子配方]做了煎饼果子
2.3 私有权限
私有权限：设置某个实例属性或者实例方法，不继承给子类，在属性名和方法名前面加上两个下划线__
- 私有属性和私有方法只能在类里面进行访问和修改
- 一般定义函数名
get_xx来获取私有属性，定义set_xx来修改私有属性值
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
#定义私有属性
self.__money = 200
def fet_money(self): # 获取私有属性
return self.__money
def set_money(self): # 修改私有属性
self.__money = 300
# 定义私有方法
def __info_print(self):
print(self.kongfu)
class Tusun(Prentice):
pass
xiaoqiu = Tusun()
print(xiaoqiu.money) # 此时程序报错，调用不了父类属性
2.4 多态
多态：调用不同子类对象的相同对象方法，可以产生不同的执行结果
class Dog(object):
def work(self): # 父类提供统一的方法
print('指哪打哪...')
class ArmyDog(Dog): # 继承Dog类
def work(self): # 子类重写父类的方法
print('追击敌人...')
class DrugyDog(Dog): # 继承Dog类
def work(self): # 子类重写父类的方法
print('追查毒品...')
class Person(object):
def work_with_dog(self,dog): # 传入不用的对象，执行不同的work函数
dog.work()
ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad) # 返回的结果是：追击敌人...
daqiu.work_with_dog(dd) # 返回的结果是：直接毒品...
2.5 类属性和类方法
类属性：类对象所拥有的属性，他被该类的所有实例对象所共有
- 类属性只能通过类对象进行修改，不能通过实例对象修改
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth) # 返回的结果是：10
print(wangcai.tooth) # 返回的结果是：10
Dog.tooth = 20
print(Dog.tooth) # 返回的结果是：20
类方法：需要用装饰器@classmethod来标识其为类方法，第一个参数必须为类对象，一般以cls作为第一个参数
- 当方法中需要使用类对象（如访问私有属性等）时，定义类方法
- 类方法一般和类属性配合使用
class Dog(object):
__tooth = 10
@classmethod
def get_tooth(cls):
return cls.__tooth
wangcai = Dog()
print(wangcai.get_tooth()) # 返回结果是：10
2.6 静态方法
静态方法：需要通过装饰器@staticmethod来进行修饰，静态方法不需要传递类对象和实例对象
- 静态方法可以通过实例对象和类对象进行访问
- 当不需要进行参数传递的时候，就使用静态方法
class Dog(object):
@staticmethod
def info_print():
print('这是一个狗类')
wangcai = Dog()
# 静态方法，既可以使用对象访问，又可以使用类访问
Dog.info_print()
wangcai.info_print()
3 学生管理系统（面向对象）
学员类的创建（sudent.py文件）
- 学员信息包括：姓名、性别、手机号
- 添加
__str__魔法s方法，方便查看学员对象信息
class Student(object):
def __init__(self,name,gender,tel):
# 姓名、性别、手机号
self.name = name
self.gengder = gender
self.tel = tel
def __str__(self):
return f'{self,name},{self.gender},{self.tel}'
管理系统的创建（managerSystem.py文件）
-
管理系统循环使用，用户输入不同的功能序号执行不同功能
-
存储数据的形式：列表存储学员对象
-
系统功能：添加学员、删除学员、修改学员、查询学员信息、显示所有学员信息、保存学员信息
-
步骤：定义程序入口函数（加载数据、显示功能菜单、用户输入功能序号、系统执行功能）——系统定义功能函数
from stdent import *
class StudentManager(object):
def __init__(self):
# 存储数据所用的列表
self.student_list = []
# 一、程序入口函数，启动程序后执行的函数
def run(self):
# 1 加载学员信息
self.load_student()
while True:
# 2 显示功能菜单
self.show_meu()
# 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.modefy_student()
elif menu_num == 4: # 查询学员信息
self.search_student()
elif menu_num == 5: # 展示学员信息
self.show_student()
elif menu_num == 6: # 保存学员信息
self.saveh_student()
elif menu_num == 7: # 退出系统
break
# 二、系统功能函数
# 1 展示功能菜单
def show_menu():
print('请选择如下功能：')
print('1 添加学员信息')
print('2 删除学员信息')
print('3 修改学员信息')
print('4 查询学员信息')
print('5 显示所有学院信息')
print('6 保存学员信息')
print('7 退出系统')
# 2 添加学员信息：用户输入信息---创建学员对象---将对象添加到学员列表
def add_student(self):
name = input('请输入您的姓名：')
gender = input('请输入您的性别：')
tel = input('请输入您的手机号：')
student = Student(name,gender,tel)
self.student_list.append(student)
print(self.student_list)
# 3 删除学员，删除指定姓名的学员
def del_student(self):
del_name = input('请输入要删除的学员姓名：')
for i in self.student_list:
if i,name == del_name:
self.student_list.remove(i)
break
else:
print('查无此人！')
print(self.student_list)
# 4 修改学员信息，用户输入学员姓名，修改学员信息
def modefy_student(self):
modefy_name = input('请输入您要修改的学员姓名：')
for i in self.student_list:
if i.name == modify_name:
i.name == input('请输入学员姓名：')
i.gengder == input('请输入学员性别：')
i.tel == input('请输入学员手机号：')
print(f'修改学员信息成功，姓名：{i.name}，性别：{i.gender}，手机号：{i.tel}')
break
else:
print('查无此人！')
# 5 查询学员信息
def search_student(self):
search_name = input('请输入您要查询的学员姓名：')
for i in self.student_list:
if i.name == search_name:
print(f'查询学员信息成功，姓名：{i.name}，性别：{i.gender}，手机号：{i.tel}')
break
else:
print('查无此人！')
# 6 显示所有学员信息
def show_student(slef):
print('姓名\t性别\t手机号')
for i in self.student_list:
print(f'姓名：{i.name}，性别：{i.gender}，手机号：{i.tel}')
# 7 保存学员信息
def save_student(self):
# 1 打开文件
f = open('student.data','w') # 打开文件
# 文件写入数据不能是内存地址，需要把学员数据转换成列表字典数据再做存储
new_list = [i.__dict__ for i in self.student_list]
# 文件内数据要求为字符串类型，需将数据类型转换成字符串
f.write(str(new_list))
f.cloese
# 8 加载学员信息
def load_student(self):
try:
f = open('student.data','r')
except:
f = open('student.data','w')
else:
data = f.read()
new_list = eval(data)
# 文件中读取数据为字典类型，需转换字典为对象后再存储到学员列表
self.student_list = [Student(i['name'],i['gender']),i['tel'] for i in new_list]
finally:
f.close（）
主函数的创建(main.py文件)
# 1 导入managerSystem模块
from managerSysyem import *
# 2 启动学员管理系统
if __name__ == '__main__':
student_maneger = StudentManager()
student_manager.run()
拓展：
__dict__：返回类或实例属性中对应的字典
eval：用于执行字符串形式的 Python 表达式，并返回表达式的结果