Python——魔法方法

已于 2023-02-17 22:50:07 修改
阅读量449 收藏 3
点赞数 1
文章标签： python 开发语言
于 2023-02-04 14:03:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66881249/article/details/128878537
版权

Python魔法方法

魔法方法

基本介绍

魔法方法的官方名称为special method，指的是Python自带的，具有强大功能的，在一些特定情况下会被自动调用的方法，方法名一般以两个下划线开始，并且以两个下划线结束，Python中大致有100多个魔法方法

具体方法讲解

1.call（）

自动被调用的场景
具有该方法的类对应的实例对象被调用时，自动调用该方法

作用
使得一个自定义的实例对象可以像函数那样被调用

案例

class C:
    def __call__(self, data):       #定义魔法方法__call__
        print('__call__方法被调用')
        print(data)

ins = C()
ins(10)     #通过调用实例对象，自动调用__call__方法

#输出结果：
"""
__call__方法被调用
10
"""

2.enter（）

自动被调用的场景
与上下文管理语句（with语句）联合使用，在上下文管理器创建以后，自动调用上下文管理器的该方法

作用
在上下文管理语句中实现资源的访问

案例

class C:
    def __init__(self):
        self.data = 10

    def __enter__(self):		#定义魔法方法__enter__
        print('__enter__方法被调用')
        return self				#将实例对象本身返回

    def __exit__(self, *args):	#定义魔法方法__exit__
        print('__exit__方法被调用', *args)

with C() as ins:		#通过上下文管理语句，在特定时刻自动调用__enter__和__exit__
    print(ins.data)

#输出结果：
"""
__enter__方法被调用
10
__exit__方法被调用 None None None
"""

2.exit（）

自动被调用的场景
与上下文管理语句（with语句）联合使用，在上下文关联语句代码块执行完毕后，自动调用上下文管理器的该方法

作用
在上下文管理语句中实现资源的关闭，并且可以获取异常的相关信息

值得注意的是如果__exit__配合上下文管理语句使用，必须要设置三个形参（除了self以外的三个形参），用来接收自动传入的三个异常的相关信息

__exit__ 方法中有三个形参，从左往右依次为exc_type（接收异常类型），exc_val（接收异常值），exc_tb（接收异常回溯追踪信息），即这三个形参用来接收处理异常，如果代码在运行时发生异常，异常会被保存到这里

案例

class C:
    def __init__(self):
        self.data = 10

    def __enter__(self):		#定义魔法方法__enter__
        print('__enter__方法被调用')
        return self				#将实例对象本身返回

    def __exit__(self, *args):	#定义魔法方法__exit__
        print('__exit__方法被调用', *args)

with C() as ins:		#通过上下文管理语句，在特定时刻自动调用__enter__和__exit__
    print(ins.data)

#输出结果：
"""
__enter__方法被调用
10
__exit__方法被调用 None None None
"""

3.new（）

自动被调用的场景
在要创建一个实例对象的时候，被自动调用（调用时会自动传入类对象以及在代码"ins = C(指定的实参)"中指定的实参）

作用
创建一个实例对象

值得一提的是__new__方法的返回值就是最后得到的ins，即两者的引用相同

案例

class C:
    def __new__(cls):       #重写魔法方法__new__
        print('__new__方法被调用')
        print(cls)
        ins = super().__new__(cls)      #调用父类的__new__方法创建实例对象
        print(ins)
        return ins          #返回实例对象

ins = C()       #通过实例化对象的操作，自动调用__new__方法
print(ins)

#输出结果：
"""
__new__方法被调用
<class '__main__.C'>
<__main__.C object at 0x0000020B2EA2ADC0>
<__main__.C object at 0x0000020B2EA2ADC0>
"""

class C:
    def __new__(cls):       #重写魔法方法__new__
        print('__new__方法被调用')
        return 123

ins = C()
print(ins)

#输出结果：
"""
__new__方法被调用
123
"""

class C:
    def __new__(cls, data):         #会自动传入类对象和123
        print('__new__方法被调用')
        print(data)
        return super().__new__(cls)

ins = C(123)

#输出结果：
"""
__new__方法被调用
123
"""

4.init（）

自动被调用的场景
_new__方法调用结束后，在_new__方法返回的是本类对象对应的实例对象的时候，会自动调用__init__方法（调用时会自动传入__new__方法返回的实例对象以及在代码"ins = C(指定的实参)"中指定的实参）

作用
对通过__new__方法创建的实例对象进行初始化（比如为该实例对象创建实例属性）

案例

class C:
    def __new__(cls):       
        print('__new__方法被调用')
        ins = super().__new__(cls)
        print(ins)
        return ins

    def __init__(self):     #重写魔法方法__init__
        print('__init__方法被调用')
        print(self)

ins = C()       #通过实例化对象的操作，自动调用__init__方法
print(ins)

#输出结果：
"""
__new__方法被调用
<__main__.C object at 0x00000185ABF3ADC0>
__init__方法被调用
<__main__.C object at 0x00000185ABF3ADC0>
<__main__.C object at 0x00000185ABF3ADC0>
"""

class C:
    def __new__(cls):       
        print('__new__方法被调用')
        return 123		#当__new__的返回值不是类对象C对应的实例对象的时候，不会自动调用__init__方法

    def __init__(self):		
        print('__init__方法被调用')

ins = C()
print(ins)

#输出结果：
"""
__new__方法被调用
123
"""

class C:
    def __new__(cls, data):       
        print('__new__方法被调用')
        print('__new__方法的', data)
        ins = super().__new__(cls)
        return ins

    def __init__(self, data):       #会自动传入__new__返回的实例对象和123
        print('__init__方法被调用')
        print('__init__方法的', data)
        self.data = data			#为实例对象创建一个实例属性


ins = C(123)
print(ins.data)

#输出结果：
"""
__new__方法被调用
__new__方法的 123
__init__方法被调用
__init__方法的 123
123
"""

__new__方法与__init__方法

一整个创建实例对象的过程

  • 先自动调用__new__方法
    • 如果__new__方法的返回值为一个该类对象对应的实例对象，则自动调用__init__方法，对这个实例对象进行初始化
    • 如果__new__方法的返回值不是一个该类对象对应的实例对象，则不会自动调用__init__方法，直接进行赋值操作（这种情况只会出现在把__new__方法重写的情况下，一般不会这么干）
  • 最后才会执行语句"实例对象 = 类（）"中的赋值操作

值得一提的是创建实例对象的过程中，在代码"ins = C(指定的实参)"中指定的实参会自动传入__new__方法与__init__方法中（如果方法被自动调用的话）

5.iter（）

自动被调用的场景
对该对象调用iter函数的时候，会被自动调用

作用
在类中定义了__iter__方法，这个类创建出来的对象就是一个可迭代对象，该方法必须返回一个迭代器，具体的案例请移步Python——迭代器

案例

class C:
    def __iter__(self):         #定义魔法方法__iter__
        print('__iter__方法被调用')
        return iter([1, 2])     #__iter__必须要返回一个迭代器对象，否则会抛出异常


ins = C()
iter(ins)       #通过对该对象调用iter函数自动调用__iter__

#输出结果：__iter__方法被调用

from collections.abc import Iterable

class C1:
    def __iter__(self):		#定义魔法方法__iter__
        pass

class C2:
    pass

ins1 = C1()
ins2 = C2()
print(isinstance(ins1, Iterable))
print(isinstance(ins2, Iterable))

#输出结果：
"""
True
False
"""

6.next（）

自动被调用的场景
对该对象调用next函数的时候，会被自动调用

作用
在类中同时定义了__iter__方法和__next__方法，这个类创建出来的对象就是一个迭代器，一般来说，该方法需要返回迭代器中的数据，具体的案例请移步Python——迭代器

案例

class C:
    def __next__(self):         #定义魔法方法__next__
        print('__next__方法被调用')


ins = C()
next(ins)       #通过对该对象调用next函数自动调用__next__

#输出结果：__next__方法被调用

from collections.abc import Iterator

class C1:
    def __iter__(self):
        pass

    def __next__(self):		#定义魔法方法__next__
        pass

class C2:
    pass

ins1 = C1()
ins2 = C2()
print(isinstance(ins1, Iterator))
print(isinstance(ins2, Iterator))

#输出结果：
"""
True
False
"""

7.str（）

自动被调用的场景
在某些需要将对象转为字符串的时候被自动调用，比如打印的时候、将在格式化字符串中将对象转化为字符串的时候

作用
不对该方法进行重写，会打印（或者将对象转化为）<模块名.类名 object at 对象id> ，如果进行了重写，会打印（或者将对象转化为）__str__方法的返回值

值得注意的是__str__返回值必须为字符串类型对象，否则会引发异常

案例

class C:
    def __init__(self, data):
        self.data = data

ins = C(10)
print(ins)          #不重写__str__方法就会输出<模块名.类名 object at 对象id>

#输出结果：<__main__.C object at 0x0000024CC5DAA850>

class C:
    def __init__(self, data):
        self.data = data

    def __str__(self):              #重写魔法方法__str__
        print('__str__方法被调用')
        return  str(self.data)      #__str__必须要返回一个字符串对象，否则会抛出异常


ins = C(10)
print(ins)          #通过打印实例对象，自动调用__str__

#输出结果：
"""
__str__方法被调用
10
"""

class C:
    def __init__(self, data):
        self.data = data

    def __str__(self):              #重写魔法方法__str__
        print('__str__方法被调用')
        return  str(self.data)      #__str__必须要返回一个字符串对象，否则会抛出异常


ins = C(10)
print(f'{ins}')          #通过将实例对象转化为字符串对象，自动调用__str__

#输出结果：
"""
__str__方法被调用
10
"""

8.getitem（）

自动被调用的场景
在使用索引获取数据的时候，会被自动调用

作用
使得对象可以通过下标取出数据

值得注意的是要设置一个形参接收指定的下标值

案例

class C:
    def __init__(self):
        self.lst = [1, 2, 3, 4]

    def __getitem__(self, key):		#定义魔法方法__getitem__
        print('__getitem__方法被调用')
        return self.lst[key]

ins = C()
print(ins[1])

#输出结果：
"""
__getitem__方法被调用
2
"""

class C:
    def __init__(self):
        self.dct = {'a':1, 'b':2, 'c':3, 'd':4}

    def __getitem__(self, key):		#定义魔法方法__getitem__
    	print('__getitem__方法被调用')
        return self.dct[key]

ins = C()
print(ins['b'])

#输出结果：
"""
__getitem__方法被调用
2
"""

9.setitem（）

自动被调用的场景
在使用索引修改（或创建）数据的时候，会被自动调用

作用
使得对象可以通过下标修改（或创建）数据

值得注意的是要设置两个形参分别接收指定的下标值和数据

案例

class C:
    def __init__(self):
        self.dct = {'a':1, 'b':2, 'c':3, 'd':4}

    def __setitem__(self, key, value):		#定义魔法方法__setitem__
        self.dct[key] = value

ins = C()
print(ins.dct)
ins['b'] = 20
print(ins.dct)

#输出结果：
"""
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
__setitem__方法被调用
{'a': 1, 'b': 20, 'c': 3, 'd': 4}
"""

class C:
    def __init__(self):
        self.dct = {'a':1, 'b':2, 'c':3, 'd':4}

    def __setitem__(self, key, value):		#定义魔法方法__setitem__
        print('__setitem__方法被调用')
        self.dct[key] = value

ins = C()
print(ins.dct)
ins['e'] = 5
print(ins.dct)

#输出结果：
"""
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
__setitem__方法被调用
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
"""

10.delitem（）

自动被调用的场景
在使用索引删除数据的时候，会被自动调用

作用
使得对象可以通过下标删除数据

值得注意的是要设置一个形参接收指定的下标值

案例

class C:
    def __init__(self):
        self.dct = {'a':1, 'b':2, 'c':3, 'd':4}

    def __delitem__(self, key):		#定义魔法方法__delitem__
        print('__delitem__方法被调用')
        del self.dct[key]

ins = C()
print(ins.dct)
del ins['a']
print(ins.dct)

#输出结果：
"""
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
__delitem__方法被调用
{'b': 2, 'c': 3, 'd': 4}
"""

11.getattribute（）（属性访问拦截器）

自动被调用的场景
在要进行任何属性（无论该属性是否存在，无论是访问实例属性还是类属性）（此处的属性也包括了方法）的访问时，都会自动调用

作用
如果对该方法进行了重写，则返回值作为属性访问得到的结果值，如果对应的类对象中没有定义该方法，则正常返回所访问的属性

通过该方法，可以实现对所要访问的属性进行检测，针对不同的属性，进行不同的操作，从而实现对某一部分特殊属性访问的拦截
在实际应用中，该方法可以实现对某一个属性被访问次数和具体访问时间的记录

值得注意的是要设置一个形参接收所要访问的属性名（一个字符串类型对象）

案例

class C:
    def __init__(self):
        self.data_1 = 10
        self.data_2 = 20

    def __getattribute__(self, name):           #重写__getattribute__方法
        print('__getattribute__方法被调用')
        if name == 'data_1':              #当要访问的属性名为'data_1'，允许访问
            return super().__getattribute__(name)		#通过调用父类的同名方法，返回数据
        else:                             #当要访问的属性名为'data_2'，不允许访问
            return '该属性无法被访问'

ins = C()
print(ins.data_1)
print(ins.data_2)

#输出结果：
"""
__getattribute__方法被调用
10
__getattribute__方法被调用
该属性无法被访问
"""

12.getattr（）

自动被调用的场景
与__getattribute__类似，只不过魔法方法__getattribute__对所有的属性（无论是否存在）都会进行拦截（即__getattribute__为全部拦截），而魔法方法__getattr__只会对一个不存在属性（即实例对象中、类对象中、父类中…都没有该同名属性）进行访问的时候会被自动调用（即__getattr__为部分拦截）

作用
如果对该方法进行了重写，则返回值作为属性访问得到的结果值，如果对应的类对象中没有定义该方法，则抛出异常

在实际应用中，该方法可以实现对所要访问的不存在属性的时间和该属性名进行记录

值得注意的是要设置一个形参接收所要访问的属性名（一个字符串类型对象）而且__getattr__和__getattribute__同时使用的时候，只会触发__getattribute__

案例

class C:
    def __init__(self):
        self.data_1 = 10

    def __getattr__(self, name):          #定义__getattr__方法
        print('__getattr__方法被调用')
        return '该属性不存在'

ins = C()
print(ins.data_1)
print(ins.data_2)

#输出结果：
"""
10
__getattr__方法被调用
该属性不存在
"""

class C:
    def __init__(self):
        self.data_1 = 10

    def __getattribute__(self, name):
        print('__getattribute__方法被调用')     
        if name == 'data_1':
            return super().__getattribute__(name)
        else:
            return '该属性不存在'

    def __getattr__(self, name):          #定义__getattr__方法
        print('__getattr__方法被调用')
        return '该属性不存在'

ins = C()
print(ins.data_1)
print(ins.data_2)

#输出结果：
"""
__getattribute__方法被调用
10
__getattribute__方法被调用
该属性不存在
"""

13.del（）

自动被调用的场景
当一个对象被回收的时候，会被自动调用

作用
在一个对象被回收的时候，

这个方法的调用时刻是不好判断的，因为一个对象的引用计数为0的时候会自动被回收，但是使得引用计数增加或者减少的方法有很多

值得注意的是__del__并不是在执行del的时候被自动调用的，即del操作与__del__关联性不大，del操作仅仅就是减少引用计数而已

案例

class C:
    def __init__(self):
        self.data_1 = 10

    def __del__(self):		#定义魔法方法__del__
        print('__del__方法被调用')
    
ins = C()		#此时实例对象的引用计数为1
a = ins			#此时实例对象的引用计数为2

del ins			#此时实例对象的引用计数为1
print('del操作结束')

#最后程序运行结束，所有对象都被回收，自动调用__del__

#输出结果：
"""
del操作结束
__del__方法被调用
"""

class C:
    def __init__(self):
        self.data_1 = 10

    def __del__(self):
        print('__del__方法被调用')
    
ins = C()		#此时实例对象的引用计数为1
a = ins			#此时实例对象的引用计数为2

del ins			#此时实例对象的引用计数为1
del a			#此时实例对象的引用计数为0，对象被回收，自动调用__del__
print('del操作结束')

#输出结果：
"""
__del__方法被调用
del操作结束
"""
林浩233
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python的魔法方法
zhongguo_boy的博客
02-25 325
python中的魔法方法是一些可以让你对类添加“魔法”的特殊方法，它们经常是两个下划线包围来命名的，比如 __init__, __call__。魔法方法可以使Python的自由度变得更高，在面向对象方面表现的更好。 python有很多魔法方法，根据其作用和特点，归纳总结为以下几类
Python——魔法方法：迭代器
Sam's blog
08-06 144
alist = range(5) it = iter(alist) while True: try: print(next(it)) except StopIteration: break import datetime as dt class LeapYear: def __init__(self): self.now = dt.date.today().year de...
python魔法方法详解
爆笑蛙的博客
08-08 1378
本文详细介绍了python中的魔法方法，每一个魔法方法都用代码举例说明了它的使用方式，你可以直接复制粘贴到你的py文件中运行，以便于观察它们的使用方式。魔法方法主要分为构造类、描述类、运算类、描述符、容器类、迭代器、上下文管理、类型转换、序列化。
python进阶（九）：魔法方法
w1101662433的博客
06-24 239
魔法方法是一种特殊的方法，可以让我们自定义类的行为，并与内置函数和运算符进行交互。通过合理地使用魔法方法，你可以编写灵活和易用的类。
20个超实用Python魔法方法
最新发布
wenjie20070212的博客
03-28 1148
以上就是Python中的20个魔法方法，掌握它们，你的编程之旅将会充满惊奇与乐趣，让你的代码更加生动灵活。记得，在合适的场景下巧妙运用这些魔法方法，会让你的Python程序拥有超乎想象的力量！它们就像是编程中的魔法咒语，赋予你的类各种神奇特性，让你的代码更加简洁、强大且有趣味！等运算符重载方法：想象你在编写一个自定义的数字类型，让它们可以像普通数字那样进行加减乘除，这些魔法方法就是实现这个目标的关键。：这两个小兄弟负责将对象变成易于理解的字符串形式，前者用于友好的显示，后者则是面向开发者更详尽的表示。
Python基础——魔法方法（一）
热门推荐
薛定谔的猫的博客
07-07 1万+
Python中的魔法方法
Python中最全魔术方法整理
GMH的博客
01-30 2391
在Python中set集合要求数据类型是可哈希的，因为set集合会默认调用对象的__hash__函数进行快速查询，如果找到了则调用对象的__eq__判断两个是是否相同，如果相同则不添加。如果抛出AttributeError异常，则会直接调用__getattr__方法，因为属性没有找到，__getattribute__方法中为了避免在该方法中无限递归，它的实现应该永远调用基类的同名方法以访问需要的任何属性。__call__()方法可以让类的实例具有类似于函数的行为，这进一步模糊了函数和对象之间的概念。
【python剑与魔法-密码】来了！！！
07-07
【python剑与魔法——密码】来了！！！
python高阶：魔法函数（csdn）————程序.pdf
12-03
python高阶：魔法函数（csdn）————程序
python海龟画图爱心代码
01-23
我们为您带来了一个独特的Python资源——海龟画图工具包。这不仅仅是一段代码，它是您创造数字艺术的魔法棒，是打开计算机图形世界大门的钥匙。通过这个精心设计的工具包，无论您是编程新手还是资深爱好者，都能轻松...
【脚本编写-python】-剑与魔法来了!!!
07-07
提示：请先从cmd中下载easygui库(pip install easygui)密码请去https://download.csdn.net/download/2301_78386901/88014210了解
浅谈 Python 魔法函数 __getattr__ 与 __getattribute__
12-21
——《雪中悍刀行》 __getattr__魔法函数 _getattr_ 魔法函数是在你试图访问一个不存在的属性时调用的。 如果没有这个魔法函数，访问不存在的属性程序会报错。 from datetime import date cla
Python魔术方法大全
记录学习路上的一些拙见
08-21 1285
在Python中，所有以“__”双下划线包起来的方法，都统称为“Magic Method”（魔术方法）,例如类的初始化方法 __init__ ,Python中所有的魔术方法均在官方文档中有相应描述，这边给大家把所有的魔术方法汇总了一下，希望对大家的学习有所帮助。
python的常用魔法方法详细总结
m0_59485658的博客
02-01 1335
在Python中，常见的容器类型有: dict, tuple, list, string。其中tuple, string是不可变容器，dict, list是可变容器。可变容器和不可变容器的区别在于，不可变容器一旦赋值后，不可对其中的某个元素进行修改。比如定义了和后, 执行l[0] = 0是可以的，但执行t[0] = 0则会报错。如果我们要自定义一些数据结构，使之能够跟以上的容器类型表现一样，那就需要去实现某些协议。
Python魔法方法
既然选择远方，便只顾风雨兼程！
10-19 2696
从入门到进阶，一个很重要的点就是Python中的魔法方法，魔法方法就是可以给你的类增加魔力的特殊方法，如果你的对象实现了这些方法中的某一个，那么这个方法就会在特殊的情况下被 Python 所调用，你可以定义自己想要的行为，而这一切都是自动发生的。它们经常是两个下划线包围来命名的（比如__init__/__new__等等），Python的魔法方法是非常强大的。
Python 魔法方法
qq_49873907的博客
04-18 409
Python中的魔法方法(Magic Methods)，也称为双下划线方法(Dunder Methods)，是特殊方法，其名称以双下划线开头和结尾，例如__init__、__str__、__add__等。这些方法提供了一种使Python对象能够使用内置函数和语言结构的方式。
python杂记——魔法方法
itlilyer的博客
02-08 6896
什么是魔法函数 python中有哪些魔法函数
【python】魔术方法大全——基础篇
bagell的博客
12-13 459
所谓魔法方法，它的官方的名字实际上叫，是Python的一种高级语法，允许你在类中自定义函数，并绑定到类的特殊方法中。比如在类A中自定义__str__()函数，则在调用str(A())时，会自动调用__str__()函数，并返回相应的结果。我们常常看到的这个名字，在官方的文档里是没有出现过的。当然无论是还是魔术方法，这些词都被广泛的使用着。所谓的魔术方法，是python提供的，让用户客制化一个类的方式，它顾名思义，就是定义在类里面的一些特殊的方法。
Python魔法方法总结
weixin_56175042的博客
06-20 210
本章主要介绍当前Python使用频率比较高的各种魔法方法，且为每个魔法方法都有对应的代码案例。
python——slots———
10-27
Python中的__slots__是一种用于限制类实例属性的方法。它可以让我们在定义类时，指定该类实例可以拥有的属性名称，从而限制了实例的属性数量和类型，提高了内存利用率和访问速度。使用__slots__可以将实例属性存储在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值