[Python知识库]python杂记——魔法方法

什么是魔法方法?

魔法方法(magic methods)：python中的魔法方法是指方法名以两个下划线开头并以两个下划线结尾的方法，因此也叫Dunder Methods (Double Underscores)。常用于运算符重载。魔法方法会在对类的某个操作时后端自动调用，而不需要自己直接调用。例如当使用+将两个数字相加时，在类内部会调用__add__()方法，再比如创建一个类A的对象，a=A()，python就会自动调用__new__和__init__。

常见魔法方法

初始化和构造

有几个问题需要注意一下:

1. 只有继承object的新式类才有_new_
2. __new__至少有一个参数cls,代表当前类
3. __new__必须要有返回值,返回创建的对象
4. __init__必须有一个参数self,这个是__new__的返回值, __init__不需要返回值

测试代码:

class MyClass(object):
	def __init__(self, num):
		self.num = num
		print("i am __init__ function")
		
	def __new__(cls, num):
		print("i am __new__ function")
		obj = super(MyClass, cls).__new__(cls)
		return obj
		
	def __del__(self):
		print("i am __del__ function")
		

myclass = MyClass(num=55)
print("create obj ok === ")
del myclass

输出结果:

i am __new__ function
i am __init__ function
create obj ok === 
i am __del__ function

一元操作符

测试代码:

class TestUnaryOpsAndFunc:
    def __init__(self, num=0) -> None:
        self._num = 3
        self._neg_num = -5
        self._float_num = 3.1415
        self._neg_float_num = -3.1415
    
    def __pos__(self):
        return +self._neg_num
    
    def __neg__(self):
        return -self._num

    def __abs__(self):
        return abs(self._neg_float_num)
    
    def __invert__(self):
        return ~self._num 
    
    def __round__(self):
        return round(self._float_num)
    
    def __floor__(self):
        return math.floor(self._neg_float_num)
    
    def __ceil__(self):
        return math.ceil(self._float_num)
    
    def __trunc__(self):
        return math.trunc(self._float_num)
test_class = TestUnaryOpsAndFunc()
print("pos: ", +test_class)
print("neg: ", -test_class)
print("abs: ", abs(test_class))
print("invert: ", ~test_class)
print("round: ", round(test_class))
print("floor: ", math.floor(test_class))
print("ceil: ", math.ceil(test_class))
print("trunc: ", math.trunc(test_class))

测试结果:

pos:  -5
neg:  -3
abs:  3.1415
invert:  -4
round:  3
floor:  -4
ceil:  4
trunc:  3

增量赋值

类型转换

字符串相关

str和repr的区别后面单独写个文章来介绍一下

测试代码:

class Person:
    def __init__(self, name, age) -> None:
        self._name = name
        self._age = age
        
    def __str__(self) -> str:
        output = "str called,name: {0}; age: {1}".format(self._name, self._age)
        return output
    
    def __repr__(self) -> str:
        output = "repr called, name: {0}; age: {1}".format(self._name, self._age)
        return output
person = Person(name="william", age=24)
print(person)
print(repr(person))

测试结果:

str called,name: william; age: 24
repr called, name: william; age: 24

属性相关

描述符

要创建一个描述符, 该类必须实现_get_, _set_, __delete__三个方法中至少一个

测试代码:

class Attribute:
    def __init__(self, data) -> None:
        self._data = data
        
    def __get__(self, instance, owner):
        print("__get__ called")
        return self._data
    
    def __set__(self, instance, value):
        print("__set__ called")
        self._data = value

    def __delete__(self, instance):
        print("__delete__ called")
        del self._data
class MyClass:
    attr = Attribute(99)
    def __init__(self, attr="defaule value"):
        self.attr = attr

myclass = MyClass()
myclass.attr = "new value"
value = myclass.attr
print("value: ", value)
del myclass.attr
#value = myclass._attr
#print("value: ", value)
myclass1 = MyClass()
value = myclass1.attr
print("value: ", value)

测试结果:

__set__ called
__set__ called
__get__ called
value:  new value
__delete__ called
__set__ called
__get__ called
value:  defaule value

拷贝

协程

测试代码

class Awaitable:
    def __init__(self) -> None:
        self._person = []
        p = Person(name="william", age=24)
        p1 = Person(name="william1", age=25)
        p2 = Person(name="william2", age=26)
        p3 = Person(name="william3", age=27)
        self._person.append(p)
        self._person.append(p1)
        self._person.append(p2)
        self._person.append(p3)    
    def __aiter__(self):
        print("aiter called ...")
        self.index = 0
        return self    
    async def __anext__(self):
        print("anext called")
        while self.index < len(self._person):
            self.index += 1
            return self._person[self.index - 1]
        raise StopAsyncIteration
async def AsyncFunction():
    print("called async function")
    return 1

async def test_coroutine():
    func = AsyncFunction()
    await func

async def test_async_context():
    async with AsyncContext() as ac:
        print("main block")

async def test_async_for():
	async for a in Awaitable():
        print("a: ", a)
asyncio.run(test_coroutine())
asyncio.run(test_async_for())
asyncio.run(test_async_context())

测试结果:

called async function
aiter called ...
anext called
a:  str called,name: william; age: 24
anext called
a:  str called,name: william1; age: 25
anext called
a:  str called,name: william2; age: 26
anext called
a:  str called,name: william3; age: 27
anext called
enter the block
main block
exit the block

二元运算符

反射算数运算符

反射运算是什么呢? 比如: a + b, 反射的意思就是交换两个操作数的位置: b + a, 注意这时候b一定不能够定义非反射的操作, 只有这样才会调用a的反射操作_radd()_

集合相关

迭代相关

测试代码:

class MyQueue:
    def __init__(self) -> None:
        self._queue = [i for i in range(10)]

    def __iter__(self):
        self._index = 0
        return self
    
    def __next__(self):

        while self._index < len(self._queue) - 1:
            self._index += 1
            return self._queue[self._index]
        
        raise StopIteration
it = iter(MyQueue())
while True:
    try:
        num = next(it)
        print("num: ", num)
    except StopIteration:
        print("visit finished")
        break

num:  1
num:  2
num:  3
num:  4
num:  5
num:  6
num:  7
num:  8
num:  9
visit finished

调用

测试代码:

class Dog:
    def __init__(self, color) -> None:
        self._color = color
    
    def __call__(self, *args: Any, **kwds: Any) -> Any:
        return self._color
dog = Dog(color="black")
color = dog()
print("color: ", color)

测试结果:

color:  black

上下文管理器

测试代码:

class MyContex:
    def __enter__(self):
        print ("enter the closer")
        
    def __exit__(self,  exception_type, exception_value, traceback):
        print("exit the closer")
with MyContex() as context:
    print("it is in closer")

测试结果:

enter the closer
it is in closer
exit the closer