#!/usr/bin/python
# -*- coding:utf-8 -*-
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 = filename
        self.mode = mode
        self.encoding = encoding

    def 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.filename
        else:
            res = "<_io.TextIOWrapper name = ‘%s‘ mode=‘%s‘ encoding=‘%s‘>" %(self.filename,self.mode,self.encoding)
        return res

f1 = FileHandle(‘b.txt‘,‘wb‘)
f1.write(‘你好11111‘.encode(‘utf-8‘))
print(f1)
f1.close()

#!/usr/bin/python
# -*- coding:utf-8 -*-
class List:
    def __init__(self,seq):
        self.seq = seq
    def append(self,p_object):
        if not isinstance(p_object,int):
            raise TypeError(‘must be int‘)
        self.seq.append(p_object)

    @property
    def mid(self):
        index = len(self.seq) // 2
        return 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.mid)
l.insert(0,-123)
print(l)
###我的理解是因为本身是list类型 ，因为类和类型的统一，所以不用继承，直接用slef.seq就是一个list，所以可以通过重写__getattr__可以去调用insert方法。

#!/usr/bin/python
# -*- coding:utf-8 -*-
class List:
    def __init__(self,seq,permission=False):
        self.seq = seq
        self.permission = permission

    def clear(self):
        if not self.permission:
            raise PermissionError(‘not allow the operation‘)
        self.seq.clear()
        self.permission=False
    def __getattr__(self, item):
        return getattr(self.seq,item) （找到这个方法getattr）

    def __str__(self):
        return str(self.seq)

l = List([1,2,3])
l.permission=True
print(l)
l.clear()
l.insert(0,-1234)
print(l)

#!/usr/bin/python
# -*- coding:utf-8 -*-
class Foo:
    def __init__(self,x):
        self.x = x

    def __iter__(self):
        return self
    def __next__(self):
        n = self.x
        self.x += 1
        return self.x


f = Foo(3)
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
for i in f:
    print(i)
    if i == 100:
        break

#!/usr/bin/python
# -*- coding:utf-8 -*-
class Foo:
    def __init__(self,start,stop):
        self.num = start
        self.stop = stop

    def __iter__(self):
        return self

    def __next__(self):
        if self.num >= self.stop:
            raise StopIteration
        n=self.num
        self.num+=1
        return n

f = Foo(1,5)
from collections import Iterator,Iterable
print(isinstance(f,Iterator))


for i in f:
    print(i)

#!/usr/bin/python
# -*- coding:utf-8 -*-
class Range:
    def __init__(self,n,stop,step):
        self.n = n
        self.stop = stop
        self.step = step

    def __next__(self):
        if self.n >= self.stop:
            raise StopIteration
        x = self.n
        self.n += self.step
        return x

    def __iter__(self):
        return self


from collections import Iterator
print(isinstance(Range(1,7,3),Iterator))
for i in Range(1,8,3):
    print(i)

#!/usr/bin/python
# -*- coding:utf-8 -*-
class Fib:
    def __init__(self):
        self._a = 0
        self._b = 1

    def __iter__(self):
        return self

    def __next__(self):
        self._a,self._b=self._b,self._a + self._b
        return self._a

f1 = Fib()

print(f1.__next__())
print(next(f1))
print(next(f1))

for  i in f1:
    if i > 100:
        break
    print(‘%s ‘ %i,end=‘‘)

1 with open(‘a.txt‘) as f:
2 　　‘代码块‘

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print(‘出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量‘)
        # return self ##返回值被赋值给as声明的变量
    def __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=name

    def __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=name

    def __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 True



with Open(‘a.txt‘) as f:
    print(‘=====>执行代码块‘)
    raise AttributeError(‘***着火啦,救火啊***‘)
print(‘0‘*100) #------------------------------->会执行

class Open:
    def __init__(self,filepath,mode=‘r‘,encoding=‘utf-8‘):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding

    def __enter__(self):
        # print(‘enter‘)
        self.f=open(self.filepath,mode=self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        # print(‘exit‘)
        self.f.close()
        return True 
    def __getattr__(self, item):
        return getattr(self.f,item)

with Open(‘a.txt‘,‘w‘) as f:
    print(f)
    f.write(‘aaaaaa‘)
    f.wasdf #抛出异常，交给__exit__处理

练习：模拟Open

#!/usr/bin/python
# -*- coding:utf-8 -*-
class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print(‘__call__‘)

obj = Foo()
obj()

g={
    ‘x‘:1,
    ‘y‘:2,
    ‘teachers‘:{‘egon‘,‘alex‘,‘yuanhao‘,‘wupeiqi‘}
}
l={‘birds‘:[1,2,3]}

# exec("""
# def func():
#     global x
#     x=‘egon‘
# func()
# """,g,l)
# print(g)
# print(l)

exec("""
global x
x=‘egon‘
""",g,l)
print(g)
print(l)

知识储备exec命令

1 class Foo:
2     pass
3 
4 f1=Foo() #f1是通过Foo类实例化的对象

1 #type函数可以查看类型，也可以用来查看对象的类，二者是一样的
2 print(type(f1)) # 输出：<class ‘__main__.Foo‘>     表示，obj 对象由Foo类创建
3 print(type(Foo)) # 输出：<type ‘type‘>  

1 class Chinese(object):
2     country=‘China‘
3     def __init__(self,name,age):
4         self.name=name
5         self.age=age
6     def talk(self):
7         print(‘%s is talking‘ %self.name)

#!/usr/bin/python
# -*- coding:utf-8 -*-
#类名
class_name = ‘Chinese‘
#父类
class_bases= (object,)
#类体
class_body = """
country = ‘China‘
def __init__(self,name,age):
    self.name = name
    self.age = age
def talk(self):
    print(‘%s is talking‘ %self.name)
"""

class_dic = {}

exec(class_body,globals(),class_dic)
print(class_dic)

Foo=type(class_name,class_bases,class_dic) #实例化type得到对象Foo，即我们用class定义的类Foo


print(Foo)
print(type(Foo))
print(isinstance(Foo,type))
‘‘‘
<class ‘__main__.Chinese‘>
<class ‘type‘>
True
‘‘‘

class Mymeta(type):
    def __init__(self):
        print(‘__init__‘)

    def __new__(cls, *args, **kwargs):
        print(‘__new__‘)

    def __call__(self, *args, **kwargs):
        print(‘__call__‘)

class Foo(metaclass=Mymeta):
    pass

print(Foo)
‘‘‘
打印结果:
__new__
None
‘‘‘

‘‘‘
分析Foo的产生过程,即Foo=Mymeta()，会触发产生Mymeta的类内的__call__，即元类的__call__:
    Mymeta加括号,会触发父类的__call__,即type.__call__
    在type.__call__里会调用Foo.__new__
    而Foo.__new__内只是打印操作,没有返回值,因而Mymeta的结果为None,即Foo=None
‘‘‘

#!/usr/bin/python
# -*- coding:utf-8 -*-

# class mymeta(type):
#     def __init__(self):
#         print(‘__init__‘)
#     def __new__(cls, *args, **kwargs):
#         obj = type.__new__(cls,*args,**kwargs)
#         return obj
#
#     def __call__(self, *args, **kwargs):
#         print(‘__call__‘)
#
# Foo = mymeta()
#
# class Foo(metaclass=mymeta):
#     pass
#
# print(Foo)

‘‘‘
基于上述表达，我们改写了__new__,返回obj，但是抛出异常:
TypeError: type.__new__() takes exactly 3 arguments (0 given)

‘‘‘

#改写
class mymeta(type):
    def __init__(self,name,bases,dic):
        print(‘__init__‘)

    def __new__(cls, *args, **kwargs):
        print("__new__")
        obj = type.__new__(cls,*args,**kwargs)
        return obj
    def __call__(self, *args, **kwargs):
        print(‘__call__‘)



class Foo(metaclass=mymeta):
    pass

print(Foo)

class Mymeta(type):
    def __init__(self,name,bases,dic):
        for key,value in dic.items():
            if key.startswith(‘__‘):
                continue
            if not callable(value):
                continue
            if not value.__doc__:
                raise TypeError(‘%s 必须有文档注释‘ %key)
        type.__init__(self,name,bases,dic)

    def __new__(cls, *args, **kwargs):
        # print(‘__new__‘)
        obj=type.__new__(cls,*args,**kwargs)
        return obj

    def __call__(self, *args, **kwargs):
        # print(‘__call__‘)
        pass

# Foo=Mymeta()
class Foo(metaclass=Mymeta):
    def f1(self):
        ‘from f1‘
        pass

    def f2(self):
        pass

‘‘‘
抛出异常
TypeError: f2 必须有文档注释
‘‘‘

应用：限制类内的函数必须有文档注释

class mymeta(type):
    def __call__(self, *args, **kwargs):
        print(‘__call__‘)
        #第一件事，创建对象__new__

        #第二件事，初始化对象__init__

        #第三件事，返回对象 return obj


class Foo(metaclass=mymeta):
    pass

obj = Foo() #Foo()加括号，触发mymeta__call__

class mymeta(type):
    def __call__(self, *args, **kwargs):
        print(‘__call__‘)
        obj=self.__new__(self) ###因为调用的是类的方法，不是绑定方法，所以有几个参数就传几个参数，Foo.__new__(Foo)
        self.__init__(obj,*args,**kwargs) ###调用的是类的方法，所以有几个就传几个参数，因为是初始化对象，所以传入的是obj这个要初始化的对象
        return obj #一定不能忘记返回obj
class Foo(metaclass=mymeta):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        return object.__new__(cls,*args,**kwargs)  ###因为创建的是类的对象，不是元类的类，所以用object，而不是type。type是用来创建元类的对象也就是自己定义的类

obj = Foo(‘egon‘,age=18) #触发mymeta__call__

print(obj.__dict__)

#!/usr/bin/python
# -*- coding:utf-8 -*-
class Mysql:
    __instance = None
    def __init__(self,host=‘127.0.0.1‘,port=‘3306‘):
        self.host = host
        self.port = port

    @classmethod
    def singleton(cls,*args,**kwargs):
        if not cls.__instance:
            cls.__instance=cls(*args,**kwargs)
        return cls.__instance


obj1 = Mysql()
obj2 = Mysql()

print(obj1 is obj2) #False

obj3 = Mysql.singleton()
obj4 = Mysql.singleton()
print(obj3 is obj4) #True

#!/usr/bin/python
# -*- coding:utf-8 -*-
class mymeta(type):
    def __init__(self,name,bases,dic):  #定义类mysql时就触发
        self.__instance=None
        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs):
        if not self.__instance:
            self.__instance=object.__new__(self) ##产生对象 obj1.__instance =
            self.__init__(self.__instance,*args,**kwargs) #初始化对象
        return self.__instance

class Mysql(metaclass=mymeta):
    def __init__(self,host=‘127.0.0.1‘,port=‘3306‘):
        self.host = host
        self.port = port


obj1 = Mysql()
obj2 = Mysql()
print(obj1 is obj2)

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 obj

class Foo(object,metaclass=Mytype):#in python3
    #__metaclass__ = MyType #in python2
    x=1111111111
    def __init__(self,name):
        self.name=name

    def __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 obj

class Foo(object,metaclass=Mytype):
    x=1111111111

    def __init__(self,name):
        self.name=name

    def __new__(cls, *args, **kwargs):
        return super().__new__(cls)

f1=Foo(‘egon‘)

print(f1.__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 obj

class Foo(object,metaclass=Mymeta):
    def __init__(self,name):
        self.name=name
    def __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__方法
‘‘‘

class Mymetaclass(type):
    def __new__(cls,name,bases,attrs):
        update_attrs={}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith(‘__‘):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k]=v
        return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):
    country=‘China‘
    tag=‘Legend of the Dragon‘ #龙的传人
    def walk(self):
        print(‘%s is walking‘ %self.name)


print(Chinese.__dict__)
‘‘‘
{‘__module__‘: ‘__main__‘,
 ‘COUNTRY‘: ‘China‘, 
 ‘TAG‘: ‘Legend of the Dragon‘,
 ‘walk‘: <function Chinese.walk at 0x0000000001E7B950>,
 ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>,                                         
 ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>,
 ‘__doc__‘: None}
‘‘‘

class Mymetaclass(type):
    # def __new__(cls,name,bases,attrs):
    #     update_attrs={}
    #     for k,v in attrs.items():
    #         if not callable(v) and not k.startswith(‘__‘):
    #             update_attrs[k.upper()]=v
    #         else:
    #             update_attrs[k]=v
    #     return type.__new__(cls,name,bases,update_attrs)

    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError(‘must use keyword argument for key function‘)
        obj = object.__new__(self) #创建对象，self为类Foo

        for k,v in kwargs.items():
            obj.__dict__[k.upper()]=v
        return obj

class Chinese(metaclass=Mymetaclass):
    country=‘China‘
    tag=‘Legend of the Dragon‘ #龙的传人
    def walk(self):
        print(‘%s is walking‘ %self.name)


p=Chinese(name=‘egon‘,age=18,sex=‘male‘)
print(p.__dict__)