Python面向对象进阶之高级编程

__slots__:定义类时,使用__slots__变量可以限制能添加的实例的属性

形如:__slots__ = ['name','age']

这样实例化的对象只能绑定到name和age属性,其他属性则无法被绑定

1
2
3
4
5
6
7
8
9
class People:
    __slots__ = ['name','age']
    def __init__(self,name,age):
        self.name = name
        self.age = age
= People('laowang',18)
print(p.name)
p.sex = 'male'
print(p.sex)

执行结果:

1
2
3
4
5
6
7
8
9
laowang
 
Traceback (most recent call last):
 
  File "C:/", line 43in <module>
 
    p.sex = 'male'
 
AttributeError: 'People' object has no attribute 'sex'

可以看出name属性初始化成功并且可以访问,但是sex属性无法添加

 

 

__call__方法:只要定义类型的时候,实现__call__函数,这个类型就成为可调用的

1
2
3
4
5
6
7
8
9
10
11
class People:
    def __init__(self,name):
        self.name=name
    #
    def __call__(self*args, **kwargs):
        print('call')
    #
p=People('egon')
print(callable(People))
print(callable(p))
p()

执行结果为:

True

True

call

意味着People及其产生的对象均为可调用的,并且:对象()会执行__call__方法

 

__getitem__、__setitem__、__delitem__方法:提供以字典的方式操作对象属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Foo:
    def __init__(self,name):
        self.name=name
    def __getitem__(self, item):
        # print('getitem',item)
        return self.__dict__[item]
    def __setitem__(self, key, value):
        print('setitem-----<')
        self.__dict__[key]=value
    def __delitem__(self, key):
        self.__dict__.pop(key)
        # self.__dict__.pop(key)
    # def __delattr__(self, item):
    #     print('del obj.key时,我执行')
    #     self.__dict__.pop(item)
f=Foo('egon')
f['name']='egon'
print(f.name)
f['age']=18
print(f.__dict__)
del f['age']

 

__iter__、__next__方法:可以实现一个迭代器协议,类定义中加入这两个方法可以将类实例化的对象变为可迭代的对象

需要注意下的就是__next__中必须控制iterator的结束条件,不然就死循环了

下例利用此原理实现了一个简单的range()函数的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Range:
    def __init__(self,start,stop):
        self.start = start
        self.stop = stop
        pass
    def __iter__(self):
        return self
    def __next__(self):
        if self.start >= self.stop:
            raise StopIteration
        = self.start
        self.start += 1
        return n
 
for in Range(1,10):
    print(i)

 

__del__方法:析构函数,当对象在内存中被释放时,自动触发执行

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Open:
    def __init__(self,filepath,mode='r',encode='utf-8'):
        self.f=open(filepath,mode=mode,encoding=encode)
    def write(self):
        pass
    def __getattr__(self, item):
        return getattr(self.f,item)
    def __del__(self):
        print('----->del')
        self.f.close()
f=Open('a.txt','w')
f1=f
del f
print('=========>')

 

__enter__、__exit__方法:实现上下文管理协议,即with语句,这个跟文件操作时使用with语句一样:

1
2
with open('filepath/filename','r',encoding='utf-8') as f:
        '代码块'

在类定义时定义__enter__、__exit__方法可以让类产生的对象使用with语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Foo:
    def __enter__(self):
        print('=====》enter')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit')
        print('exc_type',exc_type)
        print('exc_val',exc_val)
        print('exc_tb',exc_tb)
        return True
 
with Foo() as obj: #res=Foo().__enter__() #obj=res
    print('with foo的自代码块',obj)
    raise NameError('名字没有定义')
    print('************************************')
print('------>')

 __exit__()中的三个参数分别代表异常类型,异常值和追溯信息,with语句中代码块出现异常,则with后的代码都无法执行,但是__exit__如果有返回值,则with语句块之外的代码可以正常执行

 

__str__方法:当类的方法被调用时,会调用此方法返回一个字符串(为了好看与打印相关重要信息)

 

 

元类:

 

关于元类的详细讲解可参阅此文:深刻理解Python中的元类(metaclass)



本文转自 AltBoy 51CTO博客,原文链接:http://blog.51cto.com/altboy/1919295

上一篇:【线上直播】智能推荐系列公开课——让产品价值最大化


下一篇:Python画画turtle库初级、中级、高级详解