【面向对象二】

动态方法与静态方法

动态方法

1. 绑定给对象的方法

class Student:
    def run(self):
        print(self)
Student.run(11)  # 11
Student().run()  # <__main__.Student object at 0x000001B57A5BC390>

类调用绑定给对象的方法：有几个参数就需要传几个参数；
对象调用绑定给对象的方法：自动将对象当做第一个参数传入。

2. 绑定给类的方法

class Student:
   @classmethod
   def eat(cls):
       print(cls)

Student.eat()  # <class '__main__.Student'>
Student().eat()  # <class '__main__.Student'>

类调用绑定给类的方法：自动将类当做第一个参数传入。
对象调用绑定给类的方法：自动将该对象所属的类当做第一个参数传入。

静态方法（@staticmethod）

静态方法(@staticmethod),静态方法的出现就是为了在类里面可以写一个函数，当普通的函数去调用。类和对象调用这个函数都需要传对应的参数。
定义静态方法需使用@staticmethod装饰器，并且括号后面不需要self参数了。

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

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

面向对象有三大特性:继承、封装、多态
继承使我们能够定义一个继承父类所有功能的类，并允许我们添加更多功能。

继承的含义

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

继承的目的

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

继承的基本使用

# 语法结构
class 子类名(父类名1,父类名2…) :
     pass

“”"
class A(B):
pass
我们将被继承的类称为:父类或者基类 B
继承别人的类称为:子类或者派生类 A
“”"
在python中一个类可以同时继承多个父类
class A(B,C,D):
pass

继承的本质

抽象:由下往上抽取相同特征
继承:由上往下直接白嫖资源

继承法的本质就是抽象。

在面向对象编程中 其实类和父类的主要功能都是用来减少代码冗余的

对象:数据与功能的结合体
类:多个对象相同数据和功能的结合体
父类:多个类相同数据和功能的结合体

提取子类的共同特征得到父类的过程叫做抽象。

由抽象的结果得到继承关系

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
class Teacher(Person):
    def teach(self):
        print(f'{self.name}老师正在讲课')
class Student(Person):
    def study(self):
        print(f'{self.name}学生正在学习')
stu1 = Student('jason', 18, 'male')

属性查找

1. 不继承的情况

名字的查找顺序是
先从对象自己的名称空间中查找 没有则去类里面的名称空间查找
对象 >>> 类

2. 单继承的情况

名字的查找顺序是
先从对象自己的名称空间中查找 没有择取产生对象的类中查找
如果还没有并且类有父类则去父类中查找 以此往复下去!!!
对象 >>> 类 >>> 父类
案例：

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

3. 多继承的情况

“”"
在python2中存在经典类与新式类
在python3中只有新式类
区分的关键在于是否继承了一个默认的object类
新式类:直接或者间接继承了object或者其子类的类
经典类:不继承任何的类
“”"
class A:
pass
# print A.bases # 空的
# print(A.bases) # (<class ‘object’>,)
“”"
有时候我们在定义类的时候会习惯性的写
class MyClass(object):
pass
为了兼容python2和python3
“”"
强度:研究菱形和非菱形问题object不参与图形构建
非菱形继承的情况下
父类中名字的查找顺序就是按照继承时从左往右依次查找
如果多个父类还有分类 那么遵循"深度优先"
ADBECF
菱形继承的情况下
父类中名字的查找顺序就是按照继承时从左往右依次查找
如果多个父类还有分类 那么遵循"广度优先"
ADBECFM

注意：$名字的查找顺序永远都是先从当前对象自身开始查找$

派生类

如果自己写的子类需要使用父类的方法 并且还需要基于该方法做扩展
这样的子类我们称之为派生类(本质还是子类)
那么可以使用super关键字来实现

子类可以派生出自己新的属性，比如人有姓名和年龄，老师有姓名、年龄和职业

# 父类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
# 子类
class Teacher(Person):
    def __init__(self, name, age, job):
        self.name = name
        self.age = age
        self.job = job

这里明显有着重复的代码，我们可以使用super关键字去掉重复的代码。

# 父类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
# 子类
class Teacher(Person):
    def __init__(self, name, age, job):
        # 完整的语法：super(Teacher,self).__init__(name,age)
        super().__init__(name, age)
        self.job = job

派生功能例子

使用派生类，我们可以在列表的方法上进行拓展。

比如我想要使用列表的append方法时无法append(123)

# 编写一个类继承列表
class MyClass(list):
    # 重写方法
    def append(self,args):
        # 如果是123就直接返回
        if args == 123:
            print('数字123不能追加')
            return
        # 如果不是123就调用原有的list中的append方法
        super(MyClass, self).append(args)
obj1 = MyClass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)

"""
执行结果：
数字123不能追加
[333, 222]
"""