python基础--------面向对象进阶

一，__getitem__ ,__setitem__  , __delitem__

# 把对象操作属性的，模拟成字典的格式
class Foo:
    def __init__(self,name):
        self.name =name
    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        print("修改增加的时候，才会触发我")
        self.__dict__[key]= value
    def __delitem__(self, key):
        print("删除的时候，才会触发我")
        self.__dict__.pop(key)
f = Foo("egon")
f["age"] = 12   #修改，增加的时候 才会触发__srtitem__
print(f.__dict__)  #{'name': 'egon', 'age': 12}
#del f["name"]   # 模拟字典的key ，字典的key是str类型
print(f.__dict__)
print(f["name"])  #触发 __getitem__  ,获取dict中“name”的value，  没有就会报错
print(f["sex"])  # 报错：KeyError: 'sex'

二，__slots__

1,__slots__是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(意味着所有实例只有一个数据属性),

2,把类内部的所有属性，统一管理起来，不会产生新的名称空间，也就是新的dict，实例化一个对象，就会相对应的产生一个对象的名称空间，使用__slots__,只有一个名称空间，即__slote__[],或（）或{}这里面的

3.为何使用__slots__:字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__

当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了,只能使用在__slots__中定义的那些属性名。

 

class People:
    __slots__ = ["x","y","z"]   #以列表为例
p = People()
print(People.__dict__) #整个类 只有类有字典
p.x = 1
p.y = 2
p.z = 3
p.a = 5  ##报错AttributeError: 'People' object has no attribute 'name'意思就是在字典里找不到a这个key

#print(p.__dict__) #报错，对象没有dict了
p1 = People()
p1.z =10
p1.x = 20
p1.y = 30
print(p1.z,p1.x,p1.y)
print(People.__dict__)

三，实现迭代器协议：

1.

class Foo:
    def __init__(self,start):
        self.start = start
    def __iter__(self):
        return self
    def __next__(self):
        if self.start>10:
            raise StopIteration("超出范围") #主动抛出异常
        n = self.start
        self.start+=1
        return n
f= Foo(1)
print(next(f)) #一次一次的next取值，直到所有的值全被取完，next到11的时候，因为没有值可以取了                    
print(next(f)) # 就主动抛出 raise StopIteration("超出范围")
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))  #用这种方法很搂，跟简单的就是for循环，他帮我们把__iter__和__next__全部做好了
for i in f:
    print(i)

2，模拟range函数，1到10，跟上面的差不多，定义一个截止的参数就行了

#模拟range函数，1到10
class Range:
    def __init__(self,start,end):
        self.start = start
        self.end = end
    def __iter__(self):
        return self
    def __next__(self):
        if self.start == self.end:
            raise StopIteration("限制你")
        n = self.start
        self.start+=1
        return n
f = Range(1,10)
for i in f:  #其实for循环本身就自带控制技能，遍历完最大数，即结束
    print(i)

四，__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Open:
    def __init__(self,filepath,mode="r",encode="utf-8"):
        self.f = open(filepath,mode=mode,encoding=encode)
    def write(self,value):
        self.f.write(value)

    def __getattr__(self, item):
        return getattr(self.f,item)
    def __del__(self):
        print(".....处罚我")
        self.f.close()  #关闭文件
a = Open("a.txt","w")  #实例化的 传完值自动触发__del__运行

a.write("1111111111
")  #已经把内容写入进a.txt了
a.write("2222222222
")
16 #a.txt中内容：

       1111111111
       2222222222
       2222222222

五，上下文管理协议：__enter__ 和 __exit__

1操作文件有两种写法

f = open("a.txt","r")
f.read()
f.close() #关闭文件

2，前者需要自己关闭文件，下面这种with语句，自动在你处理完文件时关闭

with open("a.txt","r") as f:
    f.read()


#自动在后台偷偷的关闭文件了

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

import time

class Open:
    def __init__(self,filepath,m="r",endcode="utf8"):
        self.x = open(filepath,mode=m,encoding = endcode)

        self.filepath = filepath
        self.m = m
        self.encoding = endcode

    def write(self,line):
        t = time.strftime("%Y-%m-%d %X")  #年月日格式，当前时间
        self.x.write("%s %s"%(t,line))  #把字符串和时间 写入self.x中

    def __getattr__(self, item):  #
        return getattr(self.x,item)

    def __enter__(self):  #看这里
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):    #看这里
        self.x.close()

with Open("b.txt","w") as f:
    f.write("111111111
")
    f.write("111111111
")
    f.write("111111111
")
    f.write("111111111
")
    f.write("111111111
")

六，__call__

# 对象后面加括号，触发执行。
# 注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；
# 而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
    def __init__(self):
        pass
    def __call__(self, *args, **kwargs):
        print("执行我")

a = Foo()   # 执行__init__方法
a()   # 对象()  执行__call__   #执行结果：  执行我

七，元类：

python中一切皆是对象，类本身也是一个对象，当使用关键字class的时候，python解释器在加载class的时候就会创建一个对象(这里的对象指的是类而非类的实例)

下例可以看出f1是由Foo这个类产生的对象，而Foo本身也是对象，那它又是由哪个类产生的呢？

class Foo:  #这是通过关键字class 创建类
    pass

f1 = Foo()  #f1是Foo类实例化的对象
# type函数可以查看类型，也可以用来查看对象的类，二者是一样的
print(type(Foo)) #<class 'type'>
print(type(f1)) #<class '__main__.Foo'> f1是Foo实例化的对象

元类是类的类，是类的模板

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

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

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

1，创建类的两种方式

方式一：

#方式1，关键字class
class Bar:
    x = 1
    def __init__(self,name):
        self.name = name
    def run(self):
        pass
f = Bar("a")
print(Bar.__dict__)
#类名称空间的字典
#{'__module__': '__main__', 'x': 1, '__init__': <function Bar.__init__ at 0x00000000021EAA60>,
#  'run': <function Bar.run at 0x00000000021EAAE8>, 
# '__dict__': <attribute '__dict__' of 'Bar' objects>, '__weakref__': <attribute '__weakref__'
#  of 'Bar' objects>, '__doc__': None}

 

方式二：

#type称为元类，是所有类的类，利用type模拟class关键字的创建类的过程
#
def run(self):
    pass
class_name = "Bar"  # 模拟类名
bases = (object,)    #继承类
class_dict={"x":1,"name":"a","run":run} #类的名称空间的字典
Bar = type(class_name,bases,class_dict)   #创建类  必须有，类名，继承类，类名称空间的字典，缺一不可
print(Bar)  #<class '__main__.Bar'>
print(Bar.__dict__)
11  # 类的名称空间
#{'x': 1, 'name': 'a', 'run': <function run at 0x00000000026EA950>, 
# '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Bar' objects>,
#  '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None}

2，用元类，限制子类必须写__doc__ 

class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dict):

        type.__init__(self,class_name,class_bases,class_dict)
        for key in class_dict:
            if not callable(class_dict[key]):
                continue
            if not class_dict[key].__doc__:
                raise TypeError("你没写注释，抓紧去写")

class Foo(metaclass=Mymeta):
    x = 1
    def run(self):
        '''run方法'''
        print("running")
# f = Foo()
print(Foo.__dict__)