反射
反射用到的mmp模块
def wahaha():print('wahaha')
class QQxing:
def __init__(self,name):
self.name = name
def ADCa(self):
print('in ADCa',self.name)
# a
# b
# wahaha
# QQxing
# getattr('a')
import sys
print(sys.modules)
print(sys.modules[__name__])
print(getattr(sys.modules[__name__],'a'))
print(getattr(sys.modules[__name__],'b'))
getattr(sys.modules[__name__],'wahaha')()name1='aaa'
name2='bbb'
name3='ccc'
inp=input('>>>')
print(inp)
class A:
Name1 = 'aaa'
Name2 = 'bbb'
Name3 = 'ccc' def __init__(self,name):
self.name=name
def func(self):
print('in func',self.name)
图示帮助理解
a1=A('ddd')#实例化了一个ddd
a1.func()#调用了func函数 in func ddd
print(a1.name)#打印函数中名字 ddd
getattr(a1,'func')#'func'是字符串类型的变量名
getattr(a1,'func')() #in func ddd 加上括号执行函数
print(getattr(a1,'func'))#打印的是地址
print(getattr(a1,'name'))#打印实例化后，a1对应的名字
if hasattr(A,'Name1'):
print(getattr(A,'Name1'))#和hasattr搭配使用 #Name1
print(getattr(A,'Name2')) #Name2
print(getattr(A,'Name3')) #Name3
while True:
inp=input('>>>')
if hasattr(A,inp):
print(inp)使用字符串数据类型的变量名来操作一个变量的值
使用反射获取某个命名空间的值
需要
有一个变量指向这个命名空间的字符串数据类型的名字，
再使用getattr获取值
如果是变量，能直接获得结果
如果是函数，只能拿到内存地址，加上括号就是执行
使用类名反射：静态属性，类方法，静态方法
使用对象名反射：对象属性，类中的普通方法
使用模块名反射：变量，函数，类
在自己所在的文件夹中反射全局变量：getattr(sys.modules[__name__],'要反射的名字')
import mmp
print(mmp.a)#直接使用模块，调用模块中的变量
print(getattr(mmp,'a'))#使用反射，调用模块中的变量a
mmp.wahaha()#直接使用模块调用模块中的函数
getattr(mmp,'wahaha')()#使用反射调用模块中的函数 print(mmp.QQxing)#直接使用模块，获取类的内存地址
taibai=mmp.QQxing('太亮')#实例化模块中的类
taibai.ADCa()#实例调用方法
cls=getattr(mmp,'QQxing')#使用反射得到模块中类
ret=cls('光头')#将得到的类实例化
print(ret)#<mmp.QQxing object at 0x0000021FA2805D30>
getattr(ret,'ADCa')()#in ADCa 光头 使用反射调用类中的方法
hasattr ******
getattr ******
setattr ***
delattr *
import mmp
class A:
Name1='alex'
Name2='taibai'
Name3='egon'
def __init__(self,name):
self.name=name
def func(self):
print('in func,self.name')
A.Country='中国'#增
A.Name1='alex_NB'#改
print(A.__dict__)#查看类下的内容
setattr(A,'Country','印度')#将中国改为印度
print(A.__dict__)#查看类下的内容 setattr(A,'Role','Person')#增加一个静态属性 'Role'='Person'
print(A.__dict__)#查看类下的内容
delattr(A,'Name1')#删除Name1='alex'的静态变量
print(A.__dict__)#查看类下的内容
内置方法
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
issubclass(sub, super)检查sub类是否是 super 类的派生类
a=10
print(isinstance(a,int))#True class F:pass
class Foo(F):pass
obj=Foo()
print(isinstance(obj,Foo))#True
print(type(obj)is Foo)#True
print(isinstance(obj,F))#True
print(type(obj)is F)#False class F:pass
class Foo(F):pass
print(issubclass(Foo,F))#True
print(issubclass(F,Foo))#False
类的内置方法 双下方法 魔术方法
对象加上(),可以调用这个类的__call__方法。
class Foo:
def __call__(self):
print('call')
Foo()()#call
obj=Foo()
obj()#相当于调用__call__call
内置函数的len函数是依赖类中的__len__
class Classes:
def __init__(self,student_lst):
self.student_lst=student_lst
def __len__(self):return len(self.student_lst) clas=Classes(['张三','李四','王五'])
print(len(clas.student_lst))#不依赖__len__
print(len(clas))#依赖__len__ class Wahaha:
def __init__(self,num,name,age):
self.num=num
self.name=name
self.age=age
def __len__(self):
return len(self.__dict__)#返回类中属性的个数
obj=Wahaha(6,'alex',8)
print(len(obj.__dict__))#
print(len(obj))#3 依赖__len__
__eq__ 判断值是否相等的时候依赖__eq__的结果
class QQxing:pass
# def __eq__(self,other):本题中没有用到函数的内容(__eq__ 方法)
# if type(self)==type(other) and self.__dict__==other.__dict__:
# return True
# else:
# return False
q1=QQxing()
q1.name='alex'
q2=QQxing()
q2.name='egon'
print(q1,q2)#两个内存地址不同
print(q1==q2)# 两个自定义对象之间是否值相等，会根据内存地址去判断
面试题 判断值是否相等的时候依赖__eq__的结果，==就是在内部调用了__eq__方法
两个对象的名字和性别相同，那么这两个对象就是同一个人
class Person:
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def __eq__(self,other):
if type(self)==type(other) and self.name==other.name and self.sex==other.sex :
return True
else:return False
p1=Person('松松','男',23)
p2=Person('松松','男',24)
p3=Person('小灰灰','男',23)
print(p1==p2)#True
print(p1==p3)#False
print(p2==p3)#False hash() 在内存的优化上起到了作用
dict,set
两个对象的名字和性别相同，那么这两个对象就是同一个人,对10个对象进行去重
class Person_lst:
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def __hash__(self):
return hash(self.name+self.sex)
def __eq__(self,other):
if type(self)==type(other) and self.name==other.name and self.sex==other.sex :
return True
else:return False
l1=[('松松','男',23),('松松','男',24),('松松','女',23),('灰灰','男',23),('灰灰','男',24),\
('灰灰','女',23),('张三','男',23),('李四','男',23),('王五','男',23),('李六','男',23),]
# p1=Person_lst(l1)
p1=[Person_lst(i[0],i[1],i[2],) for i in l1]
p2=list(set(p1))
print(p2)
for i in p2:
# print(i.__dict__)#以字典的形式打印出来，因为类的空间里就是以这种方式储存的。
print(list(i.__dict__.values()))#将p2（类）空间中的内容打印出来。 class Person_lst:#巧用内置方法
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def __hash__(self):
return hash(self.name+self.sex)
def __eq__(self,other):
if type(self)==type(other) and self.name==other.name and self.sex==other.sex :
return True
else:return False
def __str__(self): # 必须返回一个str数据类型
return ','.join([self.name,self.sex,str(self.age)])
l1=[('松松','男',23),('松松','男',24),('松松','女',23),('灰灰','男',23),('灰灰','男',24),\
('灰灰','女',23),('张三','男',23),('李四','男',23),('王五','男',23),('李六','男',23),]
# p1=Person_lst(l1)#不能直接传列表，__init__方法的三个参数传不进去
p1=[Person_lst(i[0],i[1],i[2],) for i in l1]#一次性实例化10个对象
p2=list(set(p1))#利用集合去重
# print(p2)#打印的是地址
for i in p2 :#将筛选过的打印出来
print(i)
print(hash(p1[0]))#
print(hash(p1[1]))#
print(hash(p1[2]))#
print(hash(p1[3]))#-5720704507138757199
print(hash(p1[4]))#-5720704507138757199
print(hash(p2[4]))#-8555849577569044973
print(hash(p2[5]))#
print(hash(p2[7]))#
p1第一个和第二个，第四个和第五个判定为同一个人，所以hash值相等
p2中已经去重了，所以每个人的hash值不相等
hash(obj1)==hash(obj2) and obj1.__eq__(obj2):是重复的
obj1.__hash__()==obj2.__hash__() and obj1.__eq__(obj2):是重复的
py 2.7
class Person:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
person_lst=[Person('egon',i,'male') for i in range(100)]
for i in set(person_lst):
print(list(i.__dict__.values()))
__str__ __repr__
l=[1,2,3]#实际是列表的实例化
a='cba'
# 语法糖
print(a)
print(1)
class QQxing:pass
q1=QQxing()
print(q1)#内存地址
class Course:
def __init__(self,name,price,period):
self.name=name
self.price=price
self.period=period
def __str__(self):
return '*'.join([self.name,str(self.price),self.period])#列表转字符串，用join
python=Course('python',19800,'6month')
linux=Course('linux',17800,'6month')
for i in [python,linux]:
print(i)#python*19800*6month linux*17800*6month
print(python)#没有__str__方法，打印出来的是内存地址
print('course:%s' % python)#course:python*19800*6month
print('a:',str(python))#a: python*19800*6month
__str__方法和str(),print() %s 都是息息相关的
class Student:
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
def __repr__(self):
return self.name
stu1=Student('光头','男',25)
print('学生姓名:%r' % stu1)#学生姓名:光头
print(repr(stu1))#光头
__repr__方法 和repr() %r 都是息息相关的
class Student:
def __init__(self,name,sex,age):
self.name=name
self.sex=sex
self.age=age
# def __str__(self):
# return '&'.join([self.name,self.sex,str(self.age)])
# def __repr__(self):
# return self.name
def __repr__(self):
return '：'.join([self.name,self.sex,str(self.age)])
stu1=Student('光头','男',25)
print('%s' % stu1)#光头：男：25
print('学生:%r' % stu1)#学生:光头：男：25
print(str(stu1))#光头：男：25
print(repr(stu1))#光头：男：25
在没有实现__str__方法的情况下，__repr__能够完全代替__str__的功能
但是__str__不能代替__repr__的工作
在__repr__和__str__都存在的情况下：
__repr__方法 和repr() %r 都是息息相关的
__str__方法和str() % r都是息息相关的
*coding:utf_8*
format_dict={
'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
'tna':'{obj.type}:{obj.name}:{obj.addr}',
'tan':'{obj.type}*{obj.addr}*{obj.name}',
}
class School:
def __init__(self,name,addr,type):
self.name=name
self.addr=addr
self.type=type
def __format__(self,format_spec):#format_spec='nat'
if not format_spec or format_spec not in format_dict:
format_spec='nat'
fmt=format_dict[format_spec]#fmt='{obj.name}-{obj.addr}-{obj.type}'
return fmt.format(obj=self)#'{obj.name}-{obj.addr}-{obj.type}'.format(obj=self) 格式化输出
s1=School('清华','北京','公立')
print(format(s1,'nat'))#清华-北京-公立
print(format(s1,'tna'))#公立*清华1:北京
print(format(s1,'tan'))#公立*北京*清华1
print(format(s1,'iwejkwocoi'))#清华1-北京-公立class A:pass
o=A()
o.name='a'
o.addr='b'
o.type='c'
print('{obj.name}-{obj.addr}-{obj.type}'.format(obj=o))#格式化输出
总结：
反射 —— 明显的简化代码
能拿到的变量名本来就是一个字符串的时候
用户输入的、文件读入的、网络上传输
hasattr 判断某个变量在不在命名空间中
getattr 获取某个名空间中的变量
setattr 给空间中的某个变量赋值、或者创建变量
delattr 从空间中删除某个变量
***所有的变量都是字符串数据类型的变量名
内置方法
内置方法，内置函数，内置的模块
你自定义的类或者对象
能否利用一些内置函数，内置模块实现功能
你的内置方法是否实现了响应的功能
hash()函数就依赖__hash__方法
len()函数就依赖__len__方法
==函数就依赖__eq__方法
format函数就依赖__format__方法
str，print，%s函数就依赖__str__方法
repr，%r函数就依赖__repr__方法
* 在没有str的时候所有的引用__str__方法的
地方都可以自动引用__repr__方法
set 依赖 __hash__和__eq__方法来完成去重
123