面向对象，动静态方法，名字查找顺序，派生方法

目录

• 面向对象中级
  • 动静态方法
  • 面向对象之继承的概念
  • 名字的查找顺序
  • 经典类与新式类
  • 派生方法
  • super()方法使用注意事项

面向对象中级

动静态方法

在类中定义的函数有多种特性
'''
    Author:clever-cat
    time  :2022/11/3-16:26
'''
 
 
class Student:
    schoo_name = '清华大学'
 
    """
    类中直接定义函数 默认绑定给对象 类调用有几个参数传几个 对象
    调用第一个参数就是对象自身
    """
    
    def func1(self):
        print('绑定方法')
 
    # 被@classmenthod修饰的函数 默认绑定给类 类调用第一个参数
    # 类自身 对象也可以调用并且会自动将产生该对象的类当作第一个参数传入
 
    @classmethod
    def func2(cls):
        print('我是类方法 classmenthod', cls)
 
    """
    普通函数 无论是类还是对象调用 都必须自己手动传参
    
    """
 
    @staticmethod
    def func3(a):
        print('我是静态方法,staticmenthod', a)
 
 
st1 = Student()
Student.func1(1231)  # 绑定方法
st1.func1()  # 绑定方法
 
st1.func2()  # 我是类方法 classmenthod <class '__main__.Student'>
Student.func2()  # 我是类方法 classmenthod <class '__main__.Student'>
 
st1.func3(1231)  # 我是静态方法,staticmenthod 1231
Student.func3(1231)  # 我是静态方法,staticmenthod 1231
 

面向对象之继承的概念

面向对象三大特征

1. 封装

2. 继承

3. 多态

   三者中继承最为核心（实操最多 体验最强）
   封装和多态略微抽象

4. 继承的含义
   在现实生中继承表示人与人之间支援的从属关系
   eg:儿子继承父亲 干女儿继承干爹
   在编程世界中继承表示类与类之间资源的从属关系
   eg:类A继承类B

5. 继承的目的
   在现实生活中儿子继承父亲就拥有了父亲所有资源的支配权限
   在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限

6. 继承的实操

    
   class Father:
       name = 'Father'
       pass
    
    
   class son(Father):
       name = 'son'
   1.在定义类的时候类名后面可以夹括号填写其它类名 意味着继承其他类
   2.在python中支持多继承 括号内填写多个类名碧池逗号隔开即可
    
   class F1:
       pass
    
   class F2:
       pass
    
   class F3:
       pass
    
   class Son(F1,F2,F3):
       pass
    
    
   1.继承其他类的类 Son
   	我们称之为子类、派生类
   2.被继承的类 F1,F2,F3
   	我们称之为父类、基类、超类
   我们最常用的就是子类和父类

   继承的本质

   """
   对象：数据与方法的结合体
   类(子类)：多个对象相同数据与方法的结合体
   父类：多个类(子类)想要数据与方法的结合体
   类与父类本质都是为了节省代码
    
   """

   继承本质应该分为两个部分

   1. 抽象：将多个类相同的东西抽出去形成一个新的类
   2. 继承：将多个类继承刚刚抽象出去的新类

名字的查找顺序

1. 不继承情况下名字的查找顺序

   对象查找名字的顺序
       1.先从对象自己的名称空间中查找
       2.自己没有再去产生该对象的类中查找
       3.如果类中也没有则会报错
       对象 》》》 产生对象的类
    

   class Son:
       # name = 'Son'
    
       def func1(self):
           print('Son func1')
    
    
   obj = Son()
   # obj.name = 'All'
   # print(obj.name)  # All 先找对象名称空间
    
   # print(obj.name)  # All 先找对象名称空间  #Son 在查找实例化对象类中的命名空间
   # obj.name = 'All'
    
    
   print(obj.name)  # AttributeError: 'Son' object has no attribute 'name'
    

2. 单继承情况下名字的查找顺序、
   对象自身》》产生对象的类》》父类

   class A:
       # name = 'A'
       pass
    
    
   class B(A):
       # name = 'B'
       pass
    
    
   class C(B):
       # name = 'C'
       pass
    
    
   # obj = C()
    
   # obj.name = 'ALL'
   # print(obj.name)  # ALL
    
   # print(obj.name)  # C
   # print(obj.name)  # B
   # print(obj.name)  #A
    
   # 查找不到直接报错
    
   # print(obj.name)  # AttributeError: 'C' object has no attribute 'name'
    
    
   # 烧脑小案例
    
   class AA:
       def func1(self):
           print('我是AA func1')
    
       def func2(self):
           print('我是AA func2')
           self.func1()
    
    
   class AB(AA):
       def func1(self):
           print('我是AB func1')
    
    
   obj = AB()
   obj.func2()
   # 我是AA func2
   # 我是AB func1
   """
   1.首先查找自己，没有，去产生对象的类中查找没有
   2.再去父类中查找，查早到，调用，打印 我是AA func2 继续执行，self.func1()
   3.重点看self，类中的绑定方法，谁调用谁是主人公,说要就是obj对象
   4.从obj对象名称空间开始查找
   5.在产生对象的类中找到了，执行代码。打印 我是AB func1
   """
    

3. 多继承情况下名字查找顺序

   1. 菱形继承

      ​ 广度优先搜索(最后才会找闭环的顶点)

   2. 非菱形继承

      ​ 深度优先搜索(从左往右每条道走完为止)

   3. mro()方法了可以直接获取名字的查找顺序

   对象自身》》产生对象的类》》父类(从左往右)

   class F1:
       name = 'jason'
       pass
    
    
   class F2:
       # name = 'oscar'
       pass
    
    
   class F3:
       # name = 'jerry'
       pass
    
    
   class S1(F1, F2, F3):
       # name = '嘿嘿嘿'
       pass
    
    
   obj = S1()
   # obj.name = '想干饭'
   print(obj.name)
    
    
    
   '''
       对象自身   >>>   产生对象的类     >>>    父类(从左往右)
   '''
   class G:
       name = 'from G'
       pass
   class A:
       # name = 'from A'
       pass
   class B:
       # name = 'from B'
       pass
   class C:
       # name = 'from C'
       pass
   class D(A):
       # name = 'from D'
       pass
   class E(B):
       # name = 'from E'
       pass
   class F(C):
       # name = 'from F'
       pass
    
   class S1(D,E,F):
       pass
   obj = S1()
   # print(obj.name)
    
   print(S1.mro())

经典类与新式类

1. 经典类：不继承object或者其子类的类

2. 新式类：继承object或者其子类的类

   • 在python2中有经典类与新式类
   • 在python3中只有新式类(所有类默认继承object)

   class Student(object):pass

   以后在定义的时候 如果没有其他父类继承 也可以习惯性的写上可以增加兼容python2

派生方法

# 子类基于父类的方法做了扩展
class Father(object):
    def __init__(self, name, age, pwd):
        self.name = name
        self.age = age
        self.pwd = pwd
 
 
class Son(Father):
    def __init__(self, name, age, pwd, gender):
        # 子类调用父类的方法
        super().__init__(name, age, pwd)
        self.gender = gender
 
 
obj = Son('张三', 18, '123', 'male')
 
print(obj.name)  # 张三
print(obj.gender)  # male

super()方法使用注意事项

class E:
    def a(self):
        print('class E')
 
    pass
 
 
class A:
    def a(self):
        print('class A')
 
    pass
 
 
class B(A):
    def a(self):
        print('class B')
 
    pass
 
 
class C(B):
    def a(self):
        print('class C')
        super().a()  # class B
        super(C, self).a()  # class B 正常情况下
        super(B, self).a()  # class A 可以指定重哪个类想向上一级调用父类方法
        # super(A, self).a()  # 可以指定从哪个类想向上一级调用父类方法，如果父级没有则报错
        # super(E, self).a()  # 可以指定从哪个类想向上一级调用父类方法，如果这个类不是本类的父类则报错
 
    pass
 
 
obj = C()
obj.a()
 
print(C.__bases__)
 
print(C.__base__)
print(C.mro())