一、复习
class A: def func1(self):pass def func2(self): pass def func3(self): pass a = A() b = A() print(A.func1) print(a.func1) print(b.func1)
执行输出:
<function A.func1 at 0x00000286A24EAA60>
<bound method A.func1 of <__main__.A object at 0x00000286A2381048>>
<bound method A.func1 of <__main__.A object at 0x00000286A2381358>>
bound 表示绑定的意思。当类A实例化时,会将里面的方法与做类做绑定。
class A: def func1(self):pass # 对象与方法之间的绑定 @classmethod def func2(self): pass # 类与方法之间的绑定 @classmethod def func3(self): pass a = A() b = A() #普通方法 对象和类绑定的过程 print(A.func2) print(a.func2) # 对象能找到类 类里面绑着方法 print(b.func2)
执行输出:
<bound method A.func2 of <class '__main__.A'>>
<bound method A.func2 of <class '__main__.A'>>
<bound method A.func2 of <class '__main__.A'>>
类方法 由于不适用对象内存空间中的属性,所以不会将对象和方法绑在一起
而是将类和方法绑在一起
class A: def func1(self):pass # 对象与方法之间的绑定 @classmethod def func2(self): pass # 类与方法之间的绑定 @staticmethod def func3(self): pass # 静态方法 a = A() b = A() print(A.func3) print(a.func3) print(b.func3)
执行输出:
<function A.func3 at 0x0000027EB99EA9D8>
<function A.func3 at 0x0000027EB99EA9D8>
<function A.func3 at 0x0000027EB99EA9D8>
静态方法 不是绑定方法 没有和对象或者类发生任何绑定关系
python处处皆对象
'a' 是str的对象
[1,2,3] 是list的对象
派生
class Foo: def __init__(self,name): self.name = name self.age = 18 class Son(Foo):pass son = Son('egon') print(son.__dict__)
执行输出:
{'name': 'egon', 'age': 18}
这里面没有派生属性(子类有,父类没有的属性)
增加一个派生属性
class Foo: def __init__(self,name): self.name = name self.age = 18 class Son(Foo):pass son = Son('egon') son.money = 500 # 在类外部添加一个属性 print(son.__dict__)
执行输出:
{'money': 500, 'name': 'egon', 'age': 18}
第二种方式,添加派生属性
class Foo: def __init__(self,name): self.name = name self.age = 18 class Son(Foo): def __init__(self,name,money): Foo.__init__(self,name) self.money = money # 初始化添加属性 son = Son('egon',500) print(son.__dict__)
执行输出:
{'age': 18, 'money': 500, 'name': 'egon'}
age重新赋值
class Foo: def __init__(self,name): self.name = name self.age = 18 class Son(Foo): def __init__(self,name,money): Foo.__init__(self,name) self.age = 20 # 重新赋值 self.money = money # 初始化添加属性 son = Son('egon',500) print(son.__dict__)
执行输出:
{'name': 'egon', 'money': 500, 'age': 20}
在抽象类里面,当一个类指定ABCMeta,就不能实例化了
面向对象总结,请参考图
https://www.processon.com/view/link/5ad6a594e4b0f5fa24e09235
二、isinstance和issubclass
isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
a = 2 print(isinstance (a,int)) # 判断是否为整形
执行输出: True
判断继承关系
class A:pass class B:pass class A(B):pass a = A() print(isinstance(a,A)) print(isinstance(a,B)) # 能够检测到继承关系 print(type(a) is A) print(type(a) is B) # type 只单纯的判断类型
执行输出:
True
True
True
False
isinstance判断一个对象和一个类有没有血缘关系
issubclass(sub, super)检查sub类是否是 super 类的派生类
issubclass 检测子类,父类关系
class C:pass class D(C):pass print(issubclass(C,D)) print(issubclass(D,C))
执行输出:
False
True
issubclass(子类名,父类名) 如果返回True,说明有继承关系
多继承
class B:pass class C(B):pass class D(C):pass print(issubclass(C,D)) print(issubclass(D,C)) print(issubclass(B,C)) print(issubclass(C,B)) print(issubclass(D,B))
执行输出:
False
True
False
True
True
这2个方法,不常用
三、反射
反射非常重要,如果一个知识点,重要程度是5颗星的话,那么反射是6星重点掌握!!!!
1. 什么是反射
反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
2. python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)
反射就是通过字符串的形式,导入模块;通过字符串的形式,去模块寻找指定函数,并执行。利用字符串的形式去对象(模块)中操作(查找/获取/删除/添加)成员,一种基于字符串的事件驱动!
先来介绍四个内置函数:
✴✴✴✴✴✴hasattr 判断值是否存在
✴✴✴✴✴✴getattr 获取值
setattr 修改和新建
delattr 删除一个属性
参数形式:
hasattr(obj, attr):
这个方法用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。
getattr(obj, attr):
调用这个方法将返回obj中名为attr值的属性的值,例如如果attr为'bar',则返回obj.bar。
setattr(obj, attr, val):
调用这个方法将给obj的名为attr的值的属性赋值为val。例如如果attr为'bar',则相当于obj.bar = val
delattr(obj, name)
参数是由一个对象和一个字符串组成的。string参数必须是对象属性名之一。该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar
先来讲eval
role = 123 print(eval('role'))
执行输出: 123
class A: role = 'Person' print(A.__dict__['role'])
执行输出:
Person
根据输入内容,测试获取的类的属性
class A: role = 'Person' ret = input('>>>') print(A.__dict__[ret])
执行输出:
>>>role
Person
那么问题来,如果获取一个函数呢?
def func():pass ret = input('>>>') eval(ret)
如果植入一段代码,删除根目录,那么linux系统就完了。。。
import os;os.remove('/')
所以eval不能随便用,这样写没有安全意识
input的内容,没法估量,有可能是病毒或者恶意代码
hasattr和getattr的组合使用
class A: role = 'Person' if hasattr(A,'role'): # 判断role属性在A中是否存在 print(getattr(A,'role')) # 获取role属性的值
执行输出:
Person
getattr 使用字符串数据类型的变量名 访问一个命名空间中的名字
前提是,必须指定类的命名空间
比如A,'role'
如果getattr获取不到值,直接报错,所以一般和hasattr配合使用
类中的方法也是可以的获取的
从A的命名空间里找一个方法 ,找到的是这个方法的内存地址
class A: role = 'Person' def func(self): print('*'*self) if hasattr(A,'func'): # 判断func方法在A中是否存在 print(getattr(A,'func')) # 获取func方法的值
执行输出:
<function A.func at 0x000001E95F8FAA60>
class A: role = 'Person' def func(self): print('*'*self) if hasattr(A,'func'): # 判断func方法在A中是否存在 print(getattr(A,'func')) # 获取func方法的值 #下面三行代码,效果一样 f = getattr(A,'func');f(1) getattr(A,'func')(1) #上面2行,是用的字符串方法 A.func(1)
执行输出:
<function A.func at 0x00000217CBC0AA60>
*
*
*
反射
正常情况下如果可以拿到这个变量 那么如有有这个变量的字符串形式 就是用反射可以获取到这个值
使用字符串数据类型的变量名 访问一个命名空间中的名字
找一个属性 ,直接就可以找到这个属性的值
找一个方法 ,找到的是这个方法的内存地址
hasattr() 判断一个命名空间中有没有这个名字
getattr() 从命名空间中获取这个名字对应的值
类中的反射
类可以获取类中的属性和方法
class A: role = 'Person' def func(self): print('*'*self) ret = input('>>>') if hasattr(A,ret): print(getattr(A,ret))
执行输出:
>>>func
<function A.func at 0x00000206EFDFAA60>
将点改成逗号,将右边的属性名/方法名,换成字符串,比如'role'
整体就是A,'role'
再通过getattr就可以获取了。
class A: role = 'Person' def func(self): print('*'*self) ret = input('>>>') # 假设输入的是func if hasattr(A,ret): func = getattr(A,ret) # 此时func就是A类的func方法 func(1)
执行输出:
>>>func
*
看这一句代码:
func = getattr(A,ret)
等式计算右边的,getattr获取的值为A类func方法的内存地址。那么将值赋予给func之后,
外部的func和类内部的func名字是同名的,此时左边的fun和A类的方法名重名。但是不冲突,为什呢?因为一个在类外部有,一个在类的外表不
加打印
class A: role = 'Person' def func(self): print('*'*self) ret = input('>>>') if hasattr(A,ret): func = getattr(A,ret) print(func) func(1) print(func)
查看内存地址:
>>>func <function A.func at 0x000001E9CF8CAA60> * <function A.func at 0x000001E9CF8CAA60>
内存地址是一样的
小练习,使用反射的知识,用对象调用func
class A: role = 'Person' def func(self): print('*'*10) a = A()
答案:
class A: role = 'Person' def func(self): print('*'*10) a = A() print(a.func) # 获取a对象的func方法的内存地址 if hasattr(a,'func'): getattr(a,'func')() # 执行func方法
执行输出:
<bound method A.func of <__main__.A object at 0x000002A0AD61BB00>>
**********
讲一个QQ的例子:
qq客户端登录的时候,输入用户名和密码,将数据通过网络传输给腾讯服务器
数据经过编码的,二进制数据。腾讯服务器接收到数据之后,解码得到字符串
通过判断方法,来执行相应动作。
假设有500种功能呢?写500层if判断?太low了
有没有更好的办法呢?用反射
在A类里面,定义好所有的方法
用一个if判断,就可以执行对应的方法了。
class A: role = 'Person' def __init__(self): self.money = 500 def func(self): print('*'*10) a = A() print(a.func) if hasattr(a,'func'): getattr(a,'func')() 'money' #使用字符串 if hasattr(a,'money'): print(getattr(a,'money'))
执行输出:
<bound method A.func of <__main__.A object at 0x000001FC2D34FF28>>
**********
500
类使用类命名空间中的名字
对象使用对象能用的方法和属性
模块使用模块中的名字
import os ; getattr(os,'rename')('user','user_info')
从自己所在的模块中使用自己名字
import time # 一个py文件就是一个模块 time.time() if hasattr(time,'time'): print(time.time) print(getattr(time,'time')())
执行输出:
<built-in function time>
1524044098.9708395
新建文件teacher.py 内容如下:
class Teacher: todo_list = [ ] def __init__(self,name): self.name = name
导入模块teacher
import teacher t = 'Teracher' alex = teacher.t('alex').name print(alex)
执行输出:alex
import teacher t = 'Teacher' Terach_class = getattr(teacher,t) print(Terach_class) print(teacher.Teacher)
执行输出:
<class 'teacher.Teacher'>
<class 'teacher.Teacher'>
假设有一个文件名userinfo,需要重命名
第一种:常规办法
import os os.rename('userinfo','user')
第二种:使用反射
import os#os.rename('userinfo','user') getattr(os,'rename')('user','user_info')
a = 1 b = 2 def login(): print('执行login功能') def register(): print('执行register功能') func = input('>>>')
怎么反射自己的模块名?
使用sys模块,和python解释器相关的内容都在sys里
import sys print(sys.modules['__main__']) # 查看当前文件路径,包含文件名
完整代码如下:
def login(): print('执行login功能') def register(): print('执行register功能') import sys #print(sys.modules['__main__']) # 找到自己所在的模块(py文件) func = input('>>>') getattr(sys.modules['__main__'],'login')()
执行输出:
>>>login
执行login功能
总结:
类使用类命名空间中的名字
getattr(类名,'名字')
对象使用对象能用的方法和属性
getattr(对象名,'名字')
模块使用模块中的名字
导入模块
getattr(模块名,'名字')
import os ; getattr(os,'rename')('user','user_info')
从自己所在的模块中使用自己名字
import sys
getattr(sys.modules['__main__'],名字)
getattr一定要和hasattr配合使用
setattr
class A: def __init__(self,name): self.name = name def wahaha(self): print('wahaha') a = A('alex') a.name a.wahaha()
可以给a实例,绑定一个属性age
class A: def __init__(self,name): self.name = name def wahaha(self): print('wahaha') a = A('alex') print(a.__dict__) setattr(a,'age',18) # 给a对象新增一个属性 print(a.__dict__)
执行输出:
{'name': 'alex'}
{'name': 'alex', 'age': 18}
再增加一个属性
class A: def __init__(self,name): self.name = name def wahaha(self): print('wahaha') a = A('alex') print(a.__dict__) setattr(a,'age',18) # 给a增加一个属性 print(a.__dict__) setattr(a,'name','egon') # 修改name属性 print(a.__dict__)
执行输出:
{'name': 'alex'}
{'name': 'alex', 'age': 18}
{'name': 'egon', 'age': 18}
删除一个属性
class A: def __init__(self,name): self.name = name def wahaha(self): print('wahaha') a = A('alex') delattr(a,'name') print(a.__dict__)
执行输出:{}
很少有删除一个方法的
上面都是倒腾属性的,
下面说增删改方法,非常非常不常用
class A: def __init__(self,name): self.name = name def wahaha(self): print('wahaha') def qqxing(self): print('qqxing') a = A('alex') setattr(a,'qqxing',qqxing) # 增加一个属性 print(a.__dict__)a.qqxing
执行输出:
{'name': 'alex', 'qqxing': <function qqxing at 0x00000216743F7F28>}
不能set给对象添加一个方法
否则a.qqxing()就报错
这样才行
class A: def __init__(self,name): self.name = name def wahaha(self): print('wahaha') def qqxing(self): print('qqxing') a = A('alex') setattr(a,'qqxing',qqxing) # 增加一个属性 # print(a.__dict__) a.qqxing(a)
执行输出:qqxing
面试也不会问 set方法
方法可以绑定给类
但是不能绑定给对象
重点记住:
getattr
hasattr
getatter和hasattr一般是成对出现,先判断,使用hasattr,再getatter
实例化一个list
li = list([1,2,3,4,5]) print(li)
li是对象,list是类
查看长度,使用len方法
li = list([1,2,3,4,5]) print(li) print(len(li))
执行输出:
[1, 2, 3, 4, 5]
5
那么类,可以使用len方法吗?
class A: def __init__(self,name,age,sex,cls): self.name = name self.age = age self.sex = sex self.cls = cls a = A('alex',81,'不详',2) print(len(a))
执行输出:
TypeError: object of type 'A' has no len()
那么非要计算长度呢?
有一个内置函数__len__和内置方法len()是唯一对应的关系
当一个对象拥有__len__方法时,就可以使用len()方法时。
class A: def __init__(self,name,age,sex,cls): self.name = name self.age = age self.sex = sex self.cls = cls def __len__(self): # 添加__len__方法 return 5 a = A('alex',81,'不详',2) print(len(a))
执行输出:
5
多实例化几次呢?
class A: def __init__(self,name,age,sex,cls): self.name = name self.age = age self.sex = sex self.cls = cls def __len__(self): # 添加__len__方法 return 5 a1 = A('alex',81,'不详',2) a2 = A('egon',20,'不详',3) a3 = A('yuan',21,'不详',4) print(len(a1)) print(len(a2)) print(len(a3))
执行输出:
5
5
5
现在想要__len__有实际意义
统计属性的个数
class A: def __init__(self,name,age,sex,cls): self.name = name self.age = age self.sex = sex self.cls = cls def __len__(self): # 添加__len__方法 return len(self.__dict__) # 通过__dict__方法,可以查看对象的属性 a1 = A('alex',81,'不详',2) a1.hobby = '烫头' a2 = A('egon',20,'不详',3) a3 = A('yuan',21,'不详',4) print(len(a1)) print(len(a2)) print(len(a3))
执行输出:
5
4
4
内置的东西,都和内置的方法有着千丝万缕的联系
可哈希和不可哈希
字典的寻址速度是最快的
它用的是哈希算法
在一次python程序运行的过程中,对同一个字符串进行运算之后,会得到一个数字
字典的key不能一样
一个对象,能不能hash
靠一个内置方法__hash__决定的
class A: def __init__(self,name,age,sex,cls): self.name = name self.age = age self.sex = sex self.cls = cls a1 = A('alex',81,'不详',2) print(hash(a1))
执行输出:
141908978608
a1这个对象,为什么可以被hash呢?
先看一下object源码,它包含了__hash__方法
def __hash__(self, *args, **kwargs): # real signature unknown """ Return hash(self). """ pass
由于python3所有类都继承了object类,所以a1对象之所以可以hash,是靠object类来完成的。
可以自己定义个__hash__方法
class A: def __init__(self,name,age,sex,cls): self.name = name self.age = age self.sex = sex self.cls = cls def __hash__(self): return 0 a1 = A('alex',81,'不详',2) print(hash(a1))
执行输出: 0
明日默写:
class A: role = 'Person' def __init__(self): self.money = 500 def func(self): print('*'*10) a = A() print(a.func) getattr(a,'func')() print(getattr(a,'money'))
还有一个
def login(): print('执行login功能') def register(): print('执行register功能') import sys # 和python解释器相关的内容都在sys里 print(sys.modules['__main__']) func = input('>>>') if hasattr(sys.modules['__main__'],func): getattr(sys.modules['__main__'],func)()
来源:https://www.cnblogs.com/xiao987334176/p/8875356.html