首页 > 其他分享 >魔法方法

魔法方法

时间:2022-11-08 17:58:59浏览次数:38  
标签:__ obj name type self 魔法 print 方法

目录

面向对象魔法方法

定义:在类中定义的,以双下划线开头和结尾的方法,都称为魔法方法(例如:__init__)
特性:不需要人为调用,在特定的条件下会自动触发运行

__init__

触发:在通过类产生对象时触发。
用于给对象创建独有的属性。

class C(object):
    def __init__(self, name): # 在类产生对象时__init__默认运行
        self.name = name
        print('__init__')

obj = C('cloud')  # __init__
# __init__的运行还不是最早的 __init__具体执行时间后文元类部分再讲

__str__

触发:对象被执行打印操作的时候自动触发
要求:该方法的return后面返回值,会被打印。必须要有一个返回值 而且返回值必须是个字符串类型。
作用:用于区分不同的对象

# 1.错误使用
class C(object):
    def __str__(self):
        return 123  # 必须有返回值且返回值是字符串

obj = C()
print(obj)  # TypeError: __str__ returned non-string (type int)

# 2.正常使用
class C(object):
    def __str__(self):
        return '__str__'

obj = C()
print(obj)  # __str__

# 3.递归调用问题
class C(object):
    def __str__(self):
        print(self)  # 这里打印对象 会再次调用__str__
        return '递归调用'

obj = C()
print(obj)  # RecursionError: maximum recursion depth exceeded while calling a Python object

__call__

触发:当对象被加括号调用的时候
正常情况,对象是不能被调用的。给类加上这个魔术方法后,调用对象时就会执行__call__。
__call__方法有:*args 、**kwargs 形参用于接受从对象传入的参数。

class C(object):
    def __call__(self):
        print('from __call__')
        return 'back'

obj = C()
res = obj()  # from __call__
print(res)  # back

__getattr__ __getattribute__

先讲__getattr__。
触发:对象在查找一个无法使用的名字时自动触发

class C(object):
    def __init__(self, age):
        self.age = age
    def __getattr__(self, item):
        print('__getattr__', item)
        return f'名字不存在>>>{item}'

obj = C(18)
res = obj.cloud  # __getattr__ cloud  # 查找不存在的名字
print(res)  # 名字不存在>>>cloud

getattribute是getattr的老大。
触发:只要对象点名字就会自动触发 有它的存在就不会执行上面的__getattr__。会导致你访问不了名字 而是执行这个方法 并获得这个方法的返回值。

class C(object):
    def __init__(self, age):
        self.age = age
    def __getattribute__(self, item):
        print('hello')
        return 'back'

obj = C(18)
res = obj.age  # hello  # 会导致访问不了age
print(res)  # back
res = obj.cloud # hello  # 查找不存在的名字也会触发
print(res)  # back

__setattr__

触发: 给对象添加或者修改数据的时候自动触发。
比如这个语法: 对象.名字 = 值
注意__init__内的也算 会导致这个方法自动触发
每次修改、新增值都会触发 会触发多次

class C(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __setattr__(self, key, value):
        print('__setattr__已执行:')
        print(key, value)

obj = C('alice', 18)
obj.name = 'cloud'
'''
终端输出:
__setattr__已执行:
name alice
__setattr__已执行:
age 18
__setattr__已执行:
name cloud
'''

__enter__ __exit__

这两个要一起使用,也就是在类中要同时存在enter、exit方法,否则with上下文管理器就会报错。
enter触发:当对象被当做with上下文管理操作的开始自动触发 并且该方法返回什么 as后面的变量名就会接收到什么

# 1.
class C(object):
    def __enter__(self):
        print('__enter__已执行')
        return self 
    def __exit__(self, exc_type, exc_val, exc_tb):  # 不加exit会报错
        pass

obj = C()
with obj as f1:  # __enter__已执行
    print(f1)  # <__main__.C object at 0x0000028F128D6670>
	
# 2.
class C(object):
    def __enter__(self):
        print('__enter__已执行')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

obj = C()
with obj as f1, C() as f2:  # enter被触发了两次 # C()是产生一个新的对象
    print(f1)  
    print(f2)
'''输出结果:
__enter__已执行
__enter__已执行
<__main__.C object at 0x000001F492266670>
<__main__.C object at 0x000001F492266C40>
'''

exit触发:with上下文管理语法运行完毕之后自动触发(子代码结束)

class C(object):
    def __enter__(self):
        pass
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit')  # 会输出

obj = C()
with obj as f:
    pass
# 子代码结束会输出: exit

魔法方法笔试题

题目1:
补全下列代码使得运行不报错即可

    class Context:
        pass
    with Context() as f:
        f.do_something()
# 题解1
class Context:
    def do_something(self):
        pass
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
with Context() as f:
    f.do_something()

# 题解2
class Context:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def __getattr__(self, item):
        return self
    def __call__(self, *args, **kwargs):
        print('你好')
with Context() as f:  # 对象参与with上下文管理 开始触发__enter__ 结束也必须有__exit__
    f.do_something()

题目2:

自定义字典类型并让字典能够通过句点符的方式操作键值对
# 自定义字典类型
class Mydict(dict):
    def __setattr__(self, key, value): # 修改值的时候触发
        self[key] = value

    def __getattr__(self, item): # 如果名称空间名字 和字典中的名字重名呢?
        return self.get(item)  # 那么__getattr__是否就不会触发

obj = Mydict()
obj.name = 'jason'
obj.age = 18
print(obj)  # {'name': 'jason', 'age': 18}  # 成功添加
print(obj.name)  # jason  # 成功取值

# 补充
# 自定义字典类型
class Mydict(dict):
    def __setattr__(self, key, value): # 修改值的时候触发
        self[key] = value

    def __getattr__(self, item): # 如果名称空间名字 和字典中的名字重名呢?
        return self.get(item)  # 那么__getattr__是否就不会触发

    def name(self):
        print('hhh')

obj = Mydict()
obj.name = 'jason'
obj.age = 18
print(obj)  # {'name': 'jason', 'age': 18}
print(obj.name)  # <bound method Mydict.name of {'name': 'jason', 'age': 18}> # 由于类中有name这个名字无法调用__getatter__
obj.name()  # hhh

元类

推导流程

type类是产生类的类,也称为元类。

"""推导步骤1:如何查看数据的数据类型"""
s1 = 'hello world'  # str()
l1 = [11, 22, 33, 44]  # list()
d1 = {'name': 'jason', 'pwd': 123}  # dict()
t1 = (11, 22, 33, 44)  # tuple()
print(type(s1))  # <class 'str'>
print(type(l1))  # <class 'list'>
print(type(d1))  # <class 'dict'>
print(type(t1))  # <class 'tuple'>

"""推导步骤2:其实type方法是用来查看产生对象的类名"""
class Student:
    pass
obj = Student()
print(type(obj))  # <class '__main__.Student'>

"""推导步骤3:python中一切皆对象 我们好奇type查看类名显示的是什么"""
class Student:
    pass
obj = Student()
print(type(obj))  # <class '__main__.Student'>
print(type(Student))  # <class 'type'>
class A:pass
class B:pass
print(type(A), type(B))  # <class 'type'> <class 'type'>
"""结论:我们定义的类其实都是由type类产生的>>>:元类(产生类的类)"""

创建类的两种方式

class关键字

使用元类type

image

# 方式2:利用元类type  type(类名,类的父类,类的名称空间)
cls = type('Student', (object,), {'name':'cloud'})
print(cls)  # <class '__main__.Student'>
print(cls.__dict__)
obj = cls()
print(obj)  #  <__main__.Student object at 0x00000227E4EB59D0>
print(obj.name)  # cloud

类名称空间的产生(使用type创建类)

  1. 手写键值对
    可以发现使用type方法创建类时,第三个参数表示类的名称空间。
    我们是通过手写键值对的方式,给类添加属性的,然而如何添加函数呢?
    提前写个函数 然后将函数名写入字典
def func(self): # 会将对象传进来
    print(self.name)
cls = type('Student', (object,), {'name':'cloud','func':func})
obj = cls()
print(func)  # <function func at 0x00000119903F7280>
print(obj.func)  # <bound method func of <__main__.Student object at 0x0000011990516670>> # 地址不同
obj.func()  # cloud  # 是一个神奇的函数!
  1. 内置方法exec
    能够运行字符串类型的代码并产生名称空间
    略了,有空来填坑= =

元类定制类的产生行为

干预类的生产!类的制作过程是什么?是流水线生产吗!首先必须要干预元类type 继承非元类的普通类无法干预类的产生行为 然而我们又无法改type源代码 所以要自己定义一个元类 然后使用自己的 元类产生类。
ps:继承了type的类也称之为元类。

metaclass参数指定元类

"""
推导
	对象是由类名加括号产生的  ——>Student()                     __init__
	类是由元类加括号产生的    ——>type(name, bases, dict)       __init__

元类产生类的时候会不会也有__init__这种默认执行的方法?
元类中__init__产生类也要传东西!已知要传三个参数:type(类名,类的父类,类的名称空间) 
"""

# 继承并重写元类的__init
class MyMetaClass(type):  # 1.自定义元类:继承type的类也称之为元类
    def __init__(cls, what, bases=None, dict=None):  # 2.去看type源码把这一行copy下来
        print(what)  # 类名
        print(bases) # 继承的父类
        print(dict)  # 名称空间
        super().__init__(what, bases, dict) # 3.继续执行type类中的方法

class Student(object,metaclass=MyMetaClass): # 4.metaclass这个参数默认指定type这个元类 我们将其设置为自己创的元类
    name = 'cloud'
    def say(self):
        print('hello')

输出结果:
image
限制类的产生:

"""需求:所有的类必须首字母大写 否则无法产生"""
class MyMetaClass(type):
    def __init__(cls, what, bases=None, dict=None):
        if not what.istitle():
            raise TypeError('类的首字母必须大写!')  # 看这里= =

        super().__init__(what, bases, dict)

class student(object,metaclass=MyMetaClass):  # TypeError: 类的首字母必须大写!
    pass

class Teacher(object,metaclass=MyMetaClass):
    pass

print(Teacher)  # <class '__main__.Teacher'>

元类定制对象的产生行为

"""
推导
	对象加括号会执行产生该对象类里面的   __call__
	类加括号会执行产生该类的类里面的	 __call__
"""
# 继承并重写元类中的__call__
class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        print(args)  # 1.查看__call__中参数
        print(kwargs)
        super().__call__(*args, **kwargs) # 2.看一眼之后重新执行元类中的__call__

class Student(metaclass=MyMetaClass):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
obj = Student('cloud', 18, gender= 'male')   # ('cloud', 18)
                                             # {'gender': 'male'}
# 3.可以得知创建对象时 会将数据传入元类的__call__方法

__call__

元类双下call做了三件事:
1.负责产生空对象 (骨架)
2.调用子类的双下init 给对象添加独有的数据(血肉)
3.返回创建好的对象

"""给对象添加独有数据的时候 必须采用关键字参数传参"""

class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        # 1.产生一个空对象(骨架)
        # 2.调用__init__给对象添加独有的数据(血肉)
        # 3.返回创建好的对象
        if args:
            raise TypeError("必须按照关键字参数传参")
        return super().__call__(*args, **kwargs)

class Student(object,metaclass=MyMetaClass):
    def __init__(self, name, age):
        self.name = name
        self.age = age
# obj = Student('cloud', 18)  # TypeError: 必须按照关键字参数传参
obj = Student(name= 'cloud', age= 18)
print(obj.name)  # {'name': 'cloud', 'age': 18}

__new__

__new__方法可以产生一个空对象。在元类中的__call__方法会使用到__new__
例子:

class MyMetaClass(type):
    def __call__(cls, *args, **kwargs):
        # 1.使用__new__产生一个空对象(骨架)
        obj = cls.__new__(cls)
        # 2.调用Student.__init__给对象添加独有的数据(血肉)
        cls.__init__(obj, *args, **kwargs)
        # 3.返回创建好的对象
        return True, obj


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

msg, obj= Student('cloud') # 产生对象时 触发元类__call__ 将student类和数据'cloud'传入元类
print(msg)  # True
print(obj.__dict__)  # {'name': 'cloud'}

"""
__new__可以产生空对象
"""

总结

  1. 元类的__call__才是真正产生对象的方法,子类__init__只是用于设置属性的一个接口。
  2. __init__在元类__call__的调用下运行。
  3. 元类__call__方法内的__new__用于产生一个空对象。
class MyMetaClass(type):
    def __call__(cls, *args, **kwargs):
        # 1.使用__new__产生一个空对象(骨架)
        obj = cls.__new__(cls)
        # 2.调用Student.__init__给对象添加独有的数据(血肉)
        cls.__init__(obj, *args, **kwargs)
        # 3.返回创建好的对象
        return True, obj


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

msg,obj= Student('cloud')
print(msg)  # True
print(obj.__dict__)  # {'name': 'cloud'}
obj.__init__('alice') # 调用__init__
print(obj.__dict__)  # {'name': 'alice'}

标签:__,obj,name,type,self,魔法,print,方法
From: https://www.cnblogs.com/passion2021/p/16868924.html

相关文章

  • 8种现代数组方法,每个开发人员都应该知道
    英文| https://javascript.plainenglish.io/8-modern-array-methods-that-every-developer-should-know-416855e01757翻译|小爱在用代码执行数组操作时,你是否经想过,关于......
  • 安卓手机添加系统证书方法
    安卓手机添加系统证书方法https://www.cnblogs.com/zj420255586/p/14652194.htmlhttps://blog.csdn.net/z9722/article/details/121752677 安卓7.0以上证书存放位置由于......
  • Python基础之面向对象:7、面向对象之魔法方法
    目录面向对象之魔法方法一、魔法方法的概念二、常用魔法方法1、__init__2、__str__3、__call__4、__getattr__5、__getattribute__6、__setattr__7、__enter......
  • 用 JavaScript 编写枚举的最有效方法
    英文|https://betterprogramming.pub/the-most-efficient-way-to-write-enumerations-in-javascript-a1b9f41ea651JavaScript语言本身不支持枚举。如果我们想模拟枚举,我......
  • too many open files(打开的文件过多)解决方法
    https://www.cnblogs.com/conanwang/p/5818441.htmlSU:failedtoexecute/bin/bash:系统中打开的文件过多一、产生原因toomanyopenfiles(打开的文件过多)是Linux......
  • 魔法方法与元类
    面向对象的魔法方法类中定义的双下方法都称为魔法方法.在特定的条件下自动触发运行,不需要人去调用__init__方法'对象添加独有数据时'自动触发classA:def__ini......
  • javascript中数组的22种方法
    数组总共有22种方法,本文将其分为对象继承方法、数组转换方法、栈和队列方法、数组排序方法、数组拼接方法、创建子数组方法、数组删改方法、数组位置方法、数组归并方法和数......
  • 前端JavaScript 常见的报错及异常捕获与处理方法
    前言在开发中,有时,我们花了几个小时写的js代码,在浏览器调试一看,控制台一堆红,瞬间一万头奔腾而来。至此,本文主要记录js常见的一些错误类型,以及常见的报错信息,分析其报错原因......
  • 面向对象4魔法方法及元类
    目录面向对象的魔法方法魔法方法笔试题元类简介创建类的两种方式元类定制类的产生行为元类定制对象的产生行为魔法方法之双下new设计模式简介面向对象的魔法方法魔法方法......
  • 面向对象的魔法方法
    面向对象的魔法方法(格式都是双下)方法作用init对象添加独有数据的时候自动触发str对象被执行打印操作的时候自动处罚call对象加括号调用的时候自动触发......