isinstance和issubclass
- 反射
- setattr
- delattr
- getattr
- hasattr
- __str__和__repr__
- __del__
- item系列
- __getitem__
- __setitem__
- __delitem__
- __new__
- __call__
- __len__
- __hash__
- __eq__
isinstance和issubclass
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
#对象与类之间的关系
#对象与类之间的关系 #判断第一个参数是否是第二个参数的实例 #身份运算 2 == 3 # 值是否相等 2 is 3 # 内存地址是否相等 class A:pass#创建一个类 class B(A):pass#B继承A类 class C(B):pass#C继承B类 c = C()#实例化一个C print(isinstance(c,A)) # True包含继承关系的判断 print(type(c) is C) # type只关心创建这个对象的类
issubclass(sub, super)检查sub类是否是 super 类的派生类
#类与类之间的关系
#类与类之间的关系 #issubclass() class A:pass创建一个A类 class B(A):pass#B类继承A类 print(issubclass(A,B))#False不是包含关系 print(issubclass(B,A))#True是包含关系 #第一个参数是疑似子类,第二个参数是疑似父类. #最终结果如果真的是父子类关系,则返回True
反 射
1 什么是反射
反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。
2 python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)
四个可以实现自省的函数
下列方法适用于类和对象(一切皆对象,类本身也是一个对象)
hasattr、getattr、setattr、delattr
class Foo:#定义一个类 f = '类的静态变量' def __init__(self,name,age):#定义一个动态属性 self.name=name self.age=age def say_hi(self):#定义一个say_hi方法 print('hi,%s'%self.name)#打印hi,对象 obj=Foo('egon',73) #检测是否含有某属性 print(hasattr(obj,'name'))#检测是否含name属性True print(hasattr(obj,'say_hi'))#检测是否含有say_hi属性True #获取属性 n=getattr(obj,'name')#获取对象的name属性的值 print(n) # 类.静态属性 getattr(类,'静态属性') # 对象.方法 # getattr(对象,'方法')() 直接反射得到一个方法之后调用 # 对象.对象属性 # 应用场景 : 网络编程 从文件中读取信息反映到编程中 func=getattr(obj,'say_hi')#获取对象的方法ip地址 func()#执行函数 print(getattr(obj,'aaaaaaaa','不存在啊')) #找不到就报错 #设置属性 setattr(obj,'sb',True)# 为一个变量增加或者修改一个属性 setattr(obj,'show_name',lambda self:self.name+'sb') print(obj.__dict__)#打印obj内的字典 print(obj.show_name(obj))#打印更改后的属性 #删除属性 delattr(obj,'age')#删除一个变量中的属性或者方法 delattr(obj,'show_name') delattr(obj,'show_name111')#不存在,则报错 print(obj.__dict__)#打印obj的字典 # hasattr 判断某一个 变量 是否能够.调用一个名字,返回True或者False # getattr 直接获取一个变量中的名字的值 # setattr 为一个变量增加或者修改一个属性 # delattr 删除一个变量中的属性或者方法
d = {'k':'v'} #d.keys()
print(getattr(d,'keys')())
f = open() # f文件操作对象
f.read() # 文件对象.read方法
a.b 模块名.函数名 import my_moudle#引入一个模块 print(my_moudle.money)#打印my_money类的_money属性 print(getattr(my_moudle,'money'))#得到my_moudle的money属性 getattr(my_moudle,'qqxing')()#得到并运行qqxing函数
包
import 包名 ---> 包内的__init__文件
反射类中的名字
# getattr(类名,'静态属性')
# getattr(类名,'类方法')()
# getattr(类名,'静态方法')()
反射对象中的名字
# getattr(对象名,'对象属性')
# getattr(对象名,'方法名')()
反射模块中的名字
# import 模块名
# getattr(模块名,'模块中的变量')
# getattr(模块名,'模块中的函数')()
# getattr(模块名,'模块中的类名')
反射当前模块中的名字
# import sys
# getattr(sys.modules[__name__],'变量')
# getattr(sys.modules[__name__],'函数')()
# getattr(sys.modules[__name__],'类名')
import sys#引入sys模块 sys.modules[__name__] print(sys.modules[__name__])#<module '__main__' from '/Users/guoyuanjie/Desktop/day27/day27/3.反射.py'> # 所有导入过的模块 # {'字符串数据类型的模块名':模块的内存地址} # {'__main__':当前模块的内存地址}
类中的内置方法 __方法名__
魔术方法 双下方法
内置方法 : 是直接和python的语法隐形相关
len()内置函数 __len__()
hash()哈希函数 __hash__()
str() __str__()
l = [1,2,3,4]
len(l)
class A:#定义一个属性 def __init__(self,name,cls,age,sex):#初始化 self.name = name#name属性 self.cls = cls#cls属性 self.age = age#age属性 self.sex = sex#sex属性 def __eq__(self, other): if self.__dict__ == other.__dict__:return True return True def __len__(self):#__len__方法属性 return len(self.__dict__)#返回一个len(对象的字典的个数) hei = A('小黑','py10期',18,'无')#实例化小黑 hei2 = A('小2黑','py11期',17,'无')#实例化小黑二 def len(obj):#定义一个函数,传入对象 return obj.__len__()#返回一个对象属性 print(len(hei))#打印hei的个数4 print(hei.__dict__)#{'name': '小黑', 'cls': 'py10期', 'age': 18, 'sex': '无'}打印对象hei的字典方法 print(hei2.__dict__)#{'name': '小2黑', 'cls': 'py11期', 'age': 17, 'sex': '无'}打印对象hei2的字典方法 print(hei == hei2) # #True 两个对象就算值是完全相等的,但是仍然内存地址不同 # == 时间上是比较内存地址的 # == 实际上是调用了__eq__方法
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__方法 return format_spec.format(obj=self)#返回一个 s1=School('oldboy1','北京','私立')#实例化一个北京的学校 print(format(s1,format_dict['tna']))#私立:oldboy1:北京 print(format(s1,format_dict['nat']))# oldboy1-北京-私立 print(format(s1,format_dict['tan']))# 私立/北京/oldboy1 print(format(s1,'tna'))# tna print(format(s1,'tan'))# tan
class School: def __init__(self,name,addr,type): self.name=name self.addr=addr self.type=type def __str__(self): return str(self.__dict__) def __repr__(self): # repr是str的备胎 return 'repr : school的repr对象' s1=School('oldboy1','北京','私立') print(str(s1))#{'name': 'oldboy1', 'addr': '北京', 'type': '私立'} print('%s'%s1)#{'name': 'oldboy1', 'addr': '北京', 'type': '私立'} print(s1)#{'name': 'oldboy1', 'addr': '北京', 'type': '私立'} print(repr(s1))#repr : school的repr对象 print('%r'%s1)#repr : school的repr对象 print('%s'%s1) # str __str__ # %s str 直接打印 内部都是调用了__str__
object __eq__,__str__,__repr__
del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo: def __del__(self): print('执行我啦') f1=Foo() del f1 print('------->') #输出结果 执行我啦 ------->
# 构造方法 创建一个对象的 # 初始化方法 __init__ 给已经创建出来的对象添加属性 # 析构方法 删除一个对象的时候调用的方法 import time class A: def __init__(self): self.f = open('userinfo','a') def consume(self): pass def __del__(self): '''在删除一个对象之前做一些收尾工作''' self.f.close() print('删除一个对象的时候调用我') a = A() time.sleep(1) del a # 删除一个对象的时候,如果内部存在__del__方法, # 那么在删除一个对象之前先执行__del__方法中的代码 print(a)
__new__构造方法
# new一个对象 # object.__new__() class A: def __init__(self):#初始化init方法 print('执行init方法了') def __new__(cls):#函数中先执行new方法 print('执行new方法了') return object.__new__(cls) # 创造对象,将对象返回 a = A()# print(type(a)) print(type(A)) # 先执行__new__方法 创造出一个对象 # 然后把创造出来的对象传递给__init__方法 # 会把self自动的返回,被a接收
元类
有一个元类 在创建类
type() 所有直接用class创建出来的类的元类都是type
class 类名(B,classMeta = 元类名)
class 类名(B,classMeta = type) # 默认
元类 创造 类 所以所有的类的type都是它的元类,默认是type
类 创造 对象 具体创造对象的方法 __new__方法,所有的对象的type都是它对应的类
python中 一切皆对象
变量 都有它属于的数据类型
设计模式
单例模式
一个类 可以被多次实例化 但是同一时间在python的内存中,只能有一个实例
class A: _instance = None#定义一个静态变量 def __init__(self,name):#初始化方法 '''给娃穿衣服''' self.name = name#定义一个动态属性 def __new__(cls, *args, **kwargs):#定义一个new方法 '''生娃的过程''' if not A._instance:#如果没有A._instance A._instance = object.__new__(cls)#类属性等于对象的属性 return A._instance#返回一个类属性 a1 = A('alex') # 第一次实例化的时候创造一个实例 print(a1.name)#alex a2 = A('egon') print(a1.name,a2.name,a1 is a2) # egon egon True
class A: def __init__(self,name): '''给娃穿衣服''' self.name = name def __new__(cls, *args, **kwargs): '''生娃的过程''' if not hasattr(A,'_instance'):#如果没有 A._instance = object.__new__(cls) return A._instance a1 = A('alex') # 第一次实例化的时候创造一个实例 print(a1.name)#alex a2 = A('egon') print(a1.name,a2.name) #egon egon
item系列
__getitem__\__setitem__\__delitem__
class A: def __init__(self,name):#初始化方法 self.name = name#定义一个静态属性 self.age = 81 def __getitem__(self, item):#查看一个对象的的方法 return self.__dict__[item] def __setitem__(self, key, value):#增加和修改一个动态属性 self.__dict__[key] = value def __delitem__(self, key):#删除一个动态属性 del self.__dict__[key] a = A('alex')#实例化 print(a['name']) #alex 对应了类中一个方法的语法#a.name==a['name'] print(a['age']) #81 对应了类中一个方法的语法#a.age==a['age'] # 增加 和 修改一个属性 a['sex'] = '不详'# a.sex = '不详'#增加一个a.sex='不祥' print(a.__dict__)#{'name': 'alex', 'age': 81, 'sex': '不详'} # print(a.sex) # print(a['sex']) a['sex'] = '女'#修改一个对象的动态属性 print(a.__dict__)#{'name': 'alex', 'age': 81, 'sex': '女'} del a['sex']#删除一个a['sex']的属性 print(a.__dict__)#{'name': 'alex', 'age': 81}
__call__
对象后面加括号,触发执行。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
class Foo: def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__
class A: def __call__(self,a): print('执行我了',a) def call(self,b): print('执行我了',b) a = A() a('aaa') # __call__ a.call('bbb')
hash
不可变的数据类型都可以被hash
class A: def __init__(self): self.a = 1 self.b = 2 def __hash__(self):#定义一个魔术方法 print(hash(str(12)))#同一时间字符串12的哈希值#7130726887503445041 return hash(str(self.a)+str(self.b))#同一时间返回一个哈希值'12'#7130726887503445041 a = A() print(hash(a))#返回对象的哈希值
class A:pass # def __hash__(self): # return 1 a = A() b = A() print(hash(a)) # object.__hash__()#同一时间同一个对象的hash值不管调用几次都相同 print(hash(a)) # object.__hash__() print(hash(a)) # object.__hash__() print(hash(a)) # object.__hash__() print(hash(a)) # object.__hash__() print(hash(a)) # object.__hash__() print(hash(a)) # object.__hash__() print(hash(b)) # object.__hash__() # dict的key set的元素 # dic key --> value # dic[key] = value # hash(obj)函数,obj对象对应的类必然内部实现了__hash__方法 # hash的结果就是__hash__方法的返回值 # 且在一次成的执行过程中是不会发生变化的 # 且要想作为字典的key或者作为集合的元素,这个对象对应的类必须实现__hash__方法
数据结构与算法 python 数据结构
python核心编程第二三版 基础
流畅的python 进阶
扑克牌例子
from collections import namedtuple#引用一个collections模块namedtuple可命名元祖 Card = namedtuple('Card',['rank','suit'])#创建一个可命名元祖 # card1 = Card(1,'红桃') 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):#定义一个len方法 return len(self._cards)# 返回对象的_cards属性的个数 def __getitem__(self, item):#查询方法 return self._cards[item]#返回一个对象属性的所有内容 def __setitem__(self, key, value): self._cards[key] = value deck = FranchDeck() print('**',deck[:]) from random import choice#引入选择模块 print(choice(deck)) # deck对象对应的类中的getitem方法和len方法 from random import shuffle#打乱顺序 shuffle(deck)#打印顺序 print('**',deck[:])
# 金融公司面试题 # 有一个类,对应这个类产生了100个对象 # 每个对象有三个属性 : 姓名 年龄 性别 # 请对这一百个对象进行去重,如果姓名和性别相同,即便年龄不同也是相同的对象 # 问最简便的方法? class Person:#定义一个类 def __init__(self,name,age,sex):#初始化属性 self.name = name#对象的name属性 self.age = age#对象的age属性 self.sex = sex#对象的sex属性 def __hash__(self):#定义哈希方法 return hash('%s%s'%(self.name,self.sex))#返回hash'self.name,self.sex'的值 def __eq__(self, other):#定义一个eq方法 if self.name == other.name and self.sex == other.sex:#如果对象属性等于 return True p_lst = []#定义个空列表 for i in range(100):#打印0到99 p_lst.append(Person('egon',i,'male'))#p_lst列表添加Person('egon',i,'male') p_lst.append(Person('alex',i,'male'))#p_lst列表添加Person('alex',i,'male') p_lst.append(Person('yuan',i,'male'))#p_lst列表添加Person('yuan',i,'male') print(p_lst) print(set(p_lst)) # 报错不可hash 完成了__hash__ # hash是否相等 __hash__ # 值是否相等 __eq__ # 收获1 # 对于一些python当中已经存在的内置函数 内置数据类型 内置模块中的方法 # 都有可能依赖于类中的内置方法 # 收获2 # set方法依赖集合中元素对象的__hash__ __eq__