day12

多继承

'''
python2:深度优先
python3:广度优先
多继承
    深度遍历
    广度遍历

    Python2: 多继承时
        之前，经典类继承方式，采取深度优先原则
            class className(object):
                pass
        之后，新式类继承方式，广度优先原则
             class className():
                pass

新式类都从object继承，经典类不需要。

新式类的MRO(method resolution order 基类搜索顺序)算法采用C3算法广度优先搜索，而旧式类的MRO算法是采用深度优先搜索

新式类相同父类只执行一次构造函数，经典类重复执行多次。

其中：
截止到python2.1，只存在旧式类。旧式类中，类名和type是无关的：如果x是一个旧式类，那么x.__class__定义了x的类名，但是type(x)总是返回<type 'instance'>。这反映了所有的旧式类的实例是通过一个单一的叫做instance的内建类型来实现的，这是它和类不同的地方。

新式类是在python2.2为了统一类和实例引入的。一个新式类只能由用户自定义。如果x是一个新式类的实例，那么type(x)和x.__class__是一样的结果（尽管这不能得到保证，因为新式类的实例的__class__方法是允许被用户覆盖的）。

Python 2.x中默认都是经典类，只有显式继承了object才是新式类

Python 3.x中默认都是新式类,经典类被移除，不必显式的继承object
'''

class A():
    def __init__(self):
        print("class A")

class B(A):
    pass

class C(A):
    def __init__(self):
        print("class C")

class D(B,C):
    pass

D()#class C

print(D.__bases__)
# (<class '__main__.B'>, <class '__main__.C'>)
a=A()
print(a.__class__)
# <class '__main__.A'>
# print(a.__base__)#没有此属性

type与object

"""
-----------------------------------------------------
python 中 object VS type
object与type 共生关系，必须同时存在
面向对象中有两关系：
Ⅰ.父子关系-->继承关系（__bases__可查看继承关系）
Ⅱ.类型与实例的关系，表现为类型的实例化.(__class__属性来查看其所属类型)type函数也行
object
<class 'object'>
type
<class 'type'>
object 是父子关系的顶端，所有的数据类型的父类都是他
type 是类型实例关系的顶端，所有对象都是他的实例
>>>>>>>>>>>>>>>>>>>
object.__class__
<class 'type'>
type.__base__
<class 'object'>
>>>>>>>>>>>>>>>>>>>
list.__base__
<class 'object'>
list.__class__
<class 'type'>
>>>>>>>>>>>>>>>>>>>
mylist=[1,2,3]
mylist.__class__#实例
<class 'list'>
mylist.__base__
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'list' object has no attribute '__base__'
普通类的父类是object，object的父类没有了，object是type的实例化
type的父类是object，type是type的实例化


敲黑板划重点，记住这句话：object是一个type的实例，type继承自object
--------------------------------------------------------------
"""

super方法

'''
super方法：主要用于子类中继承父类
------------------------
class SuperClass():
    def act(self):
        print("SuperClass")

class SubClass(SuperClass):
    def act(self):
        SuperClass.act(self)
        print("SubClass")

sub=SubClass()
sub.act()
---------------------------------------

class SuperClass():
    def act(self):
        print("SuperClass")

class SubClass(SuperClass):
    def act(self):
        super().act()
        print("SubClass")

sub=SubClass()
sub.act()
----------------------------------------------

class SuperClass():
    def act(self):
        print("SuperClass")

class SubClass(SuperClass):
    def act(self):
        print("SubClass")
sub=SubClass()
super(SubClass,sub).act()
'''
'''
super()在多继承中的应用


class A:
    def act(self):
        print("Class A")

class B:
    def act(self):
        print("Class B")

class C(B,A):
    def act(self):
        super().act()
#方法遍历顺序： C->B->A
c=C()
c.act()
------------------------

class X:
    def m1(self):
        print("X")

class Y:
    def m1(self):
        print("Y")

class Z(X):
    def m1(self):
        super().m1()


z=Z()
z.m1()
print("change X to Y")
# 设置z的父类为Y
Z.__bases__=(Y,)
z.m1()
# X
# change X to Y
# Y
'''

装饰器回顾

"""
高阶函数与装饰器
#统计函数运行时间

import time

print(time.time())
print(time.asctime())
# 1597211267.6916356
# Wed Aug 12 13:47:47 2020

import time
# 装饰器
def timer(fun):
    def inner():
        start=time.time()
        fun()
        end=time.time()
        print(end-start)
    return inner
@timer
def fun():
    lis=[]
    for i in range(1,1000000):
        lis.append(i)

if __name__ == '__main__':

     timer(fun())
"""
"""
def fun1():
    string="python!"
    def fun2():
        print(string)

    def fun3():
        print("fun3()")

    return fun2,fun3


fun1()[0]()
fun1()[1]()
"""

"""
import time


# 装饰器
def timer(fun):
    def inner(n):
        start = time.time()
        fun(n)
        end = time.time()
        print(end - start)

    return inner


@timer
def fib(n):
    a, b = 0, 1
    while a <= n:
        a, b = b, a + b


if __name__ == '__main__':
    pass
    print("a1".isalpha())
    
"""

类中的特殊方法

'''
类中的特殊方法
@classmethod
类方法：
只能访问类变量，不能访问实例变量，通过实例化传参无法引入
构造函数中的设置参数，该方法不需要实例化，只能通过类名.方法名（）调用
@staticmethod
静态方法，方法参数与实例没有关系，相当于与类的联系被中断了，
被修饰的方法是单独的函数，不可传参，无须实例化
@property
属性方法
将类方法转为属性，并且可以实现赋值。。。。。。。
'''
 print("a1".isalpha())
    
"""

类中的特殊方法

'''
类中的特殊方法
@classmethod
类方法：
只能访问类变量，不能访问实例变量，通过实例化传参无法引入
构造函数中的设置参数，该方法不需要实例化，只能通过类名.方法名（）调用
@staticmethod
静态方法，方法参数与实例没有关系，相当于与类的联系被中断了，
被修饰的方法是单独的函数，不可传参，无须实例化
@property
属性方法
将类方法转为属性，并且可以实现赋值。。。。。。。
'''