isinstance type issubclass 区分方法和函数 反射:hasattr getattr setattr delattr
isinstance type issubclass
isinstance: 判断你给对象是否是xx类型的. (向上判断)
type: 返回xxx对象的数据类型
issubclass: 判断xxx类是否xxx的子类
class Animal:
def eat(self):
print("刚睡醒吃点儿东西")
class Cat(Animal):
def play(self):
print("猫喜欢玩儿")
c = Cat()
print(isinstance(c, Cat)) # c是一只猫 这里判断c是不是Cat类里面的
print(isinstance(c, Animal)) # 向上判断 这里判断c是不是Animal类里面的
a = Animal()
print(isinstance(a, Cat)) # 不能向下判断
print(type(a)) # 返回 a的数据类型
print(type([]))
print(type(c)) # 精准的告诉你这个对象的数据类型
# 判断.xx类是否是xxxx类的子类
print(issubclass(Cat, Animal))
print(issubclass(Animal, Cat))
# 应用
def cul(a, b): # 此函数用来计算数字a和数字b的相加的结果
# 判断传递进来的对象必须是数字. int float
if (type(a) == int or type(a) == float) and (type(b) == int or type(b) == float):
return a + b
else:
print("对不起. 您提供的数据无法进行计算")
print(cul(a, c))
如何区分方法和函数(代码)
在类中:
实例方法
如果是类名.方法 函数
如果是对象.方法 方法
类方法: 都是方法
静态方法: 都是函数
from types import MethodType, FunctionType
isinstance()
def func(): print("我是函数") class Foo: def chi(self): print("我是吃") # print(func) # <function func at 0x0000000001D42E18> f = Foo() # f.chi() print(f.chi) # <bound method Foo.chi of <__main__.Foo object at 0x0000000002894A90>>
# 野路子:
这里打印了方法或者函数的名字
打印的结果中包含了function. 函数
# method . 方法
我们的类也是对象.
这个对象: 属性就是类变量
方法就是类方法
class Person: def chi(self): print("我要吃鱼") @classmethod def he(cls): print("我是类方法") @staticmethod def pi(): print("泥溪镇地皮") p = Person() Person.chi(1) # 不符合面向对象的思维
#这里直接使用类名.方法 其实是没有经过对象的,所以不符合面向对象的思维,虽然这里可以使用,但是千万不要用
print(p.chi) # <bound method Person.chi of <__main__.Person object at 0x00000000028C4B70>> print(Person.chi) # <function Person.chi at 0x00000000028989D8> 实例方法: 1. 如果使用 对象.实例方法 方法 2. 如果使用 类.实例方法 函数 print(Person.he) # <bound method Person.he of <class '__main__.Person'>> print(p.he) # <bound method Person.he of <class '__main__.Person'>> 类方法都是 方法 print(Person.pi) # <function Person.pi at 0x0000000009E7F488> print(p.pi) # <function Person.pi at 0x0000000009E7F488> 静态方法都是函数 # 记下来 from types import FunctionType, MethodType # 方法和函数 导入的是函数 和方法模块 from collections import Iterable, Iterator #可迭代的 迭代器 实例:
class Person: def chi(self): # 实例方法 print("我要吃鱼") @classmethod def he(cls): print("我是类方法") @staticmethod def pi(): print("泥溪镇地皮") p = Person() print(isinstance(Person.chi, FunctionType)) # True print(isinstance(p.chi, MethodType)) # True print(isinstance(p.he, MethodType)) # True print(isinstance(Person.he, MethodType)) # True print(isinstance(p.pi, FunctionType)) # True print(isinstance(Person.pi, FunctionType)) # True
在这里,就可以得出结论:
在类中:
实例方法 如果是类名.方法 函数
如果是对象.方法 方法
类方法: 都是方法
静态方法: 都是函数
from types import MethodType, FunctionType
isinstance()
___________________________________________________________________________
反射.
首先, 我们看这样⼀个需求, 说, 有个大牛, 写了⼀堆特别牛B的代码. 然后放在了⼀个py ⽂件里(模块), 这时, 你想⽤这个大⽜写的东西. 但是呢. 你⾸先得知道⼤牛写的这些代码都是 干什么用的. 那就需要你把⼤牛写的每一个函数跑一下. 摘一摘⾃己想用的内容. 来咱们模拟 这样的需求, 首先, ⼤牛给出⼀个模块.
import master # 报错不用管 这里导入模块
print("""
1. chi: 大牛特别能吃
2. he: 大牛特别能喝
3. shui: 大牛特别能睡
4. play: 大牛特别能玩儿
5. sa: 大牛很喜欢撒谎
""")
while 1:
content = input("请输入你要执行的函数:")
if content == "1":
master.chi()
elif content == "2":
master.he()
elif content =="3":
master.shui()
elif content == "4":
master.play_1()
elif content == "5":
master.sa()
写是写完了. 但是.....如果⼤牛现在写了100个功能呢? 你的判断要100次么? 太累 了吧. 现有的知识解决不了这个问题. 那怎么办呢? 注意看. 我们可以使⽤反射来完成这样的功能. 非常的简单. 想想. 这里我们是不是让用户输入要执行的功能了. 那这个功能就是对应 模块里的功能. 那也就是说. 如果能通过字符串来动态访问模块中的功能就能解决这个问题. 好了. 我要告诉你. 反射解决的就是这个问题. 为什什么叫反射? 反着来啊. 正常是我们先引入 模块, 然后⽤模块去访问模块里的内容. 现在反了. 我们⼿动输入要运行的功能. 反着去模块 里找. 这个就叫反射
import master #导入模块
while 1:
content = input("请输入你要测试的功能:") # 用户输入的功能是一个字符串
# 判断 xxx对象中是否包含了xxxxx
if hasattr(master, content):
xx = getattr(master, content)
xx()
print("有这个功能")
else:
print('没有这个功能')
关于反射, 其实⼀一共有4个函数:
1. hasattr(obj, str) 判断obj中是否包含str成员
2. getattr(obj,str) 从obj中获取str成员
3. setattr(obj, str, value) 把obj中的str成员设置成value. 注意. 这里的value可以是 值, 也可以是函数或者⽅法
4. delattr(obj, str) 把obj中的str成员删除掉
注意, 以上操作都是在内存中进行的. 并不会影响你的源代码
# 对于模块而言可以使用getattr, hasattr, 同样对于我们的对象也可以执行类似的操作 class Person: def __init__(self, name, laopo): self.name = name self.laopo = laopo p = Person("宝宝", "林志玲") print(hasattr(p, "laopo")) # print(getattr(p, "laopo")) # p.laopo setattr(p, "laopo", "胡一菲") # p.laopo = 胡一菲 setattr(p, "money", 100000000000) # p.money = 100000000 print(p.laopo) print(p.money) delattr(p, "laopo") # 把对象中的xxx属性移除. != p.laopo = None print(p.laopo)#####会报错
______________________
True
林志玲
胡一菲
100000000000
最后移除了laopo这个属性,所以会报错
关于反射, 其实一共有4个函数:
1. hasattr(obj, str) 判断obj中是否包含str成员
2. getattr(obj,str) 从obj中获取str成员
3. setattr(obj, str, value) 把obj中的str成员(属性,方法)设置成value. 注意. 这⾥里里的value可以是 值, 也可以是函数或者⽅方法
4. delattr(obj, str) 把obj中的str成员删除掉
注意, 以上操作都是在内存中进行的. 并不会影响你的源代
