动静态、继承本质、对象名字查找顺序

• 动静态方法
• 面向对象之继承的概念
• 继承的本质
• 名字的查找顺序
• 经典类与新式类
• 派生方法

动静态方法

在类中定义的函数有多种特性
1.绑定给对象的方法
class Student:
    school_name = '家里蹲大学'
    def func1(self):
        print('摆烂到底')

# 类中直接定义函数 默认绑定给对象 对象调用第一个参数就是对象本身stu1
stu1 = Student()
stu1.func1()  # 摆烂到底

# 而类调用的话有几个参数就得传几个 不传就报错
Student.func1(1)  # 摆烂到底

2.绑定给类的方法 被@classmethod修饰的函数默认绑定给类的 类的调用第一个参数就是类自身 对象也可以调用并且会自动将产生该对象的类当做第一个数传入
class Student:
    school_name = '家里蹲大学'
    
    @classmethod
    def func1(self):
        print('蹲到底', self)
Student.func1()  # 蹲到底 <class '__main__.Student'> 被@class装饰过的函数类对用类自身类体函数就不需要传值了 类的调用第一个参数就是类自身 相当于func2(Student)
stu1 = Student()
stu1.func1()  # 蹲到底 <class '__main__.Student'> 对象也可以调用并且会自动将产生该对象的类当做第一个数传入 也相当于func2(Student)

3.静态方法  通过被@staticmethod修饰的函数 无论是函数还是对象本身 都必须自己手动传参
class Student:
    school_name = '家里蹲大学'

    @staticmethod
    def func1(a):
        print('你看我蹲不蹲', a)
stu1 = Student()
Student.func1(123)  # 你看我蹲不蹲 123
stu1.func1(123)  # 你看我蹲不蹲 123

面向对象之继承的概念

​ 面向对象的三大特征

​ 封装 继承 多态

​ 三者中继承最为核心(实操最多 体验最强)

​ 封装和多态略微抽象

1. 继承的含义

   在显示生活中继承表示人与人之间的资源的从属关系

   如：儿子继承父亲 干女儿继承干爹

   2. 继承的目的

   在显示生活中儿子继承父亲就拥有了父亲所有的资源支配权限

   在编程世界中类A继承类B就拥有了类B所有的数据和方法使用权

   3. 继承的实操

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

继承的本质

​ 对象：数据与功能的结合体

​ 类(子类)：多个对象相同数据和功能的结合体

​ 父类：多个类(子类)相同数据和功能结合体

​ ps：类与父类本质都是为了节省代码

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

​ 抽象：将多个类相同的东西抽出去形成一个新的类

​ 继承：将多个类继承刚刚抽取出来的新的类

名字的查找顺序

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

class C1:
    name = 'jaosn'
    def func(self):
        print('from func')
obj = C1()
print(C1.name)  # jason 类肯定找的自己的
obj.name = '哈哈哈'  # 由于对象自己原本没有name属性而该语法会在对象的名称空间中创建一个新的'键值对'
print(obj.__dict__)  # {'name': 'jason'}
print(obj.name)  # 哈哈哈
print(C1.name)  # jason

查找顺序是：
	1.先从自己的名称空间中查找
    2.自己没有子爱情产生该对象的类中查找
    3.如果类中没有 那么直接报错
对象自身  >>>  产生对象的类

2. 单继承情况下的名字的查找顺序

class F1:
    name = 'jason'
class S1(F1):
    name = 'kevin'
obj = S1()
obj.name = 'oscar'
print(obj.name)  # oscar

查找顺序是：
对象自身  >>>  产生对象的类  >>>  父亲

class F3:
    name = 'jerry'
class F2(F3):
    name = 'tony'
class F1(F2):
    name = 'jason'
class S1(F1):
    # name = 'kevin'
    pass
obj1 = S1()
obj1.name = '嘿嘿嘿'
print(obj1.name)  # 因为自身有 找的肯定显示自身嘿嘿嘿 当自身没有的话 去产生obj对象的类中查找 再没有的话去继承的父类中找 再没有则就报错
 
class A1:
    def func1(self):
        print('from A1 func1')
    def func2(self):			这里相当于func2(self) 打印的是from A1 func2 这时self指代的就是obj
        print('from A1 func2')
        self.func1() 这里相当于obj.func1() 这里查找顺序是先对象本身 再去到打印产生对象的类中的from B1 func1
class B1(A1):
    def func1(self):
        print('from B1 fun1')
        
obj = B1()
obj.func2()

'''
强调：对象点名字 永远从对象自身开始一步步查找
以后在看到self.名字的时候 一定搞清楚self指代的是哪个对象
'''

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

菱形继承
	广度优先(最后才会找闭环的定点)
非菱形继承
	深度优先(从左往右每条到走完位置)
ps: mro()方法可以直接获取名字的查找顺序
'''
对象自身  >>>  产生对象的类  >>>  父类(从左往右)
'''
class F1:
    name = 'jason'
class F2:
    name = 'oscar'
class F3:
    name = 'jerry'
class D2(F1, F2, F3):
    name = '哈哈哈'
obj = S1()
obj.name = '嘿嘿嘿'
print(obj.name)  按顺序查找先对象自身 再产生对象的类 再父类

菱形继承：广度优先(最后才会找闭环的定点)

class G:
    name = 'from G'
    pass
class A(G):
   # name = 'from A'
    pass
class B(G):
    name = 'from B'
    pass
class C(G):
    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): 这时括号中父类D从左往右的查找顺序不会再往G走直接到E
    pass
obj = S1()
print(obj.name)

print(S1.mro())  [<class '__main__.S1'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.F'>, <class '__main__.C'>, <class '__main__.G'>, <class 'object'>]  # 直接获取S1的查找顺序

非菱形继承：深度优先(从左往右每条到走完位置)

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): 这时括号中父类D从左往右的查找顺序一直走到底 D这条没有就E这一条
    pass
obj = S1()
print(obj.name)

经典类与新式类

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

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

​ 在python2中有经典类新式类

​ 在python3中只有新式类(所有类默认都继承object)

class Student(object):pass
print(Stdent.__dict__)

派生方法

子类基于父类某个方法做了扩展
class Person():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

# class Student(Person):  继承了Person 在使用类名加括号时也需要传值name age gender
#     pass


class Student(Person):  # Student在继承Person了中的name age gender 还想要再进行扩展
    def __init__(self, name, age, gender, sid):
        # super Student子类调用父类Person的方法
        super().__init__(name, age, gender)  # super(Student(当前类的名字), self)是super的完整写法 但在python3中进行了优化括号内无序传值  在__init__(传上父类需要的参数name age gender)
        self.sid = sid  # 再进行想要扩展的
stu1 = Student('jason', 18, 'male', 123456)
print(stu1.__dict__)
派生核心思想：我把你继承拥有了 我还能自己做扩展