python进阶－面向对象编程五：类的内置方法

最新推荐文章于 2025-02-18 23:44:47 发布

weixin_34067049

最新推荐文章于 2025-02-18 23:44:47 发布

阅读量103

点赞数

CC 4.0 BY-SA版权

文章标签： python

原文链接：http://www.cnblogs.com/adamans/articles/7517506.html

本文深入探讨了Python中用于实现特定行为的特殊方法，包括__getitem__、__setitem__、__delitem__、__delattr__等用于操作对象属性的方法，__slots__用于节省内存的方法，以及__iter__、__next__等用于实现迭代器协议的方法。

类的使用本质是调用类的内置方法

getitem， setitem，delitem，delattr

# __getitem__， __setitem__，__delitem__，__delattr__
# 对象的属性进行获取、修改、删除时候触发的内置方法
class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value

    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f=Foo("adamander")
print(f.name)
print(f['name'])
f['age']=18
f['age1']=19

print(f['age'])
print(f.age1)
del f.age1
del f['age']

print(f.__dict__)

# 内置方法：slots

#使用类.xxx,或者对象.xxx,来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的字典是独立的)
#字典会占用大量的内存，如果有一个属性很少的类，但是实例很多的类，用__slots__来代替__dict__,限制对象属性数量，
# 对所有对象属性统一管理，
#节省内存.缺点是不能再给实例添加新属性,只能用里面有的。
class People:
    __slots__ = ['x','y','z']

p=People()
p.x=10
p.y=20
p.z=30
print(p.x,p.y,p.z)

#实现迭代器协议的内置方法：iter,next

#实现迭代器协议的内置方法：__iter__,__next__
from collections import Iterable,Iterator

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

    def __iter__(self):
        return self

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

f=Foo(0)
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))
print(next(f))


#一直不停的往下加
# for i in f:
#     print(i)


print("************************")

# 实现range类，next进行StopIteration处理

# 实现range类，__next__进行StopIteration处理
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

for i in Range(3, 8):
    print(i)

# r=Range(3,11)
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))
# print(next(r))

析构方法_del

# 析构方法___del__析构方法，当对象在内存中被释放时，自动触发执行。
# 注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，
# 因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
#垃圾回收机制，del 立即删除，不然等其他执行完毕，自动回收

import time
class Open:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        self.file=open(filename,mode,encoding=encoding)
    def __enter__(self):
        print("enter=====>")
        return self
    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)
    def __del__(self):
        print("===>del")

    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)
        self.file.close()

with Open('b.txt','w+') as f:
    f.write("xxxx")
    f.write("xxxx")
    f.write("xxxx")

# call实例调用

# __call__实例调用
# __call__实例调用，没有他，实例是不可调用的
class People:
    def __init__(self,name):
        self.name=name
    # def __call__(self, *args, **kwargs):
    #     pass


p=People("ada")
print(callable(People))
#True
print(callable(p))
#False,然而放开注释就是True

转载于:https://www.cnblogs.com/adamans/articles/7517506.html