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_*_
#我们来加上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,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)

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

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__)

######################__solts__节省内存，让类没有__dict__字典，严格定义对象属性
from collections import Iterable,Iteratorclass people:__slots__ = ['name','age','high']b=people()
b.name='egon'
b.age=18
b.high=1.5

1.__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性)
2.引子:使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__
当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个
字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给
实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4.注意事项:__slots__的很多特性都依赖于普通的基于字典的实现。另外,定义了__slots__后的类不再 支持一些普通类特性了,比如多继承。大多数情况下,你应该
只在那些经常被使用到 的用作数据结构的类上定义__slots__比如在程序中需要创建某个类的几百万个实例对象 。
关于__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__管,节省内存

刨根问底

#_*_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 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='')

class Foo:'我是描述信息'passclass Bar(Foo):pass
print(Bar.__doc__) #该属性无法继承给子类

###########################__del__当调用基数为0即对象被清除时候会被执行（析构函数）  __doc__注释，不会被继承
class Open:def __init__(self,path,mode='a+',encoding='utf-8'):self.f=open(path,mode=mode,encoding=encoding)def __getattr__(self, item):return getattr(self.f,item)def __enter__(self):  #使用with as 开始时执行（或with）print('已经开始')return selfdef __del__(self):print('清理')def __exit__(self, exc_type, exc_val, exc_tb): #使用with as 结束时执行
        self.f.close()print("已经结束，正在清理")return True# 处理异常后返回真，可以使程序不推出异常
with Open('111') as f:f.write("\n我进来了")

class Open:def __init__(self,name):self.name=namedef __enter__(self):print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')# return selfdef __exit__(self, exc_type, exc_val, exc_tb):print('with中代码块执行完毕时执行我啊')with Open('a.txt') as f:print('=====>执行代码块')# print(f,f.name)

上下文管理协议

class Open:def __init__(self,name):self.name=namedef __enter__(self):print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')def __exit__(self, exc_type, exc_val, exc_tb):print('with中代码块执行完毕时执行我啊')print(exc_type)print(exc_val)print(exc_tb)with Open('a.txt') as f:print('=====>执行代码块')raise AttributeError('***着火啦,救火啊***')
print('0'*100) #------------------------------->不会执行

class Open:def __init__(self,name):self.name=namedef __enter__(self):print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')def __exit__(self, exc_type, exc_val, exc_tb):print('with中代码块执行完毕时执行我啊')print(exc_type)print(exc_val)print(exc_tb)return Truewith Open('a.txt') as f:print('=====>执行代码块')raise AttributeError('***着火啦,救火啊***')
print('0'*100) #------------------------------->会执行

class Foo:def __init__(self):passdef __call__(self, *args, **kwargs):print('__call__')obj = Foo() # 执行 __init__
obj()       # 执行 __call__

 class Foo:def func(self):print('from func'）

 def func(self):print('from func')x=1Foo=type('Foo',(object,),{'func':func,'x':1})

class Mytype(type):def __init__(self,class_name,bases=None,dict=None):print("Mytype init--->")print(class_name,type(class_name))print(bases)print(dict)def __call__(self, *args, **kwargs):print('Mytype call---->',self,args,kwargs)obj=self.__new__(self)self.__init__(obj,*args,**kwargs)return objclass Foo(object,metaclass=Mytype):#in python3#__metaclass__ = MyType #in python2x=1111111111def __init__(self,name):self.name=namedef __new__(cls, *args, **kwargs):return super().__new__(cls)# return object.__new__(cls) #同上
f1=Foo('name')
print(f1.__dict__)

class Mytype(type):def __init__(self,what,bases=None,dict=None):print('mytype init')def __call__(self, *args, **kwargs):obj=self.__new__(self)self.__init__(obj,*args,**kwargs)return objclass Foo(object,metaclass=Mytype):x=1111111111def __init__(self,name):self.name=namedef __new__(cls, *args, **kwargs):return super().__new__(cls)f1=Foo('egon')print(f1.__dict__)

class Mytype(type):def __init__(self,what,bases=None,dict=None):print(what,bases,dict)def __call__(self, *args, **kwargs):print('--->')obj=object.__new__(self)self.__init__(obj,*args,**kwargs)return obj
class Room(metaclass=Mytype):def __init__(self,name):self.name=namer1=Room('alex')
print(r1.__dict__)

class Mymeta(type):def __init__(self,name,bases,dic):print('===>Mymeta.__init__')def __new__(cls, *args, **kwargs):print('===>Mymeta.__new__')return type.__new__(cls,*args,**kwargs)def __call__(self, *args, **kwargs):print('aaa')obj=self.__new__(self)self.__init__(self,*args,**kwargs)return objclass Foo(object,metaclass=Mymeta):def __init__(self,name):self.name=namedef __new__(cls, *args, **kwargs):return object.__new__(cls)'''
需要记住一点:名字加括号的本质(即,任何name()的形式),都是先找到name的爹,然后执行:爹.__call__而爹.__call__一般做两件事:
1.调用name.__new__方法并返回一个对象
2.进而调用name.__init__方法对儿子name进行初始化
''''''
class 定义Foo,并指定元类为Mymeta,这就相当于要用Mymeta创建一个新的对象Foo,于是相当于执行
Foo=Mymeta('foo',(...),{...})
因此我们可以看到,只定义class就会有如下执行效果
===>Mymeta.__new__
===>Mymeta.__init__
实际上class Foo(metaclass=Mymeta)是触发了Foo=Mymeta('Foo',(...),{...})操作,
遇到了名字加括号的形式,即Mymeta(...),于是就去找Mymeta的爹type,然后执行type.__call__(...)方法
于是触发Mymeta.__new__方法得到一个具体的对象,然后触发Mymeta.__init__方法对对象进行初始化
''''''
obj=Foo('egon')
的原理同上
''''''
总结:元类的难点在于执行顺序很绕,其实我们只需要记住两点就可以了
1.谁后面跟括号,就从谁的爹中找__call__方法执行
type->Mymeta->Foo->obj
Mymeta()触发type.__call__
Foo()触发Mymeta.__call__
obj()触发Foo.__call__
2.__call__内按先后顺序依次调用儿子的__new__和__init__方法
'''