Zcoco Lab

PYTHON NOTES · 07

从类和对象出发，理解魔法方法、封装、继承与多态。

  • 类与对象
  • 继承
本文目录
  1. 1.定义类
  2. 2.创建对象
  3. 3.魔法方法
  4. 3.1 init
  5. 3.2 str
  6. 3.3 del
  7. 3.4 【补充】对象与字典的相互转化
  8. 4.三大特性
  9. 4.1 封装
  10. 4.2 继承
  11. 4.3 多态
  12. 5.实例化
  13. 1.单例模式
  14. 2.工厂模式
  15. 6.综合案例：学生管理系统

Python 面向对象

从类和对象出发，理解魔法方法、封装、继承与多态。

1.定义类

# #语法:
# 1.定义类的语法:
# class 类名：  python2
# class 类名():  python3
# class 类名(object): python3
#
# 类名规范：大驼峰写法

2.创建对象

#使用类创造对象
zs=students()

#属性的使用
print(f"zs的年龄是{zs.age},身高是{zs.height}")

#方法的使用
zs.socer()
self 
#self：谁调用的方法，self就指的是谁，self是对象的16进制地址
#self:是一个内置参数，系统会自动传递这个参数，无需关注来源
#我们传递的实参需要在self后面定义形参接收

属性是类中的变量：类属性是类中通用的属性，实例属性是对象特有的属性，一般用self.xxx来定义

方法就是类里的函数：有实例方法，静态方法，类方法，类方法和静态方法都需要用装饰器来定义。

类方法是方法内只用到了类属性的方法，所有对象通用，一般使用cls参数 @class

静态方法是方法内既不使用类属性也不使用实例属性的方法@st

3.魔法方法

在某种条件下会自动调用执行的代码

3.1 init

创建对象时会自动调用

class star():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def introduce(self,song):
        print(f"{self.name}在唱{song}")

ldh=star("刘德华",18)
zxy=star("张学友",19)

ldh.introduce("笨小孩")
zxy.introduce("吻别")

3.2 str

在打印/str格式转换时会自动调用

3.3 del

在删除对象时会自动调用（手动删除/代码运行结束后回收）

3.4 【补充】对象与字典的相互转化

from student import Student

S1 = Student("张三", "男", 90, 000, '老年人')
S2 = Student("李四", "男", 80, 000, '老年人')
S3 = Student("王五", "男", 70, 000, '老年人')

#  把对象转为字典格式
dict_s1 = (S1.__dict__)

# 把对象列表转化为字典列表
list_s = [S1, S2, S3]
# 列表推导式
dict_list = [s.__dict__ for s in list_s]
print(dict_list)

# 把字典转化为对象
dict_s1 = {"name": "张三", "gender": "男", "age": 90, "phone": 000, "desc": '老年人'}
S1 = Student(**dict_s1)
print(S1)

4.三大特性

4.1 封装

把属性和方法写在类里面

私有化：只能在类里面访问/使用属性和方法

实现私有化的方法 在方法名或属性名前加_

4.2 继承

# class B(object):  所有的类都继承于object
# class A(B)：  A继承于B  A是孩子 所有东西全继承
# 1.直接继承
# 2.多层继承
# 3.多个父级继承
# 子类可以同时继承多个父类
# 如果有同一属性，先有的先继承，后来的找不同
# 4.继承后的重写：把父类的属性值，改写为当前值
# 总结：有了就不继承，没有才继承，如果有多个，按顺序继承
# 爷爷有个自行车
class grandfather():
    car = "zixingche"


# 爸爸有10万和从爷爷那继承的自行车
class father(grandfather):
    money = 100000


# 干爹有路虎和一栋楼
class gfather():
    car = "路虎"
    house = "一栋楼"


# 儿子继承爸爸的钱和自行车继承干爹的楼
class son(father, gfather):
    pass

# print(son.car) -> 自行车
# print(son.money) ->100000
# print(son.house) -> 一栋楼

菱形继承：

# 菱形继承——从近到远，逐层继承
# 继承关系的查看 类.mro
# 私有属性无法继承 (有后门）

4.2.1 静态继承

继承类的静态属性

# 直接继承，继承静态属性
class A():
    name = "张三"


class B(A):
    # 继承A的所有静态属性
    age = 18

4.2.3 动态继承

1.super-mro

mor: 用来查看继承顺序

super：用来查找mro下一级（继承上一级）的对象

2.直接使用父类继承（推荐）

class C():

    def __init__(self):
        self.car = "宝马"
        self.house = "一栋楼"


class D():
    # 继承C的所有实例属性
    def __init__(self):
        C.__init__(self)
        self.money = 100000

4.2.4 混合继承

class B(A):
    # 继承A的所有静态属性
    age = 18


# 继承实例属性
class C():

    def __init__(self):
        self.car = "宝马"
        self.house = "一栋楼"


class D():
    # 继承C的所有实例属性
    def __init__(self):
        C.__init__(self)
        self.money = 100000


# 混合继承
class E(B, D):
    # 继承B的所有静态属性
    # 继承D的所有实例属性
    def __init__(self):
        D.__init__(self)

4.3 多态

# python是一个弱类型语言，没有严格意义上的多态（听说过就行）

5.实例化

1.单例模式

如果不需要创造多个实例对象，可以选择单例模式
单例模式指的是不需要实例化，直接把类当对象使用
@staticmethod(静态装饰器）
属性和方法都是静态的类，就叫静态类
常见使用场景：工具类方法
class ATM():
    money=0

    #查询余额
    @staticmethod
    def search():
        print(f"您当前的余额为{ATM.money}")
# @staticmethod 静态装饰器
# @classmethod 类装饰器，第一个参数是cls，就是类本身

#总结：
# 1.如果类里面没有使用self，改造成staticmethod
#2.如果单例模式想要类的属性，直接类.属性

#装饰器：@开头，作用在方法前面的内容
class Car():
    num =4
    @staticmethod
    def run():
        print("车在跑")
    @classmethod
    def introduce(cls):
        print(f"我是一辆{cls.num}轮车")

Car.run()
Car.introduce()

#改进
class Car():
    num =4
    @staticmethod
    def run():
        print("车在跑")
    @staticmethod
    def introduce():
        print(f"我是一辆{Car.num}轮车")

Car.run()
Car.introduce()

2.工厂模式

如果要生成多个实例对象选择工厂模式

6.综合案例：学生管理系统

#需求：做一个学生管理系统

"""
功能：记录学生信息：姓名、年龄、性别....
        新建、修改、删除学生信息
        查询单个学生信息、查询全部学生信息
        学生信息的保存与写入
"""
      
#实现思路:
#定义类:
#     学生类:    用来储存学生信息
#     管理系统类：用于实现功能
#     入口函数：  用于程序的运行与测试
# 学生类
#使用魔法方法定义对象的实例化属性
#使用魔法方法打印对象
# 管理系统类:
# 功能实现
#初始化
 新建一个对象列表用于储存学生对象
# 新建学生信息(2)
  调用学生类
  让用户输入学生信息
  创建对象保存学生信息
  将对象添加到对象列表
# 删除学生信息(4)
  让用户输入要删除的学生姓名
  遍历列表，找到对象.name=用户输入的姓名
  删除此信息，退出遍历
  如果没找到
  提示没有此学生
  for——else
# 修改学生信息(4)
  让用户输入要修改的学生姓名
  遍历列表，找到对象.name=用户输入的姓名
  让用户输入要修改的内容，重新给变量赋值
  如果没找到
  提示没有此学生
  for——else
# 展示全部学生信息(3)
  判断对象列表长度是否为0
    为0提示没有信息
    不为0
    遍历学生列表
    打印学生对象(调用学生类的魔法方法)
# 查询单个学生信息(6)
  让用户输入要查找的学生姓名
  遍历列表，找到对象.name=用户输入的姓名
  打印此对象，不退出循环，可能有重名情况，全部打印
  如果没找到
  提示没有此学生
  for——else
# 储存学生信息列表(7)
  需要打开文件 with open
  当前的列表是[对象，对象，对象]形式，将他转换成[字典，字典，字典]的形式 __dict__
  stu_list_dict=str([stu.__dict__ for stu in self.stu_list])
  将这个列表写入文件
# 读入学生信息列表(8)
  打开文件
  读文件内容(读出来是'[]'的格式)
  去掉''，转化为列表eval()
  将[字典，字典，字典]转化为[对象，对象，对象](**)
  self.stu_list=[Student(**stu) for stu in stu_list_dict]
  
# 程序运行菜单(1)
  读入学生信息(8)
  while True
  打印菜单
  接收用户选择
  根据用户选择调用对应的方法(7)
  结束(结束前，自动保存学生信息列表)