Python 面向对象之五 基础拾遗

Python 面向对象之五 基础拾遗

        今天呢，就剩下的面向对象的相关知识进行学习，主要会学习以下几个方面的知识：1.上下文管理协议，2.为类加装饰器 3.元类

    一、上下文管理协议

        在学习文件操作的时候对于一个文件的操作是这样的：

with open('文件名','模式')as f:
    '代码块'

    上述叫做上下文管理协议，即with语句，为了让一个对象兼容with语句，必须在这个对象的类中声明__enter__和__exit__方法

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

    def __enter__(self):
        print('执行enter')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('执行exit')
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True


with Foo('a.txt') as f:  #f为Foo的一个实例化对象，（可以类似的想象成f = Open('a.txt)）
# 执行 with Foo('a.txt') as f 就会触发Foo类中的__enter__方法 此方法把self作为返回值传递给f
#with 代码块中的代码执行完毕后就会触发__exit__方法
    print(f)  #<__main__.Foo object at 0x01EC2070>
    print(asdfsaasdfasdfasdfasdfasfasdfasdfasdfasdfasfdasfd)  #代码块有异常就
    # 会直接触发__exit__方法，后面的代码块就会报错，若在__exit__方法中有返回值则会把错误信息吞掉，
    print(f.name)
    print('-----------------')
    print('-----------------')
    print('-----------------')
    print('-----------------')
    print('-----------------')
    print('-----------------')
    print('-----------------')
print('000000000000000000000000000000000000000000000') #先执行__exit__方法后，再执行此句

    用途或者说好处：

        1.使用with语句的目的就是把代码块放入with中执行，with结束后，自动完成清理工作，无须手动干预

        2.在需要管理一些资源比如文件，网络连接和锁的编程环境中，可以在__exit__中定制自动释放资源的机制，你无须再去关系这个问题，这将大有用处

   二、为类加载装饰器

        在学习函数的时候就学习过装饰器，现在在学习面向对象的时候还在讲装饰器，在类中装饰器是这么玩儿的呢？我们首先必须要有一个认识那就是：类与函数都是对象，so,那我们再来了解一下装饰器的符号@ ，在一个函数也好，在一个类也好上面加上装饰器是想表达上面意思呢？

# @名字————>其意义就在于它不会管装在什么上面，都是把他们当做对象来处理
# eg:@echo  此句的执行就相当于：teacher = echo(teacher)
#    def teacher()
#    @echo  此句执行就相当于：Student = echo(Student)
#    calss Student()

 我们先来举一个函数的例子说明一下：

def decho(func):
    print('===========')
    return func

@decho   #执行此行相当于==> test = decho(test)
def test():
    print('..............')

test()

得到的结果为：
===========
..............

再来举一个面向对象的例子：

def test(obj):
    print('======>',obj)
    obj.name='alex'
    obj.age=45
    obj.gender='male'
    return obj
@test   # 相当于执行了Foo = test(Foo)
class Foo():
    pass

print(Foo.__dict__)
print(Foo.name)

输出的结果为：
======> <class '__main__.Foo'>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None, 'name': 'alex', 'age': 45, 'gender': 'male'}
alex

最后再写一个带参数的装饰器的例子：

def MO(**kwargs):
    def test(obj):
        print('---->',obj)
        for k ,v in kwargs.items():
            setattr(obj,k,v)
        return obj
    print('==================>',kwargs) #==================> {'name': 'alex', 'age': 45, 'gender': 'male'}
    return test

@MO(name='alex',age=45,gender='male')
class Teacher():
    print('___>')
    pass

print(Teacher.__dict__)

@MO(name='houliangong')
class Studet():
    print('wangbadan')

print(Studet.__dict__)


输出的结果为：
==================> {'name': 'alex', 'age': 45, 'gender': 'male'}
___>
----> <class '__main__.Teacher'>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Teacher' objects>, '__weakref__': <attribute '__weakref__' of 'Teacher' objects>, '__doc__': None, 'name': 'alex', 'age': 45, 'gender': 'male'}
==================> {'name': 'houliangong'}
wangbadan
----> <class '__main__.Studet'>
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Studet' objects>, '__weakref__': <attribute '__weakref__' of 'Studet' objects>, '__doc__': None, 'name': 'houliangong'}

    三、元类

        啥是元类？元类的意思即是类的类，是创建类的模板，用他就可以创建出类来，so,这么强大是不是得学习一下。

        元类是用来控制如何创建类的，正如类是创建对象的模板一样

        元类的实例为类，正如类的实例为对象(f1对象是Foo类的一个实例，Foo类是 type 类的一个实例)

        type是python的一个内建元类，用来直接控制生成类，python中任何class定义的类其实都是type类实例化的对象

        创建元类的两种模式：

        方式一：

1 class Foo:
2     def func(self):
3         print('from func')

       方式二：

1 def func(self):
2         print('from func')
3 x=1
4 Foo=type('Foo',(object,),{'func':func,'x':1})  #type创建类的时候是需要输入三个参数的第一个为创建的类名，第二个参数为属于那个类用元组来表示，第三个参数为传入的数据属性用字典的类型表示

        一个类没有声明自己的元类，默认他的元类就是type，除了使用元类type，用户也可以通过继承type来自定义元类（顺便我们也可以瞅一瞅元类如何控制类的创建，工作流程是什么）

好，那我们自定义一个元类：

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

    今天就写到这里了，有点累了！