python（day031——面向对象4）

1.判断类之间的关系

使用issubclass()或者isinstance()方法来检测类之间的关系。如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回True，否则返回False。

2.多重继承

class House:
    def __init__(self,length,width,height):
        self.length=length
        self.width=width
        self.height=height

    def print_info(self):
        print("房子长%s,宽%s,高%s" % (self.length,self.width,self.height))


class Car:
    def __init__(self,engine):
        self.engine=engine

    def print_info(self):
        print("车子%s" % (self.engine))

class BigCar(Car):
    def __init__(self,engine):
        Car.__init__(self,engine)
        print("BigCar被初始化")
        self.engine=engine

    def print_info(self):
        print("BigCar车子%s" % (self.engine))

class HouseCar(House,BigCar,):
    def __init__(self,length,width,height,engine):
        House.__init__(self,length,width,height)
        BigCar.__init__(self,engine)


h=HouseCar(100,5,6,"宝马")
print(h.length)
h.print_info()
#如果不重写，默认调用第一个
#如果子类没有实现构造函数，那么实例化时候，默认调用第一个继承类的构造函数
#子类查找实例方法时候，使用广度优先策略，先从同级类找方法，如果都没有，则从父类里面找

3.多态

class F1:
    pass

class S1(F1):

    def show(self):
        print ('S1.show')

class S2(F1):

    def show(self):
        print ('S2.show')


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""

    obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 #s1_obj，执行 S1 的show方法，结果：#S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 #ss_obj，执行 Ss 的show方法，结果：#S2.show

#多态：给不同方法传入不同的对象，有不同的结果。（传不同的参数，有不同的结果）
#在python中，可以通过函数或者方法来实现
#在java中只能通过方法实现

4.重载

class P:
    #重载：函数名一样，但是函数参数类型或者是个数不一样
    #python 没有重载，因为参数随便传，没有类型限制
    #java有类型限制
    def p(obj):
        pass

5.重写

重写是指子类重写父类的成员方法。子类可以改变父类方法所实现的功能，但子类中重写的方法必须与父类中对应的方法具有相同的方法名。也就是说要实现重写，就必须存在继承。

6.类的特殊成员

1. __doc__：表示类的描述信息

2. __module__ 和 __class__：module__ 表示当前操作的对象在那个模块 ；class__    表示当前操作的对象的类是什么

3.__del__：析构方法，当对象在内存中被释放时，自动触发执行。

4.__call__：对象后面加括号，触发执行

5.__dict__：类或对象中的所有成员

6.__str__：如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

7. __getitem__、__setitem__、__delitem__：用于索引操作，如字典。以上分别表示获取、设置、删除数据

8.__iter__：用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

9.__slot__：限制实例可以使用的属性名称

10. __new__：特性： __new__() 方法是在类准备将自身实例化时调用。 __new__() 方法始终都是类的静态方法，即使没有被加上静态方法装饰器。

7.单例

#设计模式：用类的方法来实现一些数据、实例的管理
#单例：实例化多次，但是只有一个实例产生
#方法1,实现__new__方法
#并将一个类的实例绑定到类变量_instance上,
#如果cls._instance不存在，则说明该类还没有实例化过,实例化该类,并返回
#如果cls._instance不为None,直接返回cls._instance
# super(Singleton, cls)表示获取Singleton父类对象，super也是个类，返回一个super对象（即父类对象），cls是Myclass类对象
class Singleton(object):
    _instance=None
    def __init__(self):
        print("__init__被调用")

    def __new__(cls, *args, **kw):
        print("__new__方法被调用了")
        if cls._instance is None:
            # orig = super(Singleton, cls)
            cls._instance = object.__new__(cls)
        return cls._instance

class MyClass(Singleton):
    a = 1
one = MyClass()
print(id(one))
two = MyClass()
print(id(two))
two.a = 3
print (one.a)
print(two.a)
# #one和two完全相同,可以用id(), ==, is检测
# print (id(one))
# #29097904
# print (id(two))
# #29097904
# print (one == two)
# #True
# print (one is two)
# #True

8.闭包：一个函数，返回来一个函数+函数使用的外部变量

# def add(a,b):return  a+b
#
# def p():
#     return add #返回函数对象
#
# print(p()(1,2))
# 闭包：一个函数p，在p函数内部return了一个函数x+函数使用的外部变量

def p():
    a=1
    def x():
        print(a)
    return x
p()()  #可以执行成功，打印出1