17.python-魔术方法

python 魔术方法-示例

• python 魔术方法-示例
  • 特殊属性
  • 构造方法
  • 基本方法
  • 模拟容器类
  • 属性相关
  • 比较操作符
  • 运算符相关
  • 反运算
  • 增量赋值运算
  • 一元操作符
  • 类型转换
  • 上下文管理器
  • 参考资料

特殊属性

class People(object):
    # 实例化对象
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("__init__")

p1 = People("beike", 18)
print(People.__name__)
print(People.__class__)
print(People.__bases__)
print(People.__doc__)
print(People.__dict__)
#
print("-"*50)
print(p1.__class__)
print(p1.__doc__)
print(p1.__dict__)

# 执行结果----------------------------------------------------------------------------
__init__
People
<class 'type'>
(<class 'object'>,)
None
{'__module__': '__main__', '__init__': <function People.__init__ at 0x0000017602883820>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
--------------------------------------------------
<class '__main__.People'>
None
{'name': 'beike', 'age': 18}

构造方法

构造方法__new__
触发时机： 实例化对象时自动触发（在__init__之前触发）
参数：至少一个cls 接收当前类，其他参数根据初始化方法参数决定
返回值：必须返回一个对象实例，没有返回值，则实例化对象的结果为 None,新实例的 __init__() 方法就不会被执行
作用：实例化对象

初始化方法__init__
触发机制：实例化对象之后立即触发
参数：至少有一个self，接收当前对象，其他参数根据需要进行定义
返回值：无
作用：初始化对象的成员

析构方法__del__
触发时机：当该类对象被销毁时，自动触发
参数：一个self，接受当前对象
返回值：无
作用：关闭或释放对象创建时资源
注意：del不一定会触发当前方法，只有当前对象没有任何变量引用时才会触发

可调用对象__call__    
调用对象的魔术方法
触发时机:将对象当作函数调用时触发,  方式: 对象()
参数:至少一个self接收对象，其余根据调用时参数决定
返回值：自定义
作用：可以将复杂的步骤进行合并操作，减少调用的步骤，方便使用

class People(object):
    # 创建对象
    def __new__(cls, *args, **kwargs):
        print("触发了构造方法")
        ret = super().__new__(cls) # 调用父类的__new__()方法创建对象
        return ret ## 将对象返
    # 实例化对象
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("初始化方法")
    #  删除对象
    #   del 对象名或者程序执行结束之后
    def __del__(self):
        print("析构方法，删除对象")


if __name__ == '__main__':
    p1 = People('xiaoming', 16)
	del p1
    print("程序结束")
    
触发了构造方法
初始化方法
析构方法，删除对象
程序结束

基本方法

__len__
触发时机：使用len(对象) 的时候触发
参数：一个参数self
返回值：必须是一个整型
作用：可以设置为检测对象成员个数，但是也可以进行其他任意操作
注意：返回值必须必须是整数，否则语法报错，另外该要求是格式要求

__bool__
触发时机: 使用bool(对象)的时候触发
参数：一个self接收对象
返回值：必须是布尔值
作用：根据实际情况决定，可以作为快捷方式使用
注意:仅适合于返回布尔值的操作

__repr__
触发时机:在使用repr(object)的时候触发
参数：一个self接收对象
返回值：必须是字符串
作用：将对象转使用repr化为字符串时使用，也可以用于快捷操作
此方法通常被用于调试

__str__
触发时机: 通过 str(object) 以及内置函数 format() 和 print() 
参数：一个self接收对象
返回值：必须是字符串
作用：将对象转使用str化为字符串时使用，也可以用于快捷操作

__format__
触发时机：使用字符串.format(object)时候触发
参数：一个self接收对象，一个参数接收format的{}中的格式，例如:>5
返回值:必须是字符串
作用：设置对象可以作为format的参数，并且自定义对象格式化的规则
注意：无

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

    def __repr__(self):
        return f"Person(name='{self.name}', age={self.age})"

    def __str__(self):
        return f"{self.name}, {self.age}"

    def __format__(self, format_spec):
        if format_spec == "":
            return  "s"
        if format_spec == "s":
            return str(self)
        elif format_spec == "r":
            return repr(self)
        elif format_spec == "a":
            return f"Person('{self.name}', {self.age})"
        else:
            raise ValueError(f"Invalid format specifier '{format_spec}'")

person = Person("Alice", 30)
print(person)                 # 输出：Alice, 30
print(str(person))            # 输出：Alice, 30
print(repr(person))           # 输出：Person(name='Alice', age=30)
print("{}".format(person))    # 输出：s
print("{!s}".format(person))  # 输出：Alice, 30
print("{!r}".format(person))  # 输出：Person(name='Alice', age=30)
print("{!a}".format(person))  # 输出：Person('Alice', 30)

模拟容器类

__len__
1 内建函数len()，返回对象的长度（>=0的整数）
  如果把对象当作容器类型看，就如同list或者dict
2 bool()函数调用的时候，如果没有__bool__()方法
  则会看__len__()方法是否存在，存在返回非0为真

__iter__
1 迭代容器时，调用，返回一个新的迭代器

__contains__
1 in成员运算符，没有实现，就调用__iter__方法遍历

__getitem__
1 实现self[key]访问。序列对象，key接受整数为索引，或为切片
2 对于set和dict，key为hashable。key不存在引发KeyError异常

__setitem__
1 和__getitem__的访问类似，是设置值的方法

__missing__
1 字典或其子类使用__getitem__()调用时，key不存在执行该方法

# 模拟购物车类
class Cart:
    def __init__(self):
        self.items = []
        
    def __len__(self):
        return len(self.items)
    
    def additem(self, item):
        self.items.append(item)
        
    def __iter__(self):
        return iter(self.items)
    
    def __getitem__(self, index):
        return self.items[index]
    
    def __setitem__(self, key, value):
        self.items[key] = value
        
    def __str__(self):
        return str(self.items)
    
    def __add__(self, other):
        self.items.append(other)
        return self

cart = Cart()
cart.additem(1)
cart.additem('a')
cart.additem('c')

print(cart)  			   # [1, 'a', 'c']
print(len(cart))  		   # 3
for x in cart:
    print(x, end = ' ')    # 1 a c 
print(3 in cart)  		   # False
print(1 in cart)           # True
print(cart[1])             # a
cart[1] = 'xyz'				
print(cart)                # [1, 'xyz', 'c']
print(cart + 4 + 'aaa' + 'ppp')   # [1, 'xyz', 'c', 4, 'aaa', 'ppp']
print(cart.__add__('iii'))        # [1, 'xyz', 'c', 4, 'aaa', 'ppp', 'iii']
print(cart.items)                 # [1, 'xyz', 'c', 4, 'aaa', 'ppp', 'iii']

属性相关

__getattribute__() 方法与 __getattr__() 方法的行为不同。__getattribute__() 方法用于访问任何属性，而 __getattr__() 方法仅在对象没有指定属性时才会被调用。

__getattr__
触发时机：获取不存在的对象成员时触发
参数：一个是接收当前对象的self，一个是获取成员名称的字符串
返回值：必须有值
作用:为访问不存在的属性设置值

__setattr__
触发时机:设置对象成员值的时候触发
参数:1个当前对象的self,一个是要设置的成员名称字符串,一个是要设置的值
返回值:无 过程操作
作用:接管设置操作,可以在设置前之前进行判断验证等行为
注意:在当前方法中无法使用成员=值的方式直接设置成员，否则会无限递归，必须借助object的设置方法来完成


__dir__
触发时机: 会在对相应对象调用 dir() 时被调用
参数:1个当前对象的self
返回值: 必须是一个序列
作用:  dir() 会把返回的序列转换为列表并对其排序。
注意:在当前方法中无法使用成员=值的方式直接设置成员，否则会无限递归，必须借助object的设置方法来完成

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

    def __getattr__(self, name):
        if name == "email":
            return f"{self.name.lower()}@example.com"
        else:
            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{name}'")

    def __setattr__(self, name, value):
        if name == "age":
            if value < 0:
                raise ValueError("Age cannot be negative")
        super().__setattr__(name, value)

    def __delattr__(self, name):
        if name == "email":
            raise AttributeError("Cannot delete email attribute")
        super().__delattr__(name)

person = Person("Alice", 30)
print(person.email)  # 输出：[email protected]
person.age = 40
print(person.age)    # 输出：40
del person.email     # 引发 AttributeError 异常

class Person:
    def __init__(self, name, age):
        self._name = name
        self._age = age

    def __getattribute__(self, name):
        if name == "name":
            return "Hello, " + object.__getattribute__(self, "_name")
        elif name == "age":
            return object.__getattribute__(self, "_age")
        else:
            return object.__getattribute__(self, name)

person = Person("Alice", 30)
print(person.name)  # 输出：Hello, Alice
print(person.age)   # 输出：30
print(person.xyz)   # 引发 AttributeError 异常

比较操作符

运算符相关

反运算

增量赋值运算

一元操作符

类型转换

上下文管理器

上下文管理器 详细 见contextlib

参考资料

https://zhuanlan.zhihu.com/p/344951719

https://blog.csdn.net/weixin_44983653/article/details/123968967

https://blog.csdn.net/weixin_44983653/article/details/123968967