动静态，面向对象三大特征之继承

对象独有的功能

class Person:
	school = '清华大学'
	
	def __init__(self, name, age):  # 让对象拥有独有的数据
		self.name = name 
		self.age = age
	
	def eat(self):
		print('%s正在干饭' % self.name)

	def other(self, a, b):
		print('哈哈哈')

obj = Person('jason', 18)
print(Person.school)  # 清华大学
obj.eat()  # jason正在干饭
obj.other(1, 2)  # 哈哈哈
# 如何绑定二字
p1 = Person('kevin', 21)
Person.eat(p1)  # kevin正在干饭

定义在类中的函数 我们称之为方法
是多个对象公共的方法 也算多个对象独有的方法 ，对象来调用就会将对象当做第一个参数传入

针对对象独有的方法 我们无法真正实现

1.如果在全局则不是独有的
2.如果在类中则是公共的

python解释器针对上述问题添加了一个非常牛的特性

定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)

动静态方法

动态方法

1.绑定给对象的动态方法

该动态方法会自动将对象作为第一个参数传给被调用的动态方法

该方法创建就是

def 函数名:
	函数体代码

class Person:
    name = 'jason'

    def eat(self):
        print('%s正在干饭' % self.name)


obj = Person()
print(Person.name)  # jason
print(obj.name)  # jason
obj.eat()  # jason正在吃饭
obj.name = 'kevin'  # 只会改变自己的
print(Person.name)  # jason
print(obj.name)  # kevin
obj.eat()  # kevin正在吃饭

2.绑定给类的动态方法

该方法会将类作为第一个参数自动传给该动态方法

该方法创建就是

 @classmethod
 def 函数名:
 	函数体代码

class Person:
    name = 'jason'

    @classmethod
    def eat(self):
        print('%s正在干饭' % self.name)


obj = Person()
print(Person.name)
print(obj.name)
obj.eat()
obj.name = 'kevin'
print(Person.name)
print(obj.name)
obj.eat()  # jason正在吃饭

静态方法

类中编写的函数方法在方法名上方使用@staticmethod可以生成类中的静态方法，静态方法调用必须要传入指定的参数才行，不论调用对象是类还是对象

该方法创建

@staticmethod
def 函数名:
	函数体代码

class Person:
    name = 'jason'

    @staticmethod
    def eat(a, b):
        print('正在干饭')


obj = Person()
print(Person.name)
print(obj.name)
obj.eat(1, 2)  # 需要传参数
obj.name = 'kevin'
print(Person.name)
print(obj.name)
obj.eat(1, 2)  # 需要传参数

面向对象三大特性之继承

面向对象的三大特征:继承， 封装， 多态

• 思考

  1.继承的含义:

  在现实生活中继承其实就是用来描述人与人之间资源的关系
      eg:儿子继承父亲的财产(拥有了父亲所有的资源)
  在编程世界里继承其实就是用来描述类与类之间数据的关系
      eg:类A继承类B(拥有了类B里面所有的数据和功能)
  

  2.继承的目的

  现实生活中继承就是想占有别人的财产
      eg:亲身父亲 干爹 干妈 富婆
  编程世界里继承就是为了节省代码编写
      eg:可以继承一个类 也可以继承多个类
  

• 继承的操作

  结构

  class 类名(类名);
  	pass
  

  1.定义类的时候要在类名后面加括号
  2.括号里填写你要继承的类名
  3.括号里可以填写多个继承类名，用逗号隔开即可

  eg:

  class MyClass(A, B, C)
  	pass
  

  我们将被继承的类称之为: 父类或基类或超类
  我们将继承类的类称之为: 子类或派生类
  ps:平时最常用的就是父类和子类

• 本质

  抽象:将多个类共同的数据或功能抽取出来形成一个基类
  继承:从上往下白嫖各个基类里面的资源

  对象:数据和功能的结合体
  类:多个对象相同的数据和功能的结合体
  父类:多个类相同的数据和功能的结合体
  ps:类和父类最主要的功能其实就是节省代码

  一定要掌握继承的本质 这样以后你才会在代码中自己定义出子类父类

名字的查找顺序

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

先是在对象自身的空间中查找，，没有再去该对象的类里面找

对象>>>类

举例说明

class Person:
    name = 'jason'

    def eat(self):
        print('%s正在干饭' % self.name)


obj = Person()  # 产生一个对象
print(obj.name)  # jason
obj.name = 'kevin'  # 改变的是对象本身的name
print(obj.name)  # kevin
print(Person.name)  # jason 未改变类里面的
obj.eat()

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

先在对象自身找，然后在该对象的类找，最后在该类的父类找

对象>>>子类>>>父类

class A:
     name = 'from A'
     pass
class B(A):
     name = 'from B'
     pass
class C(B):
     name = 'from C'
     pass
class MyClass(C):
     name = 'from MyClass'
     pass
obj = MyClass()

取值查找顺序:from MyClass>>>from C>>>from B>>>from A

没有了就会报错

还有一种情况:

class A1:
	def func1(self):
	    print('from A1 func1')
	def func2(self):
	    print('from A1 func2')
	    self.func1()  # obj.func1()
class MyClass(A1):
    def func1(self):
        print('from MyClass func1')
obj = MyClass()
obj.func2()

取值查找顺序:from A1 func2>>>from MyClass func1

只要涉及到对象查找名字 几乎要回到最开始的位置依次查找

class D:
    name = 'from D'
    pass
class E:
    name = 'from E'
    pass
class F:
    name = 'from F'
    pass
class A(D):
    name = 'from A'
    pass
class B(E):
    name = 'from B'
    pass
class C(F):
    name = 'from C'
    pass
class MyClass(A, B, C):
    name = 'from MyClass'
    pass
obj = MyClass()

取值查找顺序:from MyClass>>>from A>>>from D>>>from B>>>from E>>>from C>>>from F>>>

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

非菱形继承(最后不会归总到一个我们自定义类上)

深度优先(每个分支都走到底 再切换)

菱形继承(最后归总到一个我们自定义类上)

广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)

经典类与新式类

经典类

不继承object或其子类的类(什么都不继承)

新式类

继承了object或其子类的类

• python2和python3中的区别

  在python3中所有的类默认都会继承object
    	也就意味着python3里面只有新式类
  在python2中有经典类和新式类
    	由于经典类没有核心的功能 所以到了python3直接砍掉了
  

为了与python2兼容，我们可以 class MyClass(object): pass

但是以后写代码针对object无需关心 知道它的存在即可

派生方法

使用super可以拓展子类的内置属性，在父类的基础上获取新的属性。
派生使用形式：

def init(self):
super().init(父类实例化时需要的参数) 该语法针对于python3.X
super(父类, self).init(父类实例化时需要的参数) 该语法针对于python2.X
添加上新的属性

举例说明

class MyClass(list):
    def append(self, value):  # []  截胡
        if value == 'jason':
            print('jason不能添加')  # 输出
            return
        super().append(value)


obj = MyClass()  # 产生一个对象  []
obj.append('jason')
obj.append(111)
obj.append(222)
obj.append(333)
print(obj)  # [111, 222, 333]
print(MyClass.mro())  # 查看该类产生的对象名字的查找顺序