Python学习——02-Python基础——【9-面向对象进阶】——isinstance(obj,cls)、反射等...

一 isinstance(obj,cls)和issubclass(sub,super)

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

1 class Foo(object):
2     pass
3  
4 obj = Foo()
5  
6 isinstance(obj, Foo)

 issubclass(sub, super)检查sub类是否是 super 类的派生类

1 class Foo(object):
2     pass
3  
4 class Bar(Foo):
5     pass
6  
7 issubclass(Bar, Foo)

二 反射

1 什么是反射

反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2 python面向对象中的反射:通过字符串的形式操作对象相关的属性。python中的一切事物都是对象(都可以使用反射)

四个可以实现自省的函数

下列方法适用于类和对象(一切皆对象,类本身也是一个对象)

判断object中有没有一个name字符串对应的方法或属性
hasattr(object,name)
def getattr(object, name, default=None): # known special case of getattr"""getattr(object, name[, default]) -> valueGet a named attribute from an object; getattr(x, 'y') is equivalent to x.y.When a default argument is given, it is returned when the attribute doesn'texist; without it, an exception is raised in that case."""passgetattr(object, name, default=None)
getattr(object, name, default=None)
def setattr(x, y, v): # real signature unknown; restored from __doc__"""Sets the named attribute on the given object to the specified value.setattr(x, 'y', v) is equivalent to ``x.y = v''"""passsetattr(x, y, v)
setattr(x, y, v)
def delattr(x, y): # real signature unknown; restored from __doc__"""Deletes the named attribute from the given object.delattr(x, 'y') is equivalent to ``del x.y''"""passdelattr(x, y)
delattr(x, y)
class BlackMedium:feature='Ugly'def __init__(self,name,addr):self.name=nameself.addr=addrdef sell_house(self):print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)def rent_house(self):print('%s 黑中介租房子啦,傻逼才租呢' %self.name)b1=BlackMedium('万成置地','回龙观天露园')#检测是否含有某属性
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_house'))#获取属性
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()# getattr(b1,'aaaaaaaa') #报错
print(getattr(b1,'aaaaaaaa','不存在啊'))#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.show_name(b1))#删除属性
delattr(b1,'addr')
delattr(b1,'show_name')
delattr(b1,'show_name111')#不存在,则报错print(b1.__dict__)四个方法的使用演示
四个方法的使用演示
class Foo(object):staticField = "old boy"def __init__(self):self.name = 'wupeiqi'def func(self):return 'func'@staticmethoddef bar():return 'bar'print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')类也是对象
类也是对象
#!/usr/bin/env python
# -*- coding:utf-8 -*-import sysdef s1():print 's1'def s2():print 's2'this_module = sys.modules[__name__]hasattr(this_module, 's1')
getattr(this_module, 's2')反射当前模块成员
反射当前模块成员

 

 导入其他模块,利用反射查找该模块是否存在某个方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-def test():print('from the test')
module_test.py
#!/usr/bin/env python
# -*- coding:utf-8 -*-"""
程序目录:module_test.pyindex.py当前文件:index.py
"""import module_test as obj#obj.test()print(hasattr(obj,'test'))getattr(obj,'test')()

 

 3 为什么用反射之反射的好处

好处一:实现可插拔机制

有俩程序员,一个lili,一个是egon,lili在写程序的时候需要用到egon所写的类,但是egon去跟女朋友度蜜月去了,还没有完成他写的类,lili想到了反射,使用了反射机制lili可以继续完成自己的代码,等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是,可以事先定义好接口,接口只有在被完成后才会真正执行,这实现了即插即用,这其实是一种‘后期绑定’,什么意思?即你可以事先把主要的逻辑写好(只定义接口),然后后期再去实现接口的功能

class FtpClient:'ftp客户端,但是还么有实现具体的功能'def __init__(self,addr):print('正在连接服务器[%s]' %addr)self.addr=addr
egon还没有实现全部功能
#from module import FtpClient
f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):func_get=getattr(f1,'get')func_get()
else:print('---->不存在此方法')print('处理其他的逻辑')不影响lili的代码编写
不影响lili的代码编写

好处二:动态导入模块(基于反射当前模块成员)

 

三 __setattr__,__delattr__,__getattr__

class Foo:x=1def __init__(self,y):self.y=ydef __getattr__(self, item):print('----> from getattr:你找的属性不存在')def __setattr__(self, key, value):print('----> from setattr')# self.key=value #这就无限递归了,你好好想想# self.__dict__[key]=value #应该使用它def __delattr__(self, item):print('----> from delattr')# del self.item #无限递归了self.__dict__.pop(item)#__setattr__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx三者的用法演示
三者的用法演示

四 二次加工标准类型(包装)

包装:python为大家提供了标准数据类型,以及丰富的内置方法,其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型,新增/改写方法,这就用到了我们刚学的继承/派生知识(其他的标准类型均可以通过下面的方式进行二次加工)

class List(list): #继承list所有的属性,也可以派生出自己新的,比如append和middef append(self, p_object):' 派生自己的append:加上类型检查'if not isinstance(p_object,int):raise TypeError('must be int')super().append(p_object)@propertydef mid(self):'新增自己的属性'index=len(self)//2return self[index]l=List([1,2,3,4])
print(l)
l.append(5)
print(l)
# l.append('1111111') #报错,必须为int类型print(l.mid)#其余的方法都继承list的
l.insert(0,-123)
print(l)
l.clear()
print(l)二次加工标准类型(基于继承实现)
二次加工标准类型(基于继承实现)
class List(list):def __init__(self,item,tag=False):super().__init__(item)self.tag=tagdef append(self, p_object):if not isinstance(p_object,str):raise TypeErrorsuper().append(p_object)def clear(self):if not self.tag:raise PermissionErrorsuper().clear()l=List([1,2,3],False)
print(l)
print(l.tag)l.append('saf')
print(l)# l.clear() #异常

l.tag=True
l.clear()练习(clear加权限限制)
练习(clear加权限限制)

授权:授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖__getattr__方法

import time
class FileHandle:def __init__(self,filename,mode='r',encoding='utf-8'):self.file=open(filename,mode,encoding=encoding)def write(self,line):t=time.strftime('%Y-%m-%d %T')self.file.write('%s %s' %(t,line))def __getattr__(self, item):return getattr(self.file,item)f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0)
print(f1.read())
f1.close()授权示范一
授权示范一
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#我们来加上b模式支持
import time
class FileHandle:def __init__(self,filename,mode='r',encoding='utf-8'):if 'b' in mode:self.file=open(filename,mode)else:self.file=open(filename,mode,encoding=encoding)self.filename=filenameself.mode=modeself.encoding=encodingdef write(self,line):if 'b' in self.mode:if not isinstance(line,bytes):raise TypeError('must be bytes')self.file.write(line)def __getattr__(self, item):return getattr(self.file,item)def __str__(self):if 'b' in self.mode:res="<_io.BufferedReader name='%s'>" %self.filenameelse:res="<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %(self.filename,self.mode,self.encoding)return res
f1=FileHandle('b.txt','wb')
# f1.write('你好啊啊啊啊啊') #自定制的write,不用在进行encode转成二进制去写了,简单,大气
f1.write('你好啊'.encode('utf-8'))
print(f1)
f1.close()授权示范二
授权示范二
#练习一
class List:def __init__(self,seq):self.seq=seqdef append(self, p_object):' 派生自己的append加上类型检查,覆盖原有的append'if not isinstance(p_object,int):raise TypeError('must be int')self.seq.append(p_object)@propertydef mid(self):'新增自己的方法'index=len(self.seq)//2return self.seq[index]def __getattr__(self, item):return getattr(self.seq,item)def __str__(self):return str(self.seq)l=List([1,2,3])
print(l)
l.append(4)
print(l)
# l.append('3333333') #报错,必须为int类型print(l.mid)#基于授权,获得insert方法
l.insert(0,-123)
print(l)#练习二
class List:def __init__(self,seq,permission=False):self.seq=seqself.permission=permissiondef clear(self):if not self.permission:raise PermissionError('not allow the operation')self.seq.clear()def __getattr__(self, item):return getattr(self.seq,item)def __str__(self):return str(self.seq)
l=List([1,2,3])
# l.clear() #此时没有权限,抛出异常
l.permission=True
print(l)
l.clear()
print(l)#基于授权,获得insert方法
l.insert(0,-123)
print(l)练习题(授权)
练习题(授权)

五 __getattribute__

class Foo:def __init__(self,x):self.x=xdef __getattr__(self, item):print('执行的是我')# return self.__dict__[item]

f1=Foo(10)
print(f1.x)
f1.xxxxxx #不存在的属性访问,触发__getattr__

回顾__getattr__
回顾__getattr__
class Foo:def __init__(self,x):self.x=xdef __getattribute__(self, item):print('不管是否存在,我都会执行')f1=Foo(10)
f1.x
f1.xxxxxx__getattribute__
__getattribute__
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'class Foo:def __init__(self,x):self.x=xdef __getattr__(self, item):print('执行的是我')# return self.__dict__[item]def __getattribute__(self, item):print('不管是否存在,我都会执行')raise AttributeError('哈哈')f1=Foo(10)
f1.x
f1.xxxxxx#当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError

二者同时出现
二者同时出现

六 描述符(__get__,__set__,__delete__)

1 描述符是什么:描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议
__get__():调用一个属性时,触发
__set__():为一个属性赋值时,触发
__delete__():采用del删除属性时,触发

class Foo: #在python3中Foo是新式类,它实现了三种方法,这个类就被称作一个描述符def __get__(self, instance, owner):passdef __set__(self, instance, value):passdef __delete__(self, instance):pass定义一个描述符
定义一个描述符

2 描述符是干什么的:描述符的作用是用来代理另外一个类的属性的(必须把描述符定义成这个类的类属性,不能定义到构造函数中)

class Foo:def __get__(self, instance, owner):print('触发get')def __set__(self, instance, value):print('触发set')def __delete__(self, instance):print('触发delete')#包含这三个方法的新式类称为描述符,由这个类产生的实例进行属性的调用/赋值/删除,并不会触发这三个方法
f1=Foo()
f1.name='egon'
f1.name
del f1.name
#疑问:何时,何地,会触发这三个方法的执行

引子:描述符类产生的实例进行属性操作并不会触发三个方法的执行
引子:描述符类产生的实例进行属性操作并不会触发三个方法的执行
#描述符Str
class Str:def __get__(self, instance, owner):print('Str调用')def __set__(self, instance, value):print('Str设置...')def __delete__(self, instance):print('Str删除...')#描述符Int
class Int:def __get__(self, instance, owner):print('Int调用')def __set__(self, instance, value):print('Int设置...')def __delete__(self, instance):print('Int删除...')class People:name=Str()age=Int()def __init__(self,name,age): #name被Str类代理,age被Int类代理,self.name=nameself.age=age#何地?:定义成另外一个类的类属性#何时?:且看下列演示

p1=People('alex',18)#描述符Str的使用
p1.name
p1.name='egon'
del p1.name#描述符Int的使用
p1.age
p1.age=18
del p1.age#我们来瞅瞅到底发生了什么
print(p1.__dict__)
print(People.__dict__)#补充
print(type(p1) == People) #type(obj)其实是查看obj是由哪个类实例化来的
print(type(p1).__dict__ == People.__dict__)描述符应用之何时?何地?
描述符应用之何时?何地?

3 描述符分两种
一 数据描述符:至少实现了__get__()和__set__()

1 class Foo:
2     def __set__(self, instance, value):
3         print('set')
4     def __get__(self, instance, owner):
5         print('get')

二 非数据描述符:没有实现__set__()

1 class Foo:
2     def __get__(self, instance, owner):
3         print('get')

4 注意事项:
一 描述符本身应该定义成新式类,被代理的类也应该是新式类
二 必须把描述符定义成这个类的类属性,不能为定义到构造函数中
三 要严格遵循该优先级,优先级由高到底分别是
1.类属性
2.数据描述符
3.实例属性
4.非数据描述符
5.找不到的属性触发__getattr__()

#描述符Str
class Str:def __get__(self, instance, owner):print('Str调用')def __set__(self, instance, value):print('Str设置...')def __delete__(self, instance):print('Str删除...')class People:name=Str()def __init__(self,name,age): #name被Str类代理,age被Int类代理,self.name=nameself.age=age#基于上面的演示,我们已经知道,在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典#那既然描述符被定义成了一个类属性,直接通过类名也一定可以调用吧,没错
People.name #恩,调用类属性name,本质就是在调用描述符Str,触发了__get__()

People.name='egon' #那赋值呢,我去,并没有触发__set__()
del People.name #赶紧试试del,我去,也没有触发__delete__()
#结论:描述符对类没有作用-------->傻逼到家的结论'''
原因:描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级
People.name #恩,调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__()People.name='egon' #那赋值呢,直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符,肯定不会触发描述符的__set__()
del People.name #同上
'''类属性>数据描述符
类属性>数据描述符
#描述符Str
class Str:def __get__(self, instance, owner):print('Str调用')def __set__(self, instance, value):print('Str设置...')def __delete__(self, instance):print('Str删除...')class People:name=Str()def __init__(self,name,age): #name被Str类代理,age被Int类代理,self.name=nameself.age=agep1=People('egon',18)#如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性
p1.name='egonnnnnn'
p1.name
print(p1.__dict__)#实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性,查看/赋值/删除都是跟描述符有关,与实例无关了
del p1.name数据描述符>实例属性
数据描述符>实例属性
class Foo:def func(self):print('我胡汉三又回来了')
f1=Foo()
f1.func() #调用类的方法,也可以说是调用非数据描述符
#函数是一个非数据描述符对象(一切皆对象么)
print(dir(Foo.func))
print(hasattr(Foo.func,'__set__'))
print(hasattr(Foo.func,'__get__'))
print(hasattr(Foo.func,'__delete__'))
#有人可能会问,描述符不都是类么,函数怎么算也应该是一个对象啊,怎么就是描述符了
#笨蛋哥,描述符是类没问题,描述符在应用的时候不都是实例化成一个类属性么
#函数就是一个由非描述符类实例化得到的对象
#没错,字符串也一样
f1.func='这是实例属性啊'
print(f1.func)del f1.func #删掉了非数据
f1.func()实例属性>非数据描述符
实例属性>非数据描述符
class Foo:def __set__(self, instance, value):print('set')def __get__(self, instance, owner):print('get')
class Room:name=Foo()def __init__(self,name,width,length):self.name=nameself.width=widthself.length=length#name是一个数据描述符,因为name=Foo()而Foo实现了get和set方法,因而比实例属性有更高的优先级
#对实例的属性操作,触发的都是描述符的
r1=Room('厕所',1,1)
r1.name
r1.name='厨房'class Foo:def __get__(self, instance, owner):print('get')
class Room:name=Foo()def __init__(self,name,width,length):self.name=nameself.width=widthself.length=length#name是一个非数据描述符,因为name=Foo()而Foo没有实现set方法,因而比实例属性有更低的优先级
#对实例的属性操作,触发的都是实例自己的
r1=Room('厕所',1,1)
r1.name
r1.name='厨房'再次验证:实例属性>非数据描述符
再次验证:实例属性>非数据描述符
class Foo:def func(self):print('我胡汉三又回来了')def __getattr__(self, item):print('找不到了当然是来找我啦',item)
f1=Foo()f1.xxxxxxxxxxx非数据描述符>找不到
非数据描述符>找不到

 

 

5 描述符使用

众所周知,python是弱类型语言,即参数的赋值没有类型限制,下面我们通过描述符机制来实现类型限制功能

class Str:def __init__(self,name):self.name=namedef __get__(self, instance, owner):print('get--->',instance,owner)return instance.__dict__[self.name]def __set__(self, instance, value):print('set--->',instance,value)instance.__dict__[self.name]=valuedef __delete__(self, instance):print('delete--->',instance)instance.__dict__.pop(self.name)class People:name=Str('name')def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salaryp1=People('egon',18,3231.3)#调用
print(p1.__dict__)
p1.name#赋值
print(p1.__dict__)
p1.name='egonlin'
print(p1.__dict__)#删除
print(p1.__dict__)
del p1.name
print(p1.__dict__)牛刀小试
牛刀小试
class Str:def __init__(self,name):self.name=namedef __get__(self, instance, owner):print('get--->',instance,owner)return instance.__dict__[self.name]def __set__(self, instance, value):print('set--->',instance,value)instance.__dict__[self.name]=valuedef __delete__(self, instance):print('delete--->',instance)instance.__dict__.pop(self.name)class People:name=Str('name')def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salary#疑问:如果我用类名去操作属性呢
People.name #报错,错误的根源在于类去操作属性时,会把None传给instance#修订__get__方法
class Str:def __init__(self,name):self.name=namedef __get__(self, instance, owner):print('get--->',instance,owner)if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):print('set--->',instance,value)instance.__dict__[self.name]=valuedef __delete__(self, instance):print('delete--->',instance)instance.__dict__.pop(self.name)class People:name=Str('name')def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salary
print(People.name) #完美,解决

拔刀相助
拔刀相助
class Str:def __init__(self,name,expected_type):self.name=nameself.expected_type=expected_typedef __get__(self, instance, owner):print('get--->',instance,owner)if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):print('set--->',instance,value)if not isinstance(value,self.expected_type): #如果不是期望的类型,则抛出异常raise TypeError('Expected %s' %str(self.expected_type))instance.__dict__[self.name]=valuedef __delete__(self, instance):print('delete--->',instance)instance.__dict__.pop(self.name)class People:name=Str('name',str) #新增类型限制strdef __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salaryp1=People(123,18,3333.3)#传入的name因不是字符串类型而抛出异常

磨刀霍霍
磨刀霍霍
class Typed:def __init__(self,name,expected_type):self.name=nameself.expected_type=expected_typedef __get__(self, instance, owner):print('get--->',instance,owner)if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):print('set--->',instance,value)if not isinstance(value,self.expected_type):raise TypeError('Expected %s' %str(self.expected_type))instance.__dict__[self.name]=valuedef __delete__(self, instance):print('delete--->',instance)instance.__dict__.pop(self.name)class People:name=Typed('name',str)age=Typed('name',int)salary=Typed('name',float)def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salaryp1=People(123,18,3333.3)
p1=People('egon','18',3333.3)
p1=People('egon',18,3333)大刀阔斧
大刀阔斧

大刀阔斧之后我们已然能实现功能了,但是问题是,如果我们的类有很多属性,你仍然采用在定义一堆类属性的方式去实现,low,这时候我需要教你一招:独孤九剑

def decorate(cls):print('类的装饰器开始运行啦------>')return cls@decorate #无参:People=decorate(People)
class People:def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salaryp1=People('egon',18,3333.3)类的装饰器:无参
类的装饰器:无参
def typeassert(**kwargs):def decorate(cls):print('类的装饰器开始运行啦------>',kwargs)return clsreturn decorate
@typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
class People:def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salaryp1=People('egon',18,3333.3)类的装饰器:有参
类的装饰器:有参

终极大招

class Typed:def __init__(self,name,expected_type):self.name=nameself.expected_type=expected_typedef __get__(self, instance, owner):print('get--->',instance,owner)if instance is None:return selfreturn instance.__dict__[self.name]def __set__(self, instance, value):print('set--->',instance,value)if not isinstance(value,self.expected_type):raise TypeError('Expected %s' %str(self.expected_type))instance.__dict__[self.name]=valuedef __delete__(self, instance):print('delete--->',instance)instance.__dict__.pop(self.name)def typeassert(**kwargs):def decorate(cls):print('类的装饰器开始运行啦------>',kwargs)for name,expected_type in kwargs.items():setattr(cls,name,Typed(name,expected_type))return clsreturn decorate
@typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)
class People:def __init__(self,name,age,salary):self.name=nameself.age=ageself.salary=salaryprint(People.__dict__)
p1=People('egon',18,3333.3)刀光剑影
刀光剑影

6 描述符总结

描述符是可以实现大部分python类特性中的底层魔法,包括@classmethod,@staticmethd,@property甚至是__slots__属性

描述父是很多高级库和框架的重要工具之一,描述符通常是使用到装饰器或者元类的大型框架中的一个组件.

7 利用描述符原理完成一个自定制@property,实现延迟计算(本质就是把一个函数属性利用装饰器原理做成一个描述符:类的属性字典中函数名为key,value为描述符类产生的对象)

class Room:def __init__(self,name,width,length):self.name=nameself.width=widthself.length=length@propertydef area(self):return self.width * self.lengthr1=Room('alex',1,1)
print(r1.area)@property回顾
@property回顾
class Lazyproperty:def __init__(self,func):self.func=funcdef __get__(self, instance, owner):print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')if instance is None:return selfreturn self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情class Room:def __init__(self,name,width,length):self.name=nameself.width=widthself.length=length@Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符def area(self):return self.width * self.lengthr1=Room('alex',1,1)
print(r1.area)自己做一个@property
自己做一个@property
class Lazyproperty:def __init__(self,func):self.func=funcdef __get__(self, instance, owner):print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')if instance is None:return selfelse:print('--->')value=self.func(instance)setattr(instance,self.func.__name__,value) #计算一次就缓存到实例的属性字典中return valueclass Room:def __init__(self,name,width,length):self.name=nameself.width=widthself.length=length@Lazyproperty #area=Lazyproperty(area) 相当于'定义了一个类属性,即描述符'def area(self):return self.width * self.lengthr1=Room('alex',1,1)
print(r1.area) #先从自己的属性字典找,没有再去类的中找,然后出发了area的__get__方法
print(r1.area) #先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算

实现延迟计算功能
实现延迟计算功能
#缓存不起来了class Lazyproperty:def __init__(self,func):self.func=funcdef __get__(self, instance, owner):print('这是我们自己定制的静态属性,r1.area实际是要执行r1.area()')if instance is None:return selfelse:value=self.func(instance)instance.__dict__[self.func.__name__]=valuereturn value# return self.func(instance) #此时你应该明白,到底是谁在为你做自动传递self的事情def __set__(self, instance, value):print('hahahahahah')class Room:def __init__(self,name,width,length):self.name=nameself.width=widthself.length=length@Lazyproperty #area=Lazyproperty(area) 相当于定义了一个类属性,即描述符def area(self):return self.width * self.lengthprint(Room.__dict__)
r1=Room('alex',1,1)
print(r1.area)
print(r1.area) 
print(r1.area) 
print(r1.area) #缓存功能失效,每次都去找描述符了,为何,因为描述符实现了set方法,它由非数据描述符变成了数据描述符,数据描述符比实例属性有更高的优先级,因而所有的属性操作都去找描述符了

一个小的改动,延迟计算的美梦就破碎了
一个小的改动,延迟计算的美梦就破碎了

8 利用描述符原理完成一个自定制@classmethod

class ClassMethod:def __init__(self,func):self.func=funcdef __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,def feedback():print('在这里可以加功能啊...')return self.func(owner)return feedbackclass People:name='linhaifeng'@ClassMethod # say_hi=ClassMethod(say_hi)def say_hi(cls):print('你好啊,帅哥 %s' %cls.name)People.say_hi()p1=People()
p1.say_hi()
#疑问,类方法如果有参数呢,好说,好说class ClassMethod:def __init__(self,func):self.func=funcdef __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,def feedback(*args,**kwargs):print('在这里可以加功能啊...')return self.func(owner,*args,**kwargs)return feedbackclass People:name='linhaifeng'@ClassMethod # say_hi=ClassMethod(say_hi)def say_hi(cls,msg):print('你好啊,帅哥 %s %s' %(cls.name,msg))People.say_hi('你是那偷心的贼')p1=People()
p1.say_hi('你是那偷心的贼')自己做一个@classmethod
自己做一个@classmethod

9 利用描述符原理完成一个自定制的@staticmethod

class StaticMethod:def __init__(self,func):self.func=funcdef __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,def feedback(*args,**kwargs):print('在这里可以加功能啊...')return self.func(*args,**kwargs)return feedbackclass People:@StaticMethod# say_hi=StaticMethod(say_hi)def say_hi(x,y,z):print('------>',x,y,z)People.say_hi(1,2,3)p1=People()
p1.say_hi(4,5,6)自己做一个@staticmethod
自己做一个@staticmethod

 

 

六 再看property

一个静态属性property本质就是实现了get,set,delete三种方法

class Foo:@propertydef AAA(self):print('get的时候运行我啊')@AAA.setterdef AAA(self,value):print('set的时候运行我啊')@AAA.deleterdef AAA(self):print('delete的时候运行我啊')#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA用法一
用法一
class Foo:def get_AAA(self):print('get的时候运行我啊')def set_AAA(self,value):print('set的时候运行我啊')def delete_AAA(self):print('delete的时候运行我啊')AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA用法二
用法二

怎么用?

class Goods:def __init__(self):# 原价self.original_price = 100# 折扣self.discount = 0.8@propertydef price(self):# 实际价格 = 原价 * 折扣new_price = self.original_price * self.discountreturn new_price@price.setterdef price(self, value):self.original_price = value@price.deleterdef price(self):del self.original_priceobj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

案例一
案例一
#实现类型检测功能#第一关:
class People:def __init__(self,name):self.name=name@propertydef name(self):return self.name# p1=People('alex') #property自动实现了set和get方法属于数据描述符,比实例属性优先级高,所以你这面写会触发property内置的set,抛出异常#第二关:修订版class People:def __init__(self,name):self.name=name #实例化就触发property
@propertydef name(self):# return self.name #无限递归print('get------>')return self.DouNiWan@name.setterdef name(self,value):print('set------>')self.DouNiWan=value@name.deleterdef name(self):print('delete------>')del self.DouNiWanp1=People('alex') #self.name实际是存放到self.DouNiWan里
print(p1.name)
print(p1.name)
print(p1.name)
print(p1.__dict__)p1.name='egon'
print(p1.__dict__)del p1.name
print(p1.__dict__)#第三关:加上类型检查
class People:def __init__(self,name):self.name=name #实例化就触发property
@propertydef name(self):# return self.name #无限递归print('get------>')return self.DouNiWan@name.setterdef name(self,value):print('set------>')if not isinstance(value,str):raise TypeError('必须是字符串类型')self.DouNiWan=value@name.deleterdef name(self):print('delete------>')del self.DouNiWanp1=People('alex') #self.name实际是存放到self.DouNiWan里
p1.name=1案例二
案例二

七 __setitem__,__getitem,__delitem__

class Foo:def __init__(self,name):self.name=namedef __getitem__(self, item):print(self.__dict__[item])def __setitem__(self, key, value):self.__dict__[key]=valuedef __delitem__(self, key):print('del obj[key]时,我执行')self.__dict__.pop(key)def __delattr__(self, item):print('del obj.key时,我执行')self.__dict__.pop(item)f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)
View Code

八 __str__,__repr__,__format__

改变对象的字符串显示__str__,__repr__

自定制格式化字符串__format__

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
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=nameself.addr=addrself.type=typedef __repr__(self):return 'School(%s,%s)' %(self.name,self.addr)def __str__(self):return '(%s,%s)' %(self.name,self.addr)def __format__(self, format_spec):# if format_specif not format_spec or format_spec not in format_dict:format_spec='nat'fmt=format_dict[format_spec]return fmt.format(obj=self)s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))
View Code
date_dic={'ymd':'{0.year}:{0.month}:{0.day}','dmy':'{0.day}/{0.month}/{0.year}','mdy':'{0.month}-{0.day}-{0.year}',
}
class Date:def __init__(self,year,month,day):self.year=yearself.month=monthself.day=daydef __format__(self, format_spec):if not format_spec or format_spec not in date_dic:format_spec='ymd'fmt=date_dic[format_spec]return fmt.format(self)d1=Date(2016,12,29)
print(format(d1))
print('{:mdy}'.format(d1))自定义format练习
自定义format练习
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'class A:passclass B(A):passprint(issubclass(B,A)) #B是A的子类,返回True

a1=A()
print(isinstance(a1,A)) #a1是A的实例

issubclass和isinstance
issubclass和isinstance

九 __slots__

'''
1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__
当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个
字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给
实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该
只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
关于__slots__的一个常见误区是它可以作为一个封装工具来防止用户给实例增加新的属性。尽管使用__slots__可以达到这样的目的,但是这个并不是它的初衷。           更多的是用来作为一个内存优化工具。'''
class Foo:__slots__='x'f1=Foo()
f1.x=1
f1.y=2#报错
print(f1.__slots__) #f1不再有__dict__class Bar:__slots__=['x','y']n=Bar()
n.x,n.y=1,2
n.z=3#报错__slots__使用
__slots__使用
class Foo:__slots__=['name','age']f1=Foo()
f1.name='alex'
f1.age=18
print(f1.__slots__)f2=Foo()
f2.name='egon'
f2.age=19
print(f2.__slots__)print(Foo.__dict__)
#f1与f2都没有属性字典__dict__了,统一归__slots__管,节省内存

刨根问底
刨根问底

十 __next__和__iter__实现迭代器协议

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
class Foo:def __init__(self,x):self.x=xdef __iter__(self):return selfdef __next__(self):n=self.xself.x+=1return self.xf=Foo(3)
for i in f:print(i)简单示范
简单示范
class Foo:def __init__(self,start,stop):self.num=startself.stop=stopdef __iter__(self):return selfdef __next__(self):if self.num >= self.stop:raise StopIterationn=self.numself.num+=1return nf=Foo(1,5)
from collections import Iterable,Iterator
print(isinstance(f,Iterator))for i in Foo(1,5):print(i)
class Range:def __init__(self,n,stop,step):self.n=nself.stop=stopself.step=stepdef __next__(self):if self.n >= self.stop:raise StopIterationx=self.nself.n+=self.stepreturn xdef __iter__(self):return selffor i in Range(1,7,3): #
    print(i)练习:简单模拟range,加上步长
练习:简单模拟range,加上步长
class Fib:def __init__(self):self._a=0self._b=1def __iter__(self):return selfdef __next__(self):self._a,self._b=self._b,self._a + self._breturn self._af1=Fib()print(f1.__next__())
print(next(f1))
print(next(f1))for i in f1:if i > 100:breakprint('%s ' %i,end='')斐波那契数列
斐波那契数列

 

 参考:http://www.cnblogs.com/linhaifeng/articles/6204014.html#_label6

转载于:https://www.cnblogs.com/caofu/p/8762641.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/414300.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

工作262:HBuilderX常见快捷键

1 1. ctrl/ 注释代码2 2. ctrly 恢复撤销3 3. ctrlx 剪切4 4. ctrlz 撤销5 5. ctrlc 复制6 6. ctrlp 在当前项目查找文件7 7. ctrlf 在当前文件查找字符串8 8. ctrlaltf 在当前目录查找字符串9 9. ctrlk 格式化代码 10 10. ctrlg 跳转到某行代码 11 11. ctrlo 打开文件 12 12. …

webService使用

1. 认识webservice WebService定义: 顾名思义就是基于Web的服务。它使用Web(HTTP)方式&#xff0c;接收和响应外部系统的某种请求。从而实现远程调用。 Webservice理解&#xff1a;我们可以调用互联网上查询天气信息Web服务&#xff0c;然后将它嵌入到我们的程序(C/S或B/S程序)…

工作261:ele-layont布局使用

<!--页面主体布局--> <template><el-container class"layout"><!--头部组件--><el-header class"element-header" style"height: 80px;line-height: 80px"><global-header /></el-header><el-con…

68-Flutter中极光推送的使用

1、申请极光账号和建立应用 极光推送的官方网址为&#xff1a;https://www.jiguang.cn/ 注册好后&#xff0c;进入服务中心,然后再进入开发者平台&#xff0c;点击创建应用。 这时候会出现新页面&#xff0c;让你填写“应用名称”和上传“应用图标”。 创建完成&#xff0c;极…

工作275:表单验证重置

/*3GY歌谣表单验证 通过继续前行*/this.$refs["form"].validate(valid > {if (valid) {setTimeout(() > {/*声明变量*/let method postAction;/*声明url* position()* *//*url/user*/let url this.url.add;/*4 判断是否有id 确定新增还是编辑 根据表单数据是…

被引用的外部JS存在window.onload时,判断当前页面是否已存在window.onload,并进行相应处理...

如果页面a.html引用了b.js&#xff0c;b.js里的方法需要在页面资源加载完成后执行&#xff0c;即在window.onload里执行&#xff1b;这时如果a.html里使用了window.onload方法&#xff0c;b.js就不能重复调用这个方法了&#xff0c;因为window.onload不能同时使用多个&#xff…

new String(123) 创建了几个对象?

String 对象可谓再熟悉不过了&#xff0c;与此相关的面试题经常会引出内存性能优化的问题&#xff0c;本篇主要以 new String("123") 创建了几个对象为例记录。 一、你能回答正确吗 String a "123"; 如上定义的为常量&#xff1b; String b a "456&…

如何优化网站页面提高网页的加载速度

网站要想加载快无非就是减少http请求次数&#xff0c;下面说一下具体做法&#xff1a; 1&#xff1a;字符集声明 如果<head>部分未定义字符集&#xff0c;将增加页面渲染次数&#xff0c;速度减慢。 2&#xff1a;Meta信息完善程度 建议网站meta信息填写完整 3&…

工作263:弹性布局 修改样式

<div class"container" style"display: flex;flex-direction: column"><!-- <el-radio-group v-model"mode">--><div ><!-- <el-radio-button class"login-btn" label"0">营销端</el…

MongoDB系列四(索引).

一、索引简介 再来老生常谈一番&#xff0c;什么是索引呢&#xff1f;数据库索引与书籍的索引类似。有了索引就不需要翻整本书&#xff0c;数据库可以直接在索引中查找&#xff0c;在索引中找到条目以后&#xff0c;就可以直接跳转到目标文档的位置&#xff0c;这能使查找速度提…

并发编程之多线程线程安全(上)

1、为什么有线程安全问题&#xff1f; 当多个线程共享同一个全局变量或静态变量&#xff0c;做写的操作时&#xff0c;可能会发生数据冲突问题&#xff0c;也就是线程安全问题。但是做读操作是不会发生数据冲突问题。 案例&#xff1a;现在有100张火车票&#xff0c;有两个窗口…

[PAT乙级]数字分类 (20)

题目描述 给定一系列正整数&#xff0c;请按要求对数字进行分类&#xff0c;并输出以下5个数字&#xff1a;A1 能被5整除的数字中所有偶数的和&#xff1b;A2 将被5除后余1的数字按给出顺序进行交错求和&#xff0c;即计算n1-n2n3-n4...&#xff1b;A3 被5除后余2的数字的个…

怎样在php中使用PDF文档功能

写给Hunte: 好久不在网上见你,真有点说不出来的感觉,没有hunte的phpuser.com什么也不是. 转了你站上的两篇文章, 特翻了一篇了以示致歉. ---------------------------------------------------- 原作者:Perugini Luca (www.phpbuilder.com) 译者:znsoft (http://www.phpease.co…

并发编程快速入门

1、线程与进程的区别 进程是所有线程的集合&#xff0c;每一个线程是进程中的一条执行路径。 比方&#xff1a;通过查看 windows 任务管理器中的列表&#xff0c;我们可以把运行在内存中的 exe 文件理解成进程&#xff0c;进程是受操作系统管理的基本运行单元。 2、为什么要…

工作275:表单验证层级添加

<template><!--绑定了一个 控制是否为全屏fullscreen close-on-click-modal 是否通过点击model进行关闭 visible是否显示弹出框 close关闭按钮 --><el-dialog :title"fullTitle" width"80%" :fullscreen"false" :close-on-click-…

Python 黑帽子第二章运行截图

转载于:https://www.cnblogs.com/blankicefire/p/8796158.html

公司网页添加旺旺,状态不正确

这两天在给公司做的网站添加旺旺&#xff0c;在阿里巴巴官网生成代码之后复制到网页。想试试旺旺的状态是否正确&#xff0c;登录旺旺之后一直都是不在线状态&#xff0c;如下图&#xff1a; &#xff0c; 到官网问客服之后得到的答复如下&#xff1a; 如果您登录了阿里旺旺…

并发编程之多线程线程安全(下)

1、什么是 Volatile&#xff1f; volatile 是一个类型修饰符&#xff0c;具有可见性&#xff0c;也就是说一旦某个线程修改了该被 volatile 修饰的变量&#xff0c;它会保证修改的值会立即被更新到主存&#xff0c;当有其他线程需要读取时&#xff0c;可以立即获取修改之后的值…

工作265:v-model实现原理 自定义组件使用v-model

v-model只是一个语法糖&#xff0c;等于:valueinput&#xff0c;真正的实现靠的还是&#xff1a; &#xfeff;v-bind:绑定响应式数据&#xff0c;触发 input 事件并传递数据 (核心和重点) 1其实和下面一样的 <input :value“something” input“something $event.target…

关于CI框架引入CSS与JS文件

</pre>最近用了一下CI框架&#xff0c;使用到了bootstrap&#xff0c;引入CSS文件的时候一直不生效&#xff0c;琢磨这找到了原因。<p></p><p>首先&#xff0c;在根目录找到.htaccess文件&#xff0c;修改为如下内容</p><p></p><…