动态方法与静态方法、面向对象的三大特性之一:继承、属性查找、多继承问题、面向对象的三大特性之一:封装、派生类

动态方法与静态方法

动态方法

绑定给对象的方法

class Sdudent:
    def run(self):
        print(self)
# 类调用绑定给对象的方法:有几个参数就需要传几个参数
Sdudent.run(123)
# 对象调用绑定给对象的方法:会自动将对象当作第一个参数传入
obj = Sdudent()
obj.run()

绑定给类的方法

# 绑定给类的方法
class Student:
    @classmethod
    def eat(cls):
        print(cls)

# 类调用绑定给类的方法:会自动将类当作第一个参数传入
print(Student)  # <class '__main__.Student'>
Student.eat()  # <class '__main__.Student'>
obj1 = Student()
obj1.eat()  # <

静态方法

静态方法是类中的函数,不需要实例,静态方法主要用来存放逻辑逻辑性的代码,主要是一些逻辑属于类,但是和类本身没有交互,即在静态方法中,不会涉及到类中的方法和属性的操作.可以理解为将静态方法存在此类的名称空间中.

class Student:
    @staticmethod
    def speak(a):
        print(a)
# 普普通通的函数:无论谁来调,都必须传固定的参数个数
# 类调用静态方法:要自己传值
Student.speak(123)  # 123
# 对像调用静态方法:要自己传值
obj1 = Student()
obj1.speak(123)  # 123

面向对象的三大特性之一:继承

面向对象有三大特性

最重要的就是继承
	继承、封装、多态

继承的含义

继承就是让类和类之间产生父子关系，子类可以拥有父类的静态属性和方法。

# 现实生活中继承是用来描述人与人之间资源的从属关系
eg：儿子继承父亲资产，那么就可以拥有父亲的一切
面向对象中继承则是用来描述类与类之间数据的从属关系
eg：类A继承了类B，那么类A就可以使用类B中所有的数据(数据、功能...)

继承的目的

现实生活中通过继承可以快速的积累财富少奋斗N多年，并且可以多继承
eg：可以认多个爹、傍800个富婆，走上人生巅峰
面向对象中通过继承可以减少代码冗余、提升开发效率、同样也支持多继承
eg：类A可以继承多了类同时拥有多个类里面的代码使用权

继承的基本使用

'''
class A(B)：
	pass
被继承的类成为：父类或者基类		B
继承别人的类称为：子类或者派生类	A
'''
在python中一个类可以同时继承多个父类
eg:
class A(B,C,D):
    pass

继承的本质

抽象：由下往上抽取相同特征
继承：由上往下直接白嫖资源
'''
在面向对象编程中：其实类和父类的主要功能都是用来减少代码冗余的
对象：数据与功能的集合体
类：多个对象相同的数据和功能的结合体
父类：多个类相同数据和功能的结合体
'''

eg:

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
class Teacher(Person):  # 继承Person类
    def teach(self):
        print(f'{self.name}老师好')
class Stdudent(Person):  # 继承Person类
    def study(self):
        print(f'{self.name}同学好')
stu1 = Stdudent('tuzi',18,'male')
tec = Teacher('jason',18,'male')
stu1.study()  # tuzi同学好
tec.teach()  # jason老师好

名字的查找顺序

不继承的情况下

名字的查找顺序是
先从对象自己的名称空间中查找，没有则去类里面的名称空间查找
对象 >>> 类
'''注意设置值的情况下实在自身的名称空间中添加或者修改数据'''

eg：

class sheep:
    sheep_village = '懒羊羊'
    def choise(self):
        print('123')
s1 = sheep()
print(s1.sheep_village)  # 懒羊羊
s1.sheep_village = '沸羊羊'  # 相当于s1.__dict__['sheep_village'] = '沸羊羊'
相当于自身空间里已经有了这个数据，所以不会去类中查找
print(s1.sheep_village)  # 沸羊羊

单继承的情况下

名字的查找顺序
先从对象自己的名称空间查找，没有则取产生对象的类中查找
如果还没有并且父类则取父类中查找，以此往复
对象 >>> 类 >>> 父类

eg：

class A:
    name = 'a'
class B(A):
    name = 'b'
class C(B):
    name = 'c'
class Myclass(A):
    name = 'myclass'

obj = Myclass()
print(obj.name)

eg2：

class A:
  def f1(self):
      print('from A.f1')
  def f2(self):
      print('from A.f2')
      self.f1()  '''以后看到self点东西 一定要问自己self是谁'''
class MyClass(A):
   def f1(self):
        print('from MyClass.f1')
obj = MyClass()
obj.f2()
# 执行的方法分别是A里面的f2和MyClass里面的f1
只要自己的类里面存在需要的数据，就不会去别的类里面拿

多继承的情况下

eg：

class A:
    # name = 'a'
    pass
class B:
    name = 'b'
class C:
    name = 'c'
class Myclass(A,B,C):
    # name = 'myclass'
    pass
obj = Myclass()
print(obj.name)  # b
根据继承多个父类，从左到右依次查找

eg2:

class D:
    # name = 'd'
    pass
class E:
    name = 'e'
class F:
    name = 'f'
    # pass
class A(D):
    # name = 'a'
    pass
class B(E):
    name = 'b'
class C(F):
    name = 'c'
class Myclass(A,B,C):
    # name = 'myclass'
    pass
    name = 'c'
obj = Myclass()
print(obj.name)  # b

新式类与经典类

"""
在python2中存在经典类与新式类
在python3中只有新式类
区分的关键在于是否继承了一个默认的object类
新式类:直接或者间接继承了object或者其子类的类
经典类:不继承任何的类
"""
为了兼容python2和python3有时候会习惯性的写
class MyClass(object):
	pass
为了兼容python2和python3

菱形继承与非菱形继承

# 非菱形继承的情况下：
父类中名字的查找顺序就是按照继承时从左往右一次查找
如果多个父类还有分类，那么遵循"深度优先"
查找顺序：ADBECF
# 菱形继承的情况下：
父类中名字的查找孙旭就是按照继承时从左往右依次查找
如果多个父类还有分类，那么遵循'广度优先'
查找顺序：ADBECFX
'''名字的查找顺序永远都是先从当前对象自身开始查找'''

eg:

class X:
    name = 'x'
class D(X):
    # name = 'd'
    pass
class E(X):
    # name = 'e'
    pass
class F(X):
    # name = 'f'
    pass
class A(D):
    # name = 'a'
    pass
class B(E):
    # name = 'b'
    pass
class C(F):
    # name = 'c'
    pass
class Myclass(A,B,C):
    # name = 'myclass'
    pass
obj = Myclass()
print(obj.name)  # x

执行流程图

派生类

什么是派生类

# 继承了父类的数据和方法之后，还需要基于该方法做扩展
# 这样的子类就是派生类(本质还是子类)
# 使用super关键字来添加额外的关键字

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class Teacher(Person):
    def __init__(self,name,age,gender,level,salary):
        # super(Teacher,self).__init__(name,age,gender)  # 子类调用父类的方法,完整语法
        super().__init__(name,age,gender)  # 精简语法
        # 添加一些额外的数据
        self.level = level
        self.salary = salary
class Student(Person):
    def __init__(self,name,age,gender,stu_id,class_id):
        super().__init__(name,age,gender)
        self.stu_id = stu_id
        self.class_id = class_id
t1 = Teacher('鸡大侠',18,'male','开挂升满级','小目标')
s1 = Student('tuzi',3,'male',111222333,2)
print(t1.__dict__)
# {'name': '鸡大侠', 'age': 18, 'gender': 'male', 'level': '开挂升满级', 'salary': '小目标'}
print(s1.__dict__)
# {'name': 'tuzi', 'age': 3, 'gender': 'male', 'stu_id': 111222333, 'class_id': 2}

派生功能前瞻

class Myclass(list):  # 把list绑定Myclass类
    def append(self,args):  # 使用append给列表添加值
        if args == 123:  # 判断条件
            print('数字123不能追加')
            return
        super(Myclass,self).append(args)  # 将传入的符合要求的值添加到list列表里面
obj1 = Myclass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)