类的名字查找

今日内容概要

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

动态方法

就是可以动态传参数的方法(函数)

静态方法就是不能动态传参的方法

class Yun(object):
    def __init__(self, name):
        self.name = self
	  绑定给队形的方法
    def yu(self):
        print("我是绑定给对象的方法哦", self)

    @classmethod  绑定给类的方法
    def yun_l(cls):
        print('我是类方法', cls)

    @staticmethod  静态方法
    def yun(a, d):
        print(a, d)
        print("我是静态方法哦, 我要几个参数你就得给我几个哦")


aa = Yun("jason")
#               绑定给Yun object 的方法
# print(aa.yu)  # <bound method Yun.yu of <__main__.Yun object at 0x000001AC73DC2340>>
#              绑定给 class Yun 的方法
# print(aa.yun_l)  # <bound method Yun.yun_l of <class '__main__.Yun'>>
#             函数
# print(aa.yun)  # <function Yun.yun at 0x000001AC73EEEC10>

"""
绑定给对象的方法 会把默认把对象自身当作第一个参数传给所调用的方法
             类调用的时候该传几个参数传几个
绑定给类的方法 会默认把类自身当作第一个参数传给所调用的方法
            对象调用的时候也会把产生对象本身的类当作第一个参数传过去
静态方法  把它当作函数就好的 该传几个就传几个

"""
aa.yu()  # 我是绑定给对象的方法哦 <__main__.Yun object at 0x000001DB26DB2340>
aa.yun_l()  # 我是类方法 <class '__main__.Yun'>

面向对象之继承的概念

面向对象的三大特性： 封装 继承 多态

1. 三者中继承最为核心(实操最多， 体验最强)
2. 封装和多态略微抽象

"""
1. 继承的含义
    在现实生活中继承表示人与人之间资源的
    eg: 儿子继承父亲 ( 子承父业 )
    在编程世界中继承表示类与类之间资源的从属关系
    eg: 类A继承类B

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: 我们最常用的就是子类和父类

继承的本质

对象：数据和功能的集合体

类 (子类）： 多个对象相同的数据和功能的集合体

父类：多个类（子类）的相同的数据和功能的集合体

继承本质应该分为两部分

​ 抽离：将多个类的相同的数据和方法 抽出去形成一个新类

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

名字查找顺序

1.不继承

class A:
    name = "jason"

    def aa(self):
        print("哈哈")
        pass


a1 = A()
print(a1.name)

名字的查找顺序

1. 会先在a1的名称空间找
2. a1里没有则会去产生a1的类A里面找
3. 如果类A没有则会报错

2. 单继承

class A:
    name = "jason"
    pass


class B(A):
    name = "kevin"
    pass


class C(B):
    name = "oscar"
    pass


aa = C()
print(aa.name)  # "oscar"  kevin  jason
print(C.mro())  # [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

查找顺序

1. 当对象aa的名称空间没有则会去产生aa的类C里面去找
2. 如果类C的里面有则取C里面，如果没有则去C的父类里面找，
3. 如果还没有则去父类的父类里面去找 父类都找完了还没有则报错。

ps: 每次查找都会先在自己里面找

3.多继承

"""
非菱形多继承
"""
class A:
    name = "jason"
    pass
class B:
    # name = "kevin"
    pass
class C(B, A):
    # name = "oscar"
    pass

aa = C()
print(aa.name)  # oscar  kevin  jason
print(C.mro())  # [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

名字的查找顺序

1. 当aa的名称空间没有则会去产生aa的类C里面去找
2. 如果类C没有则会去类B里面去找
3. 如果类B没有则会去类A里面去找
4. 类A没有则报错

"""
菱形继承
"""
class A:
    name = "jason"
    pass
class B(A):
    # name = "kevin"
    pass
class C(A):
    # name = "oscar"
    pass
class D(C, B):
    # name = "tony"
    pass
aa = D()
# print(aa.name)  # tony  oscar  kevin  jason
print(D.mro())  # [<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

名字的查找顺序

1. 当aa的名称空间没有则会去产生aa的类D里面去找
2. 如果类D没有则会去类C里面去找
3. 如果类C没有则会去类B里面去找 而不是去C的父类A里面去找
4. 如果类B没有则会去类A里面去找
5. 如果类A没有则会报错

经典类和新式类

• 经典类

  不继承object或者其子类的类

• 新式类

  继承object或者其子类的类

在python2中有经典类和新式类

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

class Studet(object):pass
ps: 以后我们在定义类的时候 如果没有其他明确的父类 
    也可能习惯写object兼容

派生方法

子类基于父类某个方法做了扩展
class Mylist(list):
    def append(self, values):
        # 方式一
        # list.append(self, values)
        # 方式二
        # super(Mylist,self,).append(values)
        # 方式三
        super().append(values)

aa = Mylist()

aa.append(11)
print(aa)  # [11]