类与对象（第三天）

一、类的定义

1、常规的写法：

class Axx（基函数/父类/多父类）：

        a = xxx   # 类变量//全局变量 == 类中的所有人均可以调用

        b =xxx

        def __init__(self,xx):     # 实例化属性  # 初始化方法

                self.xx=xx      # 初始化参数

        def xxx(self,xxx):   # 实例化方法==函数

                AXX.a    # 调用类变量

                print()

       @classmenthod  # 类方法装饰器

        def sss(cls,xxx):    # 类方法

                cls.a   # 调用全局变量

        @stasticmenthod # 静态方法

        def (cls,xxx,xxx):  # 静态方法不能调取实例化属性

                Axx.a   # 强制调用实例化属性

                cls.a  # 调用全局变量

二、派生与继承（super函数//多态）

        1、class 类名（基类名/父类名）：

                代码块

        2、注：子类函数可以对父类进行继承、修改、覆盖、多态等操作。

        3、函数的封装

                目的：隐藏函数中某些实现细节，同时避免使用者调用的参数

                class A :

                        def __init__(self,xxx):

                                self.xxx =xxx  #实例化属性 可以进行调用

                                self.__a =a   # 私有属性，不可以进行调用

                        def __x(self):    # 私有方法，不可以进行调用

        4、方法重写

                注：可以对父类函数的重写//可以对python默认函数进行重写（魔术方法）//

# class Myclass:
#     def __init__(self,x,y,item):
#         self.x = x
#         self.y = y
#         self.item = item
#     # 定义相加的魔法方法
#     def __add__(self, other):
#         return self.x + other.x , self.y + other.y   # 可以自定义加法的魔法方法
#
#     # 定义str 直接返回数值
#     def __str__(self):
#         # return "x = %d , y = %d" % (self.x,self.y)    # 返回 x = 10 , y = 20
#         return "sdadf"   # 返回 sdadf
#     # 自定义len
#     def __len__(self):
#         return len(self.item)   # 修改属性，只对myclass中item进行len计算，其他变量不计算字符

         5、super函数

                注：super函数可以调用父类中函数的用法，同时可以解决重复调用、钻石继承等问题。

                常用的调用方式：

class Parent:
    def __init__(self,name):
        self.name = name
    def add_(self,munn):
        print(f"年龄增加了{munn}岁")

class Child(Parent):
    def __init__(self,name,age):
        super().__init__(name)   # suoer 函数对父类的继承 == 对父类初始化参数的继承
        self.age = age
    def add_(self,munn):
        print("sss")
        super().add_(munn)  # 对父类方法的调用  // 若没有次行函数则为对父类方法的覆盖

    def print_info(self):
        print(self.name,self.age)

c = Child("sadfsa",151)
c.print_info()
c.add_(3  # sss   #年龄增加了3岁

        为什么使用 super().__init__()？

• 代码重用：避免在子类中重复父类的初始化代码。

• 正确初始化：确保父类的初始化逻辑（如设置属性、分配资源等）被执行。

• 支持多重继承：在多重继承情况下，super() 可以确保所有基类的构造函数都被正确调用方法

三、迭代器与生成器

注：生成迭代器（iter（range(10)））

        读取迭代器中的内容（next(iter)）== 每次读取一个数值 == 超出索引时会报错

                try：  except ：else： finally：  ==去解决报错问题

        生成器：yield 表达式：

                yield 与 return 的区别：

                        yield ：在循环中可以依次输出循环列表中的内容，当输出后，循环暂停，当值使用后循环继续。

                        return：在循环中return 后面的代码不执行。循环截至。

四、函数式编程

        1、内置高阶函数

                

        2、lambda 表达式  == 可以嵌套在高阶函数中进行组合使用

        

# # 获取年龄最大的人
# # 高阶函数写法
# print(max(Gril.list_gril,key = lambda item:item.age))  # key == 为判断的关键字  == 返回的结果最大值对象

"""
# 常规写法
maxx = Gril.list_gril[0].age
for item in Gril.list_gril:
    if maxx < item.age:
        maxx = item.age
print([[item.name,item.age] for item in Gril.list_gril if item.age == maxx])
"""

五、函数闭包

        1、将函数作为返回值进行调用

        2、函数闭包的特点：

                嵌套函数 + 内部函数访问外部函数的变量 + 外部函数返回内部函数

# def give(money):
#     print(f"当前得到了{money}元")
#
#     def child_buy(price):
#         nonlocal money
#         money -= price
#         print(f"孩子花{price}元，剩余{money}")
#
#     return child_buy  # 返回未执行函数
#
# action = give(100)  # 调用主函数  == 执行
# action(80)  # 调用函数内的封装函数
# action(30)  # 调用函数内的封装函数

        3、函数闭包的特点 == 主函数生成后 函数栈帧不会立即释放，等待内部函数进行执行

                                ==        内存消耗过大

六、装饰器

        注：装饰器执行先后顺序

@A  # 新功能
@B  # 新功能
class C  # 旧功能
执行顺序：：B A C