面向对象之内置方法

Posted featherwit

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象之内置方法相关的知识,希望对你有一定的参考价值。

Python类的内置方法总结

内置方法 描述
__new__() 类的真正的构造方法, 用于产生对象(空属性)
__init__() 初始化对象, 在创建对象的时候调用
__str__() 控制用户显示, 即在print()的时候显示
__repr__() 控制调试显示, 在调试模式下显示的内容
__call__() 把实例对象作为函数调用
__del__() 当对象的引用计数为0时自动调用
__iter__() 用于将一个对象模拟成序列
__next__() 用于将一个对象模拟成序列, 便于遍历
__getitem__() 模拟对象成列表或者是字典, 获取元素
__setitem__() 模拟对象成列表或者是字典, 设置元素
__delitem__() 模拟对象成列表或者是字典, 删除元素
__getattr__() 当访问对象的一个不存在的属性时触发 
__setattr__() 当设置对象属性的时候触发
__delattr__() 当删除对象属性的时候触发
__getattribute__() 获取属性时调用
__enter__() with的时候触发
__exit__() 离开with的时候触发

 

__new__()、__init__()

__new__方法是真正的类构造方法,用于产生实例化对象(空属性), 重写__new__方法可以控制对象的产生过程。
__init__方法是初始化方法,负责对实例化对象进行属性值初始化,此方法必须返回None,__new__方法必须返回一个对象。重写__init__方法可以控制对象的初始化过程。

# 使用new来处理单例模式
class Student:
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def sleep(self):
        print(sleeping...)

stu1 = Student()
stu2 = Student()

print(id(stu1), id(stu2))  # 两者输出相同
print(stu1 is stu2)  # True

 

__str__()、__repr__()

两者的目的都是为了显式的显示对象的一些必要信息,方便查看和调试。__str__print默认调用,__repr__被控制台输出时默认调用。即,使用__str__控制用户展示,使用__repr__控制调试展示。

# 默认所有类继承object类,object类应该有一个默认的str和repr方法,打印的是对象的来源以及对应的内存地址
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

stu = Student(zlw, 26)
print(stu)  # <__main__.Student object at 0x0000016ED4BABA90>
# 自定义str来控制print的显示内容,str函数必须return一个字符串对象
# 使用repr = str来偷懒控制台和print的显示一致

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f{self.__class__}, {self.name}, {self.age}
    
    __repr__ = __str__

stu = Student(zlw, 26)
print(stu)  # <class ‘__main__.Student‘>, zlw, 26

 

__call__()

__call__方法提供给对象可以被执行的能力,就像函数那样,而本质上,函数就是对象,函数就是一个拥有__call__方法的对象。拥有__call__方法的对象,使用callable可以得到True的结果,可以使用()执行,执行时,可以传入参数,也可以返回值。所以我们可以使用__call__方法来实现实例化对象作为装饰器:

# 检查一个函数的输入参数个数, 如果调用此函数时提供的参数个数不符合预定义,则无法调用。

# 单纯函数版本装饰器
def args_num_require(require_num):
    def outer(func):
        def inner(*args, **kw):
            if len(args) != require_num:
                print(函数参数个数不符合预定义,无法执行函数)
                return None

            return func(*args, **kw)
        return inner
    return outer

@args_num_require(2)
def show(*args):
    print(show函数成功执行!)

show(1)  # 函数参数个数不符合预定义,无法执行函数
show(1,2) # show函数成功执行!
show(1,2,3)  # 函数参数个数不符合预定义,无法执行函数
# 检查一个函数的输入参数个数,
# 如果调用此函数时提供的参数个数不符合预定义,则无法调用。

# 实例对象版本装饰器
class Checker:
    def __init__(self, require_num):
        self.require_num = require_num

    def __call__(self, func):
        self.func = func

        def inner(*args, **kw):
            if len(args) != self.require_num:
                print(函数参数个数不符合预定义,无法执行函数)
                return None

            return self.func(*args, **kw)
        return inner

@Checker(2)
def show(*args):
    print(show函数成功执行!)

show(1)  # 函数参数个数不符合预定义,无法执行函数
show(1,2) # show函数成功执行!
show(1,2,3)  # 函数参数个数不符合预定义,无法执行函数

 

__del__()

__del__用于当对象的引用计数为0时自动调用。
__del__一般出现在两个地方:1、手工使用del减少对象引用计数至0,被垃圾回收处理时调用。2、程序结束时调用。
__del__一般用于需要声明在对象被删除前需要处理的资源回收操作

# 手工调用del 可以将对象引用计数减一,如果减到0,将会触发垃圾回收

class Student:

    def __del__(self):
        print(调用对象的del方法,此方法将会回收此对象内存地址)

stu = Student()  # 调用对象的__del__方法回收此对象内存地址

del stu

print(下面还有程序其他代码)
class Student:

    def __del__(self):
        print(调用对象的del方法,此方法将会回收此对象内存地址)

stu = Student()  # 程序直接结束,也会调用对象的__del__方法回收地址

 

__iter__()、__next__()

这2个方法用于将一个对象模拟成序列。内置类型如列表、元组都可以被迭代,文件对象也可以被迭代获取每一行内容。重写这两个方法就可以实现自定义的迭代对象。

# 定义一个指定范围的自然数类,并可以提供迭代

class Num:
    def __init__(self, max_num):
        self.max_num = max_num
        self.count = 0
        
    def __iter__(self):
        return self

    def __next__(self):
        if self.count < self.max_num:
            self.count += 1
            return self.count
        else:
            raise StopIteration(已经到达临界)
        
num = Num(10)
for i in num:
    print(i)  # 循环打印1---10

 

__getitem__()、__setitem__()、__delitem__()

重写此系列方法可以模拟对象成列表或者是字典,即可以使用key-value的类型。

class StudentManager:
    li = []
    dic = {}

    def add(self, obj):
        self.li.append(obj)
        self.dic[obj.name] = obj

    def __getitem__(self, item):
        if isinstance(item, int):
            # 通过下标得到对象
            return self.li[item]
        elif isinstance(item, slice):
            # 通过切片得到一串对象
            start = item.start
            stop = item.stop
            return [student for student in self.li[start:stop]]
        elif isinstance(item, str):
            # 通过名字得到对象
            return self.dic.get(item, None)
        else:
            # 给定的key类型错误
            raise TypeError(你输入的key类型错误!)

class Student:
    manager = StudentManager()

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

        self.manager.add(self)

    def __str__(self):
        return f学生: {self.name}

    __repr__ = __str__


stu1 = Student(小明)
stu2 = Student(大白)
stu3 = Student(小红)
stu4 = Student(胖虎)

# 当做列表使用
print(Student.manager[0])  # 学生: 小明
print(Student.manager[-1])  # 学生: 胖虎
print(Student.manager[1:3])  # [学生: 大白, 学生: 小红]

# 当做字典使用
print(Student.manager[胖虎])  # 学生: 胖虎

 

__getattr__()、__setattr__()、__delattr__()

当使用obj.x = y的时候触发对象的setattr方法,当del obj.x的时候触发对象的delattr方法。
当尝试访问对象的一个不存在的属性时 obj.noexist 会触发getattr方法,getattr方法是属性查找中优先级最低的。

特别注意:如果定义了getattr,而没有任何代码(即只有pass),则所有不存在的属性值都是None而不会报错, 可以使用super().getattr()方法来处理该问题

class Student:
    def __getattr__(self, item):
        print(访问一个不存在的属性时候触发)
        return 不存在

    def __setattr__(self, key, value):
        print(设置一个属性值的时候触发)
        # self.key = value  # 这样会无限循环
        self.__dict__[key] = value

    def __delattr__(self, item):
        print(删除一个属性的时候触发)
        if self.__dict__.get(item, None):
            del self.__dict__[item]

stu = Student()
stu.name = zlw  # 设置一个属性值的时候触发
print(stu.noexit)  # 访问一个不存在的属性时候触发 , 返回‘不存在‘
del stu.name  # 删除一个属性的时候触发

 

__getattribute__()

这是一个属性访问截断器,即,在你访问属性时,这个方法会把你的访问行为截断,并优先执行此方法中的代码,此方法应该是属性查找顺序中优先级最高的。

class People:
    a = 200

class Student(People):
    a = 100

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

    def __getattr__(self, item):
        print(没有找到:, item)

    def __getattribute__(self, item):
        print(属性访问截断器)
        if item == a:
            return 1
        return super().__getattribute__(item)

stu = Student(1)
print(stu.a)  # 1

 

__enter__()、__exit__()

这两个方法的重写可以让我们对一个对象使用with方法来处理工作前的准备,以及工作之后的清扫行为。

class mysql:
    def connect(self):
        print(启动数据库连接,申请系统资源)

    def execute(self):
        print(执行sql命令,操作数据)

    def finish(self):
        print(数据库连接关闭,清理系统资源)

    def __enter__(self):  # with的时候触发,并赋给as变量
        self.connect()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):  # 离开with语句块时触发
        self.finish()

with MySQL() as mysql:
    mysql.execute()
    
# 结果:
# 启动数据库连接,申请系统资源
# 执行sql命令,操作数据
# 数据库连接关闭,清理系统资源

 

以上是关于面向对象之内置方法的主要内容,如果未能解决你的问题,请参考以下文章

python 面向对象进阶之内置方法

面向对象之反射及内置方法

Python之面向对象:类的内置方法

Python学习第14篇:面向对象之反射以及内置方法

面向对象之内置方法续集

面向对象之isinstance与issubclass(python内置方法)