面向对象之继承

面向对象之动静态方法

@classmethod

@staticmethod

在类中的动态方法：
class 类名:
  name = '倚天屠龙记'
  def func1(self):
    print('屠龙刀牛逼')
#在类中直接定义函数，默认绑定给对象自身，self就是本身的意思，当对象调用这个函数时，默认的第一个参数就是对象自身

@classmethod
def func2(cls):
  print('倚天一出谁与争锋')
#被 @classmethod 修饰的函数，默认的参数就是这个类，类调用这个函数是，就会把类本身当作第一个参数传入

在类中的静态方法：
@staticmethod
def func3(a):
  print('张无忌牛逼')
# 被@staticmethod 修饰的函数，就是默认的函数不会自动获取任何参数，不管是类还是对象调用，都必须手动传参


obj = 类名() #创建一个对象
obj.func1()  #不需要传参 也可以执行，因为默认传参self 就是对象本身
类名.func1(123) # 必须传参，因为默认传参self 是对象本身 类调用还是要传参的
ojb = Dragon()
Dragon.func2()
# func2 默认传参为类本身 所以不需要传参也可以调用
ojb.func2()
# func2 默认传参为类本身 对象中也包括类 所以把产生对象的类也传进去了
ojb.func3()
Dragon.func3()
# 不管是对象还是类 调用func3 都需要传参，因为没有默认参数

面向对象之继承的概念

'''
面向对象的三大特性 ：封装  继承 多态
三者中 继承 最为核心，因为实际工作中运用次数最多，体验感也是最强
封装和多态略微抽象
'''

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

2.继承的目的
	在现实生活中儿子继承父亲就拥有了父亲所有资源的支配权限
 	在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限
  
3.继承的实操
  class Son(Father):
    pass
  #这样 类 son 就可以用到 father 类中的所有方法和数据
  #也支持多继承，定义类的时候 class a(b,c,d,e,f)使用逗号隔开即可
      	class a(b,c,d,e,f):
         pass
    
 '''
  1,继承其他类的类 叫做 子类 或者 派生类
    一般都叫子类 子类可以拥有父类的所有公共数据和方法
  2.被继承的类叫做 父类 或者 超类
    一般都叫父类
 '''

继承的本质

"""
对象:数据与功能的结合体
类(子类):多个对象相同数据和功能的结合体
父类:多个类(子类)相同数据和功能结合体
ps:类与父类本质都是为了节省代码
"""
继承本质应该分为两部分
	抽象:将多个类相同的东西抽出去形成一个新的类
 	继承:将多个类继承刚刚抽取出来的新的类
重点记忆 抽象 和 继承 的概念

变量名的查找顺序

无继承和单继承

1.在没有继承的情况下

 class A1:
    name = '张无忌'
    def func(self):
    print('来自张无忌')
      
  obj = A1()
  obj.name = '赵敏'
  
  print(A1.name)  #'张无忌' 同样的名字，类中自己拥有则优先用自己的
  print(obj.name) #'赵敏'  同样的名字，对象中自己拥有则优先用自己的
    """
    对象查找名字的顺序
        1.先从自己的名称空间中查找，谁调用的先找谁里面有没有
        2.自己没有再去产生该对象的类中查找
        3.如果类中也没有 那么直接报错
    对象自身 >>>    产生对象的类
    """
    
 2. 在单继承的情况下

	class A：
  	name = '张翠山'
     
  class A1(A):
		pass
      
  obj = A1()
  obj.name = '赵敏'
  
  print(A1.name)     # '张翠山' 类里面没有 子类没有就找父类 
  print(obj.name)    #  自己有就用自己的 ，没有就找自己的类，
  
  ''' 对象自身 >>>> 产生对象的类 >>> 类的父类 >>> 父类的父类
      从内而外 层层寻找 优先找自身
  '''
  
  
      class A1:
        def func1(self):
            print('from A1 func1')

        def func2(self):
            print('from A1 func2')
            self.func1()

    class B1(A1):
        def func1(self):
            print('from B1 func1')

    obj = B1()   #B1类产生了的对象 
    obj.func2()  #对象本身没有 然后找产生的类B1  B1里面没有就找它的父类A1， A1里面有 就执行， print('from A1 func2')，和 self.func1()
# self = 对象本身， 那就又回到了obj, boj没有找B1 B1有就执行print('from B1 func1')
    
 '''
 使用 对象.名字的方法，永远都是从对象自身开始一步步查找的
 self指代的就是一个对象，一定要搞清楚 self指代的是哪个对象
 '''

多继承查找顺序

    class G:
        name = 'from G'
        pass
    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):
        pass
    obj = S1()
    # print(obj.name)
    
    # print(S1.mro())
    # 找名字顺序 ojb >>> S1 >>> D >>> A >>> E >>> B >>> F >>> C 
       对象自身   >>>   产生对象的类     >>>    父类(从左往右)
      
    
 3.多继承情况下名字的查找顺序
'''
	菱形继承
    广度优先(最后才会找闭环的定点)
 非菱形继承
    深度优先(从左往右每条道走完为止)
 	ps:mro()方法可以直接获取名字的查找顺序
'''

经典类与新式类


经典类：不继承object或者其子类的类
新式类:继承object或者其子类的类
    在python2中有经典类和新式类
    在python3中只有新式类(所有类默认都继承object)
现在基本都是python3了  

这也是python2与python3的区别   
python3中 所有的类都默认带有 object
Python2中 需要手动加上 object

class A1(object):
	pass

派生方法

派生方法就是子类基于父类某个方法做的扩展
关键词 super()

class Person:
  def __init__(self,name,age)
  	self.name = name 
    self.age = age
    
class Student(Person):
  def __init__(self,name,age,gender)
  	 super().__init__(name,age)
     self.sid = sid
      
# 如果在子类中需要调用父类的方法 需要用到关键词 super().的方式把父类方法先复制过来，然后在加入新的参数

class Teacher(Person):
   def __init__(self,name,age,level)
    	super().__init__(name,age)
      self.level = level
      

#super(). 可以调用父级方法