python 全栈开发,Day23(复习,isinstance和issubclass,反射)

时间:2023-08-15 21:08:56

一、复习

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>

python 全栈开发,Day23(复习,isinstance和issubclass,反射)

将点改成逗号,将右边的属性名/方法名,换成字符串,比如'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的例子:

python 全栈开发,Day23(复习,isinstance和issubclass,反射)

qq客户端登录的时候,输入用户名和密码,将数据通过网络传输给腾讯服务器

数据经过编码的,二进制数据。腾讯服务器接收到数据之后,解码得到字符串

通过判断方法,来执行相应动作。

假设有500种功能呢?写500层if判断?太low了

有没有更好的办法呢?用反射python 全栈开发,Day23(复习,isinstance和issubclass,反射)

在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方法
方法可以绑定给类
但是不能绑定给对象

python 全栈开发,Day23(复习,isinstance和issubclass,反射)

重点记住:

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不能一样

python 全栈开发,Day23(复习,isinstance和issubclass,反射)

一个对象,能不能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)()