关键词:
一、isinstance和issubclass
class Foo: pass class Son(Foo): pass s = Son() #判断一个对象是不是这个类的对象,传两个参数(对象,类) # print(isinstance(s,Son)) # print(isinstance(s,Foo)) # print(type(s) is Son) # print(type(s) is Foo) #判断一个类是不是另一类的子类,传两个参数(子类,父类) print(issubclass(Son,Foo)) print(issubclass(Son,object)) print(issubclass(Foo,object)) print(issubclass(int,object))
二、反射
python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)
四个方法:hasattr(),getattr(),setattr(),delattr()
1.对象中
__author__ = ‘ctz‘ class Foo: def __init__(self,name,age): self.name=name self.age=age def fun(self): print("...........ctz") f=Foo("ctz",21) print(hasattr(f,"name")) print(hasattr(f,"age")) print(hasattr(f,"fun")) print(getattr(f,"name")) print(getattr(f,"age")) print(getattr(f,"fun")) fu=getattr(f,"fun") fu() print("".center(50,"-")) setattr(f,"name","egon") setattr(f,"age",73) print(f.name,f.age) print("--------------------") delattr(f,"name") print(f.name)
True True True ctz 21 <bound method Foo.fun of <__main__.Foo object at 0x00000000023F9DD8>> ...........ctz -------------------------------------------------- egon 73 -------------------- Traceback (most recent call last): File "G:/test/week6/day27/反射1 对象.py", line 32, in <module> print(f.name) AttributeError: ‘Foo‘ object has no attribute ‘name‘
2.类中
__author__ = ‘Administrator‘ class Foo: f=123 @staticmethod def static(): print("static......") @classmethod def clas(cls): print(cls.f,"class.............") print(hasattr(Foo,"f")) print(hasattr(Foo,"static")) print(hasattr(Foo,"clas")) if hasattr(Foo,"f"): print(getattr(Foo,"f")) print(getattr(Foo,"static")) print(getattr(Foo,"clas")) s=getattr(Foo,"static") s() c=getattr(Foo,"clas") c()
True True True 123 <function Foo.static at 0x000000000241B9D8> <bound method Foo.clas of <class ‘__main__.Foo‘>> static...... 123 class.............
3.模块
import my_module # print(hasattr(my_module,‘test‘)) # # func_test = getattr(my_module,‘test‘) # # func_test() # getattr(my_module,‘test‘)() #import其他模块应用反射 from my_module import test def demo1(): print(‘demo1‘) import sys print(__name__) #‘__main__‘ print(sys.modules) #‘__main__‘: <module ‘__main__‘ from ‘D:/Python代码文件存放目录/S6/day26/6反射3.py‘> module_obj =sys.modules[__name__] #sys.modules[‘__main__‘] # module_obj : <module ‘__main__‘ from ‘D:/Python代码文件存放目录/S6/day26/6反射3.py‘> print(module_obj) print(hasattr(module_obj,‘demo1‘)) getattr(module_obj,‘demo1‘)() #在本模块中应用反射
__author__ = ‘Administrator‘ import aa print(hasattr(aa,"bb")) g=getattr(aa,"bb") g() def Demo(): print("本模块自己的反射") import sys print(sys.modules) module=sys.modules[__name__] if hasattr(module,"Demo"): d=getattr(module,"Demo") d()
def bb(): print("bbbbb") #aa
二、内置方法:
__str__和__repr__
改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__
class Foo: def __init__(self,name): self.name = name def __str__(self): return ‘%s obj info in str‘%self.name def __repr__(self): return ‘obj info in repr‘ f = Foo(‘egon‘) # print(f) print(‘%s‘%f) print(‘%r‘%f) print(repr(f)) # f.__repr__() print(str(f)) #当打印一个对象的时候,如果实现了str,打印中的返回值 #当str没有被实现的时候,就会调用repr方法 #但是当你用字符串格式化的时候 %s和%r会分别去调用__str__和__repr__ #不管是在字符串格式化的时候还是在打印对象的时候,repr方法都可以作为str方法的替补 #但反之不行 #用于友好的表示对象。如果str和repr方法你只能实现一个:先实现repr
__del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
__author__ = ‘Administrator‘ class Foo: def __del__(self): print("执行我来") f = Foo() print(123) print(123) del f print(123) print(123) print(123)
item系列
__getitem__\__setitem__\__delitem__
class Foo: def __init__(self): self.name = ‘egon‘ self.age = 73 def __getitem__(self, item): return self.__dict__[item] def __setitem__(self, key, value): # print(key,value) self.__dict__[key] = value def __delitem__(self, key): del self.__dict__[key] f = Foo() # f[‘name‘] = ‘alex‘ # del f[‘name‘] # print(f.name) f1 = Foo() print(f == f1) # print(f[0]) # print(f[1]) # print(f[2])
单例模式
class Singleton: def __new__(cls, *args, **kw): if not hasattr(cls, ‘_instance‘): orig = super(Singleton, cls) cls._instance = orig.__new__(cls, *args, **kw) return cls._instance one = Singleton() two = Singleton() two.a = 3 print(one.a) # 3 # one和two完全相同,可以用id(), ==, is检测 print(id(one)) # 29097904 print(id(two)) # 29097904 print(one == two) # True print(one is two) 单例模式
__call__
对象后面加括号,触发执行。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print(‘__call__‘) obj = Foo() # 执行 __init__ obj() # 执行 __call__
__len__
class A: def __init__(self): self.a = 1 self.b = 2 def __len__(self): return len(self.__dict__) a = A() print(len(a))
# class Foo: # # def __len__(self): # # return len(self.__dict__) # def __hash__(self): # print(‘my hash func‘) # return hash(self.name) # f = Foo() # # print(len(f)) # f.name = ‘egon‘ # # print(len(f)) # print(hash(f))
__hash__
class A: def __init__(self): self.a = 1 self.b = 2 def __hash__(self): return hash(str(self.a)+str(self.b)) a = A() print(hash(a))
__eq__
class A: def __init__(self): self.a = 1 self.b = 2 def __eq__(self,obj): if self.a == obj.a and self.b == obj.b: return True a = A() b = A() print(a == b)
纸牌游戏
class FranchDeck: ranks = [str(n) for n in range(2,11)] + list(‘JQKA‘) suits = [‘红心‘,‘方板‘,‘梅花‘,‘黑桃‘] def __init__(self): self._cards = [Card(rank,suit) for rank in FranchDeck.ranks for suit in FranchDeck.suits] def __len__(self): return len(self._cards) def __getitem__(self, item): return self._cards[item] deck = FranchDeck() print(deck[0]) from random import choice print(choice(deck)) print(choice(deck)) 纸牌游戏
纸牌游戏2
class FranchDeck: ranks = [str(n) for n in range(2,11)] + list(‘JQKA‘) suits = [‘红心‘,‘方板‘,‘梅花‘,‘黑桃‘] def __init__(self): self._cards = [Card(rank,suit) for rank in FranchDeck.ranks for suit in FranchDeck.suits] def __len__(self): return len(self._cards) def __getitem__(self, item): return self._cards[item] def __setitem__(self, key, value): self._cards[key] = value deck = FranchDeck() print(deck[0]) from random import choice print(choice(deck)) print(choice(deck)) from random import shuffle shuffle(deck) print(deck[:5]) 纸牌游戏2
面试题
class Person: def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def __hash__(self): return hash(self.name+self.sex) def __eq__(self, other): if self.name == other.name and self.sex == other.sex:return True p_lst = [] for i in range(84): p_lst.append(Person(‘egon‘,i,‘male‘)) print(p_lst) print(set(p_lst)) 一道面试题
27反射类的内置方法
一、反射1、什么是反射? 用字符串类型的名字去操作变量2、反射对象中的属性和方法 getattrhasattrsetattrdelettr3、 getattr:通过字符串类型的名字取到变量的值 hasattr:判断字符串类型的名字对应的值是否存在 set... 查看详情
day07-02-反射
反射:通过字符串映射或修改程序运行时的状态、属性、方法python中的反射功能是由以下四个内置函数提供:hasattr、getattr、setattr、delattr,改四个函数分别用于对对象内部执行:检查是否含有某成员、获取成员、设置成员、删... 查看详情
27isinstance与issubclass反射内置方法(代码片段)
...,Bar))#输出一个Trueobj=Foo()print(isinstance(obj,Foo))#输出一个True反射反射:通过字符串来反射/映射到对象/类的属性上classPeople:def__init__(self,name,age):self.name=nameself.age=agedefrun(self):print(‘%sisrunning‘%self.name)obj=People(‘egon‘,18)print(hasattr(obj,... 查看详情
day17-注解与反射(代码片段)
Java的注解和反射注解与反射注解可被其他程序(如:编译器)读取,可以对程序做出解释以@注释名在代码中存在内置注解@Override必须重写父类存在的方法,否则报错@Deprecated表示不鼓励使用该类或者方法或者属性@SuppressWarnings(... 查看详情
day27--多态封装反射
一、多态 多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)importabcclassAnimal(metaclass=abc.ABCMeta):#同一类事物:动物@abc.abstractmethoddeftalk(self):passclassPeople(Animal):#动物的形态之一:人deftalk(self... 查看详情
day27(反射之内省机制实现beanutils)
使用内省方式来实现beanUtils往对象里面存值publicclassBeanInfoUtil2{ publicstaticvoidsetPropertyByIntrospector(ObjectuserInfo,Map<String,Object>map)throwsException{ //mapkey=namevalue=valueBeanInfobea 查看详情
learn_day14内置函数补充反射初识面向对象
内置函数__import__()用于导入模块getattr用于寻找模块的指定对象a=__import__(‘b’) #b为模块名,b是字符串==>>导入模块b并重新命名为ac=getattr(a,’d’) #d为模块中指定对象==>>找到模块中命名为d的对象d()==>>执行d#... 查看详情
目录大纲
...的进阶-内置函数(__new__,__del__)Day34面试题Day27类的进阶-反射Day26封装Day25多态.Day24继承Day23面向对象的命名空间与组合Day 查看详情
重修课程day26(面向对象6之反射,内置函数和常用模块)
一 软件的开发规范 基本的目录结构:bin目录:里面写start.py文件,启动程序。将当前的项目目录添加到sys.path,调用core文件下的所有脚本。 core目录:放一些主脚本文件,跟类相关的文件放在里面。在创... 查看详情
day18反射
反射机制是什么反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的... 查看详情
反射内置方法(代码片段)
反射~~~ 反射 使用字符串数据类型的变量名来获取这个变量的值反射类中的变量:静态属性 类方法 静态方法classFoo:school=‘qinghua‘#静态属性country=‘China‘language=‘English‘@classmethod#类方法defclass_method... 查看详情
day13内置函数
...相关的:3种。 基础数据类型相关的:38种。 反射相关:4种。 面向对象相关的:9种。 其他:12种。作用域相关 globals():以字典 查看详情
面向对象的进阶---反射--一些内置方法
反射反射和一些类的内置方法1isinstance----issubclasstype()--判断是不是ininstance(object,cls)判断是不是类的对象如果这个类有父类这个对象也是这个父类的对象issubclaaa(cls,cls)判断一个类是不是另一个类的子类=============================反射... 查看详情
反射(高大上)类的内置方法
反射对象的反射类的反射模块的反射本模块的反射:找到本模块sys.modules[__name__]python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)hasattr()函数用于判断对象是否包含... 查看详情
反射以及内置方法(代码片段)
反射反射是使用字符串数据类型的变量名来获取这个变量的值a=1b=2name=‘wang’使用场景: input:用户输入的如果是a,就打印1,如果是b,就打印2,如果是name,就打印‘wang’ 文件:从文件中读出的字符串,转换成变量的... 查看详情
面向对象:反射内置方法(代码片段)
反射:通过字符串映射到对象或者类的属性反射的方法:classPeople:country="China"def__init__(self,name,age):self.name=nameself.age=agedeftalk(self):print("%sistalking"%self.name)obj=People("neo",22)"""判断是否拥有某个属性:hasattr(o,name)#n 查看详情
面向对象-反射-其他内置方法(代码片段)
1.反射1.1反射含义通过字符串的形式操作对象的相关属性。方法有hasattr,getattr,delattr#!/usr/bin/envpython#-*-coding:utf-8-*-#Author:vitaclassPeople:country=‘China‘def__init__(self,name,age):self.name=nameself.age=agedeftalk(self): 查看详情
反射内置方法
#isinstance()判断对象所属类型,包括继承关系判断对象#classA:pass#classB(A):pass#b=B()#print(isinstance(b,B))#b属于B#print(isinstance(b,A))#b属于A##ssubclass()判断类与类之间的继承关系#classA:pass#classB(A):pass#print(issubclass(B,A))#b属于 查看详情