面对对象二,super......反射
一.super()
super() : 主动调用其他类的成员
# 单继承 # 在单继承中 super，主要是用来调用父类的方法的。 class A: def __init__(self): self.n = 2 def add(self, m): print('self is {0} @A.add'.format(self)) self.n += m class B(A): def __init__(self): self.n = 3 def add(self, m): print('self is {0} @B.add'.format(self)) super().add(m) self.n += 3 # 执行下面代码后， b.n 的值是多少呢？ b = B() b.add(2) print(b.n) # 执行结果如下: # self is <__main__.B object at 0x106c49b38> @B.add # self is <__main__.B object at 0x106c49b38> @A.add # 8 """这个结果说明了两个问题: super().add(m) 确实调用了父类 A 的 add 方法。 super().add(m) 调用父类方法 def add(self, m) 时, 此时父类中 self 并不是父类的实例而是子类的实例, 所以b.add(2) 之后的结果是 5 而不是 4 。 不知道这个结果是否和你想到一样呢？下面我们来看一个多继承的例子。""" # 多继承 # 这次我们再定义一个 class C，一个 class D: class C(A): def __init__(self): self.n = 4 def add(self, m): print('self is {0} @C.add'.format(self)) super().add(m) self.n += 4 class D(B, C): def __init__(self): self.n = 5 def add(self, m): print('self is {0} @D.add'.format(self)) super().add(m) self.n += 5 # 下面的代码又输出啥呢？ d = D() d.add(2) print(d.n) # 这次的输出如下: # self is <__main__.D object at 0x10ce10e48> @D.add # self is <__main__.D object at 0x10ce10e48> @B.add # self is <__main__.D object at 0x10ce10e48> @C.add # self is <__main__.D object at 0x10ce10e48> @A.add # 19
在大多数情况下， super 包含了两个非常重要的信息: 一个 MRO 以及 MRO 中的一个类。当以如下方式调用 super 时:
super(a_type, obj)
MRO 指的是 type(obj) 的 MRO, MRO 中的那个类就是 a_type , 同时 isinstance(obj, a_type) == True 。
当这样调用时:
super(type1, type2)
MRO 指的是 type2 的 MRO, MRO 中的那个类就是 type1 ，同时 issubclass(type2, type1) == True 。
那么， super() 实际上做了啥呢？简单来说就是：提供一个 MRO 以及一个 MRO 中的类 C ， super() 将返回一个从 MRO 中 C 之后的类中查找方法的对象。
也就是说，查找方式时不是像常规方法一样从所有的 MRO 类中查找，而是从 MRO 的 tail 中查找。
举个栗子, 有个 MRO:
[A, B, C, D, E, object]
下面的调用:
super(C, A).foo()
super 只会从 C 之后查找，即: 只会在 D 或 E 或 object 中查找 foo 方法。
supper多继承图解:
二,特殊成员
相应语法对应
# __doc__ 输出类的描述(注释)信息 # __module__ 表示当前操作的对象在那个模块 # __class__ 表示当前操作的对象的类是什么 class C: def __init__(self): self.name = 'zwq' from lib.aa import C obj = C() print obj.__module__ # 输出 lib.aa，即：输出模块 print obj.__class__ # 输出 lib.aa.C，即：输出类 # __init__ 构造方法，通过类创建对象时，自动触发执行。 # __del__ 析构方法，当对象在内存中被释放时，自动触发执行。一般无须定义,由解释器在进行垃圾回收时自动触发执行的 # __call__ 将对象变为可调用对象； 对象后面加括号，触发执行。 # __dict__ 类或对象中的所有成员 # __str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。 # __getitem__、__setitem__、__delitem__ # 用于索引操作，如字典。以上分别表示获取、设置、删除# 数据 # __getslice__、__setslice__、__delslice__ 该三个方法用于分片操作 # __iter__ 用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__ # __new__ 和 __metaclass__ # __enter__ ,__exit__ with 对象 自动执行__enter__ / __exit__
class Foo(object): def __init__(self,a1,a2): self.a1 = a1 self.a2 = a2 def __call__(self, *args, **kwargs): print(11111,args,kwargs) return 123 def __getitem__(self, item): print(item) return 8 def __setitem__(self, key, value): print(key,value,111111111) def __delitem__(self, key): print(key) def __add__(self, other): return self.a1 + other.a2 def __enter__(self): print('1111') return 999 def __exit__(self, exc_type, exc_val, exc_tb): print('22222') # 1. 类名() 自动执行 __init__ # obj = Foo(1,2) # 2. 对象() 自动执行 __call__ # ret = obj(6,4,2,k1=456) # 3. 对象['xx'] 自动执行 __getitem__ # ret = obj['yu'] # print(ret) # 4. 对象['xx'] = 11 自动执行 __setitem__ # obj['k1'] = 123 # 5. del 对象[xx] 自动执行 __delitem__ # del obj['uuu'] # 6. 对象+对象 自动执行 __add__ # obj1 = Foo(1,2) # obj2 = Foo(88,99) # ret = obj2 + obj1 # print(ret) # 7. with 对象 自动执行 __enter__ / __exit__ # obj = Foo(1,2) # with obj as f: # print(f) # print('内部代码')
三,构造方法
class Foo(object): def __init__(self, a1, a2): # 初始化方法 """ 为空对象进行数据初始化 :param a1: :param a2: """ self.a1 = a1 self.a2 = a2 def __new__(cls, *args, **kwargs): # 构造方法 """ 创建一个空对象 :param args: :param kwargs: :return: """ return object.__new__(cls) # Python内部创建一个当前类的对象(初创时内部是空的.). obj1 = Foo(1,2) print(obj1) obj2 = Foo(11,12) print(obj2)
四,isinstance(obj,cls), issubclass(sub,super)和type;
isinstance(obj,cls)
检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
class Base(object): pass class Foo(Base): pass obj1 = Foo() print(isinstance(obj1,Foo)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。 print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
issubclass(sub,super)
检查sub类是否是 super 类的派生类
issubclass class Base(object): pass class Foo(Base): pass class Bar(Foo): pass print(issubclass(Bar,Base)) # 检查第一个参数是否是第二个参数的 子子孙孙类
type:
#type:获取当前对象是由那个类创建。 """ class Foo(object): pass obj = Foo() print(obj,type(obj)) # 获取当前对象是由那个类创建。 if type(obj) == Foo: print('obj是Foo类型') """
五,反射
1 什么是反射
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念
的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
四个可以实现反射(自省)的函数
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）
#记忆： getattr # 根据字符串的形式，去对象中找成员,返回这个成员的值。 ### v = getattr(obj,"func") # 根据字符串为参数（第二个参数），去对象（第一个参数）中寻找与之同名的成员。 hasattr(obj,"func") # 根据字符串的形式，去判断对象中是否有该成员。 setattr(obj,"name","ZWQ") # 根据字符串的形式，动态的设置一个成员（内存） delattr(类，"func") # 根据字符串的形式，动态的删除一个成员（内存）
from types import FunctionType import handler while True: print(""" 系统支持的函数有： 1. f1 2. f2 3. f3 4. f4 5. f5 """) val = input("请输入要执行的函数：") # val = "f1" # 错误 # handler.val() if hasattr(handler,val): func_or_val = getattr(handler,val) # 根据字符串为参数，去模块中寻找与之同名的成员。 if isinstance(func_or_val,FunctionType): func_or_val() else: print(func_or_val) else: print('handler中不存在输入的属性名')
class Foo(object): country = "中国" def func(self): pass v = getattr(Foo,'func') # Foo.func # 根据字符串为参数，去类中寻找与之同名的成员。 print(v) obj = Foo() v = getattr(obj,"func") # obj.func # 根据字符串为参数，去对象中寻找与之同名的成员。 print(v)
class Account(object): func_list = ['login', 'logout', 'register'] def login(self): """ 登录 :return: """ print('登录111') def logout(self): """ 注销 :return: """ print('注销111') def register(self): """ 注册 :return: """ print('注册111') def run(self): """ 主代码 :return: """ print(""" 请输入要执行的功能： 1. 登录 2. 注销 3. 注册 """) choice = int(input('请输入要执行的序号:')) func_name = Account.func_list[choice-1] # func = getattr(Account,func_name) # Account.login # func(self) # 执行这个函数要传参数,传self func = getattr(self, func_name) # self相当于对象可以直接传self相当于self.login func() obj1 = Account() obj1.run() obj2 = Account() obj2.run()
六,callable(x) 检查x是否是可调用的
def func(): pass class Foo(object): def __call__(self, *args, **kwargs): pass def func(self): pass obj = Foo() print(callable(func)) #True print(callable(Foo)) #True print(callable(obj)) #True print(callable(obj.func)) #True
