Python中类的特殊属性与魔术方法

最新推荐文章于 2022-09-01 10:33:57 发布
最新推荐文章于 2022-09-01 10:33:57 发布
阅读量835 收藏 6
点赞数 1
分类专栏： python基本知识 文章标签： 类的特殊属性与魔术方法 Python中类的特殊属性与魔术方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013008795/article/details/90574509
版权

文章目录

Python中类的特殊属性与魔术方法

特殊的属性

属性含义
__name__类，函数，方法等效的名字。即名称
__module__类定义所在的模块名称
__class__对象或类所属的类
__bases__类的基类(父类)的元组，顺序为他们在基类列表中出现的顺序
__doc__类、函数的文档字符串，如果没有定义则为None
__mro__类的mro,class.mro()返回的结果都保存在__mro__中。C3算法帮忙保证类的mro唯一性
__dict__类或实例的属性，可写的字典

查看属性

方法含义
__dir__(self)返回类或者对象的所有成员名称列表
dir()函数操作实例就是调用__dir()__

如果dir([obj])参数obj包含方法 __dir__() ，该方法将被调用。如果参数obj不包含 __dir__() ，该方法将最大限 度地收集属性信息。

  • dir(obj) #如果没有参数，返回当前局部作用域中的名称列表。使用参数时，尝试返回该对象的有效属性列表。
    • dir(obj)相当于调用obj.__dir__()的方法
    • 对于不同类型的对象obj具有不同的行为：
    1. 如果对象是模块对象，返回的列表包含模块的属性名和变量名
    2. 如果对象是类型或者说是类对象，返回的列表包含类的属性名，及它祖先类的属性名。
    3. 如果是类的实例
      • 有__dir__方法，返回可迭代对象的返回值
      • 没有__dir__方法，尽可能收集实例的属性名、类的属性和祖先类的属性名
    4. 如果obj不写，返回列表包含内容不同
      • 在模块中，返回模块的属性和变量名
      • 在类中，返回类本地作用域的属性和变量名
      • 在函数中，返回本地作用域的变量名
      • 在方法中，返回本地作用域的变量名

  1. 示例1，不同作用域中的dir返回值 返回局部作用域中的名称列表

    • animal.py文件信息如下：
    #animal.py文件信息如下：
class Animal:
x = 123
def __init__(self,name):
    self._name = name
    self.__age = 18
    self.weight = 20

print("animal.py names = {}".format(dir()))
    • cat.py文件信息如下：
    
#cat.py文件信息如下：
import animal
from animal import Animal

class Cat(Animal):
    x = "cat"
    y = "abcd"
    print("Cat class 类中 names = {}".format(dir()))

    z = "xyz"

    def show(self):
        a = self
        b = 10
        print("show方法中 names = {}".format(dir()))

print("cat.py names = {}".format(dir()))
cat = Cat("苗")
cat.show()

    执行cat.py文件输出结果如下：
    class4_001

  2. 示例2：类型中的__dir__

    • 如果对象是类型或者说是类对象，返回的列表包含类的属性名，及它祖先类的属性名。
    • dir(类) 等价于调用type.__dir__(类)方法。应为类的类型是type
    class Animal:
    x = 123
    def __init__(self,name):
        self._name = name
        self.__age = 18
        self.weight = 20

class Cat(Animal):
    x = "cat"
    z = "xyz"

    def show(self):
        a = self
        b = 10
        print("show方法中 names = {}".format(dir()))

class Dog(Animal):
    def __dir__(self):
        return ["dog"]  #__dir__方法必須返回可迭代对象

#Cat类的dir 会调用type中的__dir__方法返回类Cat的dir,应为Cat是类
print(type(Cat))
print("Cat 类的 names = {}".format(dir(Cat)))
#相当于排序后的集合
print("Cat 类的 names = {}".format(sorted((Cat.__dict__.keys()| Animal.__dict__.keys() | object.__dict__.keys()))))
print("Dog 类的 names = {}".format(dir(Dog)))

    class4_003

  3. 示例3：示例属性中的__dir__ (尽可能的最大收集实例属性的属性名)

    • dir(self) 等价于 self.__dir__ #self为实例对象
    • 如果类中重写了__dir__方法，那么dir(self)调用的返回值是重写的__dir__方法的返回值
    • __dir__方法的返回值必须是一个可迭代对象
    class Animal:
    x = 123
    def __init__(self,name):
        self._name = name
        self.__age = 18
        self.weight = 20

class Cat(Animal):
    x = "cat"
    z = "xyz"

    def show(self):
        a = self
        b = 10
        print("show方法中 names = {}".format(dir()))

class Dog(Animal):
    def __dir__(self):
        return ["dog"]  #__dir__方法必須返回可迭代对象

cat = Cat("苗")
dog = Dog("旺旺")

#注意：dir(cat) 等价于cat.__dir__()
print("cat 实例属性,dir() = {}".format(dir(cat)))
print("cat 的内建函数__dir__ = {}".format(sorted(cat.__dir__())))
print("dog 实例的实例属性 dir() = {}".format(dir(dog)))
print("dog 实例的实例属性 __dir__() = {}".format(dog.__dir__()))

    class4_002

特殊函数

  • locals() 返回当前作用域中的变量字典
  • globals() 当前模块全局变量的字典
class Animal:
    x = 123
    def __init__(self,name):
        self._name = name
        self.__age = 18
        self.weight = 20

class Cat(Animal):
    x = "cat"
    z = "xyz"
    print("Cat 类中 globals = {}".format(sorted(globals().keys())))
    print("Cat 类中 dir = {}".format(dir()))
    print("Cat 类中 locals = {}".format(sorted(locals().keys())))
    def show(self):
        a = self
        b = 10
        print("show方法中 globals = {}".format(sorted(globals().keys())))
        print("show方法中 dir = {}".format(dir()))
        print("show方法中 locals = {}".format(sorted(locals().keys())))

class Dog(Animal):
    def __dir__(self):
        return ["dog"]  #__dir__方法必須返回可迭代对象
    print("Dog 类中 globals = {}".format(sorted(globals().keys())))
    print("Dog 类中 dir = {}".format(dir()))
    print("Dog 类中 locals = {}".format(sorted(locals().keys())))


print("cat.py 模块中 globals = {}".format(sorted(globals().keys())))
print("cat.py 模块中 locals = {}".format(sorted(locals().keys())))
print("cat.py 模块中 dir = {}".format(dir()))
cat = Cat("苗")
cat.show()

class4_004

魔术方法

实例化

方法意义
__new__(self,*args,**kwargs)示例化一个对象
该方法需要返回一个值，如果该值不少cls的实例，则会调用__init__
该方法永远都是静态方法
调用new方法前还没有实例对象，正常调用完成后会生成实例对象。
__init__(self)对实例进行初始化，通常用来设置实例属性，基本配置信息等。
调用init方法前已经存在实例对象
__del__(self)实例的引用次数为0时调用。即删除实例时调用。
当系统自动调用del方法后实例已经没有对象记录，等着垃圾回收gc来清理。
  • new的简单示例(init和del方法在前面文章中已经讲到，这里不做演示)
class A:
    def __new__(cls,*args,**kwargs):
        print(cls)
        print(args)
        print(kwargs)
        # return super().__new__(cls)
        # return 1
        return None

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

a = A()
print(a)

class4_005
__new__ 方法很少使用，即使创建了该方法，也会使用 return super().__new__(cls) 基类object的 __new__ 方 法来创建实例并返回。

可视化

方法等效的内建函数含义
__str__(self)str()str()函数、format()函数、print()函数调用，需要返回对象的字符串表达式。如果没有定义，就去调用__repr__方法返回字符串的表达。如果__repr__没有定义，就直接返回对象的内存地址信息
__repr__(self)repr()内建函数repr()对一个对象获取字符串表达。
调用__repr__方法返回字符串表达，如果__repr__也没有定义，就直接返回object的定义，显示内存地址信息。
__bytes__(self)bytes()bytes()函数调用，返回一个对象的bytes表达，即返回bytes对象
  • 简单示例：
class A:
    def __init__(self,name,age=18):
        self.name = name
        self.age = age
        
    def __repr__(self):
        return "repr:{},{}".format(self.name,self.age)
    
    def __str__(self):
        return "str:{},{}".format(self.name,self.age)
    
    def __bytes__(self)->bytes:
        import json
        return json.dumps(self.__dict__).encode()
    
a = A("tom")
print(a) #print函数会默认调用对象的__str__ 等价于a.__str__
print([a]) #等价于[a].__str__  但[]里面会默认调用a的__repr__即等价于[a.__repr__()].__str__()
print([a.__repr__()].__str__())
print(bytes(a)) #等价于str(bytes(a))  等价于 a.__bytes__().__str__()
print( a.__bytes__().__str__())

class4_006

可哈希(hash)与等等运算符(==)

方法等效的内建函数意义
__hash__(self)hash()内建函数hash()调用的返回值，返回一个整数。如果定义这个方法该类的实例就可hash。
__eq__(self)==对等等操作符，判断2个对象是否相等，返回值bool值
定义了这个方法，如果不提供__hash__方法，那么实例对象将不可hash了。
  • __hash__ 方法只是返回一个hash值作为set的key，但是 去重 ，还需要 __eq__ 来判断2个对象是否相等。 hash值相等，只是hash冲突，不能说明两个对象是相等的。
  • 因此，一般来说提供 __hash__ 方法是为了作为set或者dict的key，如果 去重 要同时提供 __eq__ 方法。
  • 判断对象是否可哈希isinstance(obj, collections.Hashable),obj为需要判断的对象。

  1. 示例1:

    • 对象的hash值取决于对象的__hash__函数的返回值
    • 如果使用"=="运算符，其结果为__eq__函数的返回值
    class A:
    def __init__(self,name,age=18):
        self.name = name
        self.age = age

    def __hash__(self):
        return hash("{},{}".format(self.name,self.age))

    def __repr__(self):
        return "repr {} {}".format(self.name,self.age)

    def __eq__(self,other):
        # return "abc"  #如果返回字符串，那么print(b==a)的结果就是返回的字符串
        return True

    __str__ = __repr__

a = A("旺旺")
b = A("哈哈")
print(a)
print(hash(a),a.__hash__())
print(hash(b),b.__hash__())
print(b==a) #等价于 b.__eq__(a)

    class4_007

  2. 示例2:

    • set字典中唯一性先判断对象是否可hash，在判断hash值是否相等以及是否“==”来判断新增加的值是否已经存在
    class stt:
    def __repr__(self):
        return "("+",".join("{}:{}".format(x,y) for x,y in self.__dict__.items())+")"

class Point(stt):
    def __init__(self,x,y):
        self.x = x
        self.y = y

class Point2(stt):
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __hash__(self):
        return hash("{},{}".format(self.x,self.y))

    def __eq__(self,other):
        return self.x==self.x and self.y==self.y

print(set([Point(1,2),Point(1,2)]))
print(set([Point2(1,2),Point2(1,2)]))

    class4_008

  3. 示例3：

    • 扩展
    • hash值对int类型求值是用一个大整数取摸(%)计算得到的结果
    • hash值的整数为：【2305843009213693951】
    • 下面示例求出hash值对应的大整数是多少
    # %%timeit
def getHashbigInt():
    i = 0
    ii = 2 #增量

    while ii >1:
        i = i+ii
        if hash(i)==i:
            ii = ii*2 #增量加大
        else: #调整增量
            i = i-ii  #i值还原
            ii = ii//2 #增量缩小
    return i+1

hig = getHashbigInt()
print(hig)
print(hash(hig-1),hash(hig),hash(hig+1))

    class4_009

bool

方法对应的内建函数意义
__bool__(self)bool()内建函数bool()，或者对象放在逻辑表达式的位置，调整这个函数返回布尔值。
如果对象没有定义__bool__()，就找__len__()返回长度，非0为真
如果__len__()也没有定义，那么所有实例都返回真
  • if obj等价于 if obj.__bool__()
  • bool(obj)等价于 obj.__bool__()
class A:pass

class B:
    def __bool__(self)->bool:
        #注意：bool函数的返回值必须是bool类型，否则会报错
        return False

class C:
    def __len__(self):
        return 1

class D:
    def __len__(self):
        return 0

a = A()
b = B()
c = C()
d = D()
print(bool(a),bool(b),bool(c),bool(d))
if a: #if a等价于 if a.__bool__()
    print("this is a = true")
if b:
    print("this is b = true")
if c:
    print("this is c = true")
if d:
    print("this is d = true")

class4_0010

运算符重载

operator模块提供以下的特殊方法，可以将类的实例使用下面的操作符来操作

1.比较运算符重载
特殊方法运算符含义
__lt__(self,other)<小于运算符等效符调用的对应方法
在obj1 < obj2时调用obj1.__lt__(obj2)
__le__(self,other)<=小于等于运算符等效符调用的对应方法
在obj1 <= obj2时调用obj1.__le__(obj2)
__eq__(self,other)==等等运算符等效调用的对应方法
在obj1 == obj2时调用obj1.__eq__(obj2)
__gt__(self,other)>大于运算符等效调用的对应方法
在obj1 > obj2时调用obj1.__gt__(obj2)
__ge__(self,other)>=大于等于运算符等效调用的对应方法
在obj1 >= obj2时调用obj1.__ge__(obj2)
__ne__(self,other)!=不等运算符等效调用的对应方法
在obj1 != obj2时调用obj1.__ne__(obj2)

注意：

  • 完成小于方法，对应的大于方法可以不用重新也能使用。反之也一样。
  • 完成小于等于方法，对应的大于等于方法可以不用重写。反之也一样。
  • 简单示例：
class A:
    def __init__(self,age = 18):
        self.age = age

    def __lt__(self,other): #完成小于方法，大于方法也可以使用
        return self.age < other.age

    def __ge__(self,other): #完成大于等于方法，小于等于方法也可以使用
        return self.age >= other.age

    def __eq__(self,other): #完成
        return self.age == other.age

a1 = A()
a2 = A(20)
a3 = A(10)
a4 = A()
print("a1 < a2 ,{}".format( a1 < a2 ))
print("a1 > a2 ,{}".format( a1 > a2 ))
print("a1 >= a2 ,{}".format( a1 >= a2 ))
print("a1 <= a2 ,{}".format( a1 <= a2 ))
print("a1 <= a4 ,{}".format( a1 <= a4 ))
print("a1 == a4 ,{}".format( a1 == a4 ))

class4_0011

2.算术运算符重载
特殊方法运算符含义
__add__(self,other)+加法运算等效调用的对应方法
在obj1 + obj2时调用obj1.__add__(obj2)
__sub__(self,other)-减法运算等效调用的对应方法
在obj1 - obj2时调用obj1.__sub__(obj2)
__mul__(self,other)*乘法运算等效调用的对应方法
在obj1 * obj2时调用obj1.__mul__(obj2)
__truediv__(self,other)/除法运算等效调用的对应方法
在obj1 / obj2时调用obj1.__truediv__(obj2)
__mod__(self,other)%**取摸运算(取余数)**等效调用的对应方法
在obj1 % obj2时调用obj1.__mod__(obj2)
__floordiv__(self,other)//整除运算(向下取整)等效调用的对应方法
在obj1 // obj2时调用obj1.__floordiv__(obj2)
__pow__(self,other)**
pow(x,n)		次幂运算等效调用的对应方法。也等价于pow(x,n)方法
在obj1 ** obj2时调用obj1.__pow__(obj2)
__divmod__(self,other)divmod(obj1,obj2)获取数的商和余数组成的元组等效的对应方法
在divmod(obj1,obj2)时调用obj1.__divmod__(obj2)
__matmul__(self,other)@矩阵运算符等效调用的对应方法
在obj1 @ obj2时调用obj1.__matmul__(obj2)
__and__(self,other)&与运算符等效的对应方法
在obj1 & obj2时调用obj1.__and__(obj2)
__or__(self,other)|或运算符等效的对应方法
在obj1 | obj2时调用obj1.__or__(obj2)
__xor__(self,other)^异或运算符等效的对应方法
在obj1 ^ obj2时调用obj1.__xor__(obj2)
__lshift__(self,other)<<左移运算符等效的对应方法
在obj1 << obj2时调用obj1.__lshift__(obj2)
__rshift__(self,other)>>右移运算符等效的对应方法。
在obj1 >> obj2时调用obj1.__rshift__(obj2)
__invert__(self,other)~按位取反运算符等效的对应方法
在~obj时调用obj.__invert__()
  • 简单示例：
class A:
    def __init__(self,age=18):
        self.age = age

    def __repr__(self):
        return "(age = {})".format(self.age)

    def __add__(self,other):
        return A(self.age + other.age)

a1 = A(15)
a2 = A(18)
print(a1,a2,a1+a2)

class4_0012

3.反向运算符
  • 在obj1 + obj2中如果obj1不支持+操作，那么obj1.__add__(self,other)的返回值应该是NotImplemented，此时系统会调用obj2中的__radd__(self,other)方法来实现运算。即执行obj2.__radd__(obj1)
特殊方法运算符含义
以下示例中。按照__iadd__方法来举例：
obj1中必须没有定义对应的方法__add__。或者返回值为NotImplemented。才会调用obj2.__radd__(obj1)来完成运算
__radd__(self,other)+加法运算等效调用的对应方法
在obj1 + obj2时调用obj2.__radd__(obj1)
__rsub__(self,other)-减法运算等效调用的对应方法
在obj1 - obj2时调用obj2.__rsub__(obj1)
__rmul__(self,other)*乘法运算等效调用的对应方法
在obj1 * obj2时调用obj2.__rmul__(obj1)
__rtruediv__(self,other)/除法运算等效调用的对应方法
在obj1 / obj2时调用obj2.__rtruediv__(obj1)
__rmod__(self,other)%**取摸运算(取余数)**等效调用的对应方法
在obj1 % obj2时调用obj2.__rmod__(obj1)
__rfloordiv__(self,other)//整除运算(向下取整)等效调用的对应方法
在obj1 // obj2时调用obj2.__rfloordiv__(obj1)
__rpow__(self,other)**
pow(x,n)		次幂运算等效调用的对应方法。也等价于pow(x,n)方法
在obj1 ** obj2时调用obj2.__rpow__(obj1)
__rdivmod__(self,other)divmod(obj1,obj2)获取数的商和余数组成的元组等效的对应方法
如果obj1没有__divmod__方法，或者返回NotImplemented，则会调用obj2.__rdivmod__(obj1)
__rmatmul__(self,other)@矩阵运算符等效调用的对应方法
在obj1 @ obj2时调用obj2.__rmatmul__(obj1)
__rand__(self,other)&与运算符等效的对应方法
在obj1 & obj2时调用obj2.__rand__(obj1)
__ror__(self,other)|或运算符等效的对应方法
在obj1 | obj2时调用obj2.__ror__(obj1)
__rxor__(self,other)^异或运算符等效的对应方法
在obj1 ^ obj2时调用obj2.__rxor__(obj1)
__rlshift__(self,other)<<左移运算符等效的对应方法
在obj1 << obj2时调用obj2.__rlshift__(obj1)
__rrshift__(self,other)>>右移运算符等效的对应方法。
在obj1 >> obj2时调用obj2.__rrshift__(obj1)

  • 简单流程运行图：
    a+b

  • 简单示例：

class A:
    def __init__(self,age=18):
        self.age = age

    def __repr__(self):
        return "(age = {})".format(self.age)

    def __add__(self,other):
        return A(self.age + other.age)

    def __radd__(self,other):
        return A(self.age + other.age)

class B:
    def __init__(self,age= 18):
        self.age = age

    def __repr__(self):
        return "(age = {})".format(self.age)

a = A(10)
b = B(15)
print(a+b)
print(b+a)

class4_0013

4.赋值运算符的重载
特殊方法运算符含义
__iadd__(self,other)+=加等赋值运算等效调用的对应方法
在obj1 += obj2时调用obj1 = obj1.__iadd__(obj2)
__isub__(self,other)-=减等赋值运算等效调用的对应方法
在obj1 -= obj2时调用obj1 = obj1.__isub__(obj2)
__imul__(self,other)*=乘等赋值运算等效调用的对应方法
在obj1 *= obj2时调用obj1 = obj1.__imul__(obj2)
__itruediv__(self,other)/=除等赋值运算等效调用的对应方法
在obj1 /= obj2时调用obj1 = obj1.__itruediv__(obj2)
__imod__(self,other)%=取模等赋值运算等效调用的对应方法
在obj1 %= obj2时调用obj1 = obj1.__imod__(obj2)
__ifloordiv__(self,other)//=整除等赋值运算符等效调用的对应方法
在obj1 //= obj2时调用obj1 = obj1.__ifloordiv__(obj2)
__ipow__(self,other)**=次幂等运算符等效调用的对应方法
在obj1 **= obj2时调用obj1 = obj1.__ipow__(obj2)
__imatmul__(self,other)@=矩阵等赋值运算等效调用的对应方法
在obj1 @= obj2时调用obj1 = obj1.__imatmul__(obj2)
__iand__(self,other)&=与等赋值运算等效的对应方法
在obj1 &= obj2时调用obj1 = obj1.__iand__(obj2)
__ior__(self,other)|=或等赋值运算等效的对应方法
在obj1 |= obj2时调用obj1 = obj1.__ior__(obj2)
__ixor__(self,other)^=异或等赋值运算等效的对应方法
在obj1 ^= obj2时调用obj1 = obj1.__ixor__(obj2)
__ilshift__(self,other)<<=左移等赋值运算等效的对应方法
在obj1 <<= obj2时调用obj1 = obj1.__ilshift__(obj2)
__irshift__(self,other)>>=右移等赋值运算等效的对应方法
在obj1 >>= obj2时调用obj1 = obj1.__irshift__(obj2)
  • 注意：例如：obj1 += obj2中，如果obj1没有对应的加法赋值运算__iadd__那么等式会转换成obj1 = obj1 + obj2即obj1 = obj1.__add__(obj2)，其他赋值也同样适用。
  • 简单示例01：
class A:
    def __init__(self,age=18):
        self.age = age

    def __repr__(self):
        return "(age = {})".format(self.age)

    def __add__(self,other):
        return A(self.age + other.age)

    def __iadd__(self,other):
        self.age = self.age + other.age
        return self

a1 = A(15)
a2 = A(18)
print(a1,a2,a1+a2)
a1 += a2
print(a1)

class4_0014

  • 简单示例02：
class A:
    def __init__(self,age=18):
        self.age = age

    def __repr__(self):
        return "(age = {})".format(self.age)

    def __add__(self,other):
        return A(self.age + other.age)

a1 = A(15)
a2 = A(18)
print(a1,a2,a1+a2)
a1 += a2  #如果没有__iadd__方法，会转换成 a1 = a1+a2来调用
print(a1)

class4_015

  • 综合示例：完成Point类设计，实现判断点相等的方法，并完成向量的加法
    1. 在直角坐标系里面，定义原点为向量的起点。两个向量和与差的坐标分别等于这两个向量相应坐标的和与差若向量 的表示为(x,y)形式。
    2. A(X1,Y1) B(X2,Y2)，则A+B=（X1+X2，Y1+Y2），A-B=（X1-X2，Y1-Y2）
class Point:
    def __init__(self,x:int,y:int):
        self.x = x
        self.y = y

    def __add__(self,other):
        return Point(self.x+other.x,self.y+other.y)

    # def __iadd__(self,other):
    #     self.x += other.x
    #     self.y += other.y
    #     return self

    def __sub__(self,other):
        return Point(self.x-other.x,self.y-other.y)

    # def __isub__(self,other):
    #     self.x -= other.x
    #     self.y -= other.y
    #     return self

    def __repr__(self):
        return "<Point {},{}>".format(self.x,self.y)

p1 = Point(5,6)
p2 = Point(1,2)
print(p1+p2,p1-p2)
p1-=p2
print(p1)

class4_0016

运算符重载的应用场景

往往是用面向对象实现的类，需要做大量的运算，而运算符是这种运算在数学上最常见的表达方式。例如，上例中 的对+进行了运算符重载，实现了Point类的二元操作，重新定义为Point + Point。提供运算符重载，比直接提供加法方法要更加适合该领域内使用者的习惯。
int类，几乎实现了所有操作符，可以作为参考。

functools.total_ordering装饰器

__lt__ , __le__ , __eq__ , __gt__ , __ge__ 是比较大小必须实现的方法，但是全部写完太麻烦，使用 @functools.total_ordering 装饰器就可以大大简化代码。
但是要求 __eq__ 必须实现，其它方法 __lt__ , __le__ , __gt__ , __ge__ 实现其一

from functools import total_ordering

@total_ordering
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __eq__(self,other):
        return self.age == other.age
    
    def __gt__(self,other):
        return self.age > other.age
    
tom = Person("tom",20)
jerry = Person("jerry",16)
print(tom > jerry)
print(tom < jerry)
print(tom >= jerry)
print(tom <= jerry)

class4_0017

上例中大大简化代码，但是一般来说比较实现等于或者小于方法也就够了，其它可以不实现，所以这个装饰器只是 看着很美好，且可能会带来性能问题，建议需要什么方法就自己创建，少用这个装饰器。

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __eq__(self,other):
        return self.age == other.age
    
    def __gt__(self,other):
        return self.age >other.age
    
    def __ge__(self,other):
        return self.age >= other.age
    
tom = Person("tom",20)
jerry = Person("jerry",16)
print(tom > jerry)
print(tom < jerry)
print(tom >= jerry)
print(tom <= jerry)
print(tom == jerry)
print(tom != jerry)

class4_0018

  • __eq__等于可以推断不等于
  • __gt__大于可以推断小于
  • __ge__大于等于可以推断小于等于
    也就是用3个方法，就可以把所有比较解决了。

容器相关方法

方法对应的操作意义
__len__(self)len(obj)内建函数len()，返回对象的长度(>=0的整数)，如果把对象当做容器类型看，就如同list或者dict。
bool()函数调用的时候，如果没有__bool__()方法，则会看__len__()方法是否存在，存在返回非0为真。
__iter__(self)for i in obj迭代容器时，调用，返回一个新的可迭代对象
__contains__(self,item)x in objin 成员运算符，没有实现，就默认调用__iter__方法遍历
__getitem__(self,key)obj[key]实现self[key]访问。序列对象，key接受整数为索引，或者切片。对于set和dict,key为可以hashable(即可哈希)。key不存在引发KeyError异常
__setitem__(self,key)obj[key] = value和__getitem__的访问类似，是设置值的方法
__missing__(self,key)字典或其子类使用__getitem__()调用时，key不存在执行该方法
  • __missing__(self,key)例子：
class A(dict):
    def __missing__(self,key):
        print("键值对不存在。。{}".format(key))
        return 0

a = A()
a["a"] = 10
print(a["a"])
print(a["b"])

class4_0019

  • 简单综合示例：不使用继承，实现一个容器
class Goods:
    def __init__(self,name):
        self.name = name

    def __repr__(self):
        return "<Goods name = {}>".format(self.name)

class Cart:

    def __init__(self):
        self.__goods = list()

    def __len__(self):
        return len(self.__goods)

    def add(self,good:Goods):
        self.__goods.append(good)

    def __add__(self, other):
        self.add(other)
        return self

    def __iter__(self):
        # yield from self.__goods
        return iter(self.__goods)

    def __getitem__(self, item):
        return self.__goods[item]

    def __setitem__(self, key, value):
        self.__goods[key] = value

    def __repr__(self):
        return str(self.__goods)

gd = Goods("棒棒糖")
gd2 = Goods("宫保鸡丁")
cat = Cart() + gd + gd2
cat.add(Goods("火爆鸡精"))
print(cat)

class4_0020

可调用对象

Python中一切皆对象，函数也不例外。

def foo():
    print(foo.__module__,foo.__name__)

foo()
#等价于
foo.__call__()

class4_0021

函数即对象，对象foo加上()，就是调用此函数对象的 __call__() 方法

方法等效意义
__call__(self)obj()类中定义一个该方法，类的实例就可以像函数一样调用
  • 示例1：可调用对象，定义一个类，并实例化得到其实例，将实例像函数一样调用。
class Adder:
    def __call__(self,*args):
        self.sum = sum(args)
        return self.sum

adder = Adder()
print(adder(4,5,6,3,2))
print(adder.sum)

class4_0022

  • 示例2:定义一个斐波拉契数列，方便调用，计算第n项。
    1. 增加迭代的方法、返回容器长度、支持索引的方法。
class Xdd_Fib:
    """
    斐波拉契数列类，获取第num个位置的斐波拉契数列。
    """
    def __init__(self):
        self.fib = [0,1,1]

    def __len__(self):
        return len(self.fib)

    #类的实例可调用
    def __call__(self,num:int):
        if not isinstance(num,int):
            raise TypeError("num必须是int类型")
        if num<0:
            raise KeyError("选项错误，必须大于0")
        elif num<3:
            return self.fib[num]
        else:
            for i in range(len(self),num + 1):
                self.fib.append(self.fib[i-1]+self.fib[i-2])
        return self.fib[num]

    #类可迭代
    def __iter__(self):
        return iter(self.fib)

    def __repr__(self):
        return ",".join(map(str,self.fib))

    __str__ = __repr__
    __getitem__ = __call__ #类可以像数组一样访问

fib = Xdd_Fib()
print(fib(5),fib(6),fib(8))
print(fib)

class4_0023

带着梦想飞翔
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python之特殊属性、对象的浅拷贝和深拷贝
Calor13的博客
08-09 336
Python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。除了继承，“组合”也能实现代码的复用！“组合”核心是“将父类对象作为子类的属性”。浅拷贝：拷贝时，拷贝源对象，但对象包含的子对象内容不拷贝。深拷贝：拷贝时，拷贝源对象，也递归拷贝对象中包含的子对象。两人组合后，可以复用对方的属性和方法！函数，递归拷贝对象中包含的子对象。Python拷贝一般都是浅拷贝。
Python中魔术属性
weixin_44579563的博客
07-10 437
普通属性和魔术属性 普通属性都存储在__dict__属性中， 而魔术属性由Python决定存储位置，有的魔术属性有特殊的存储方式，而也有的跟普通属性一样存储在__dict__中。 魔术属性和普通属性的区别是魔术属性在解释器中有专门的处理函数， 比如__dict__的_PyObject_GetDictPtr等，__doc__的type_set_doc等为这些魔术属性进行特别的处理。 而普通属性是使用通用的函数处理。 我们可以用Python的源码中查找它们的定义和使用流程。 object和type源码 先看看o
python魔法方法意义_python魔法方法-属性转换和类的表示详解
weixin_39619858的博客
12-06 153
类型转换魔法类型转换魔法其实就是实现了str、int等工厂函数的结果，通常这些函数还有类型转换的功能，下面是一些相关的魔法方法：•__int__(self)•转换成整型，对应int函数。•__long__(self)•转换成长整型，对应long函数。•__float__(self)•转换成浮点型，对应float函数。•__complex__(self)•转换成 复数型，对应complex函数。•_...
python的特殊属性
最新发布
weixin_46713695的博客
09-01 236
python的__name__属性
python中self.__class__的用法详解
IT之一小佬的博客
08-01 4186
python中self.__class__的用法详解
Python入门--特殊属性
周周的博客
03-14 1448
#特殊方法和特殊属性 #特殊属性 --> __dict__ --> 获得类对象或实例对象所绑定的所有属性和方法的字典 #特殊方法 #1.__len__() --> 通过重写__len__()方法，让内置函数len()的 参数可以是自定义类型 #2.__add__() --> 通过重写__add__()方法，可使自定义对象具有“+”功能 #3.__new__() --> 用于创建对象 #4.__init__() --> 对创建的对象进行初始化 class A: p.
python 类的特殊成员（属性和方法）
幽雨雨幽
12-13 592
在 Python 类中有些方法名、属性名的前后都添加了双下画线，这种方法、属性通常都属于 Python 的特殊方法和特殊属性，开发者可以通过重写这些方法或直接调用这些方法来实现特殊的功能。 最常见的特殊方法就是前面介绍的构造方法：__init__，开发者可以通过重写类中的 __init__ 方法来实现自己的初始化逻辑。 Python 是一门尽量简单的语言，它不像某些语言（如 Java）需要让类实现...
python中的特殊属性
野马
07-07 947
# animal.py class Animal: x = 123 def __init__(self, name): self.name = name self.age = 20 self.weight = 20 y = 200 print('animal Module\'s names = {}'.format(dir(...
Python中特殊方法 与 特殊属性
LittleBridLibrary的博客
11-24 234
名称 描述 特殊属性 __ dict __ 获得类对象或实例对象所绑定的所有属性和方法的字典 特殊方法 __ len__() 通过重写__len__() 方法，让内置函数len()的参数可以是自定义类型 __ add__() 通过重写__add()__方法，可使用自定义对象具有“+”的功能 __ new__() 用于创建对象 __ init__() 对创建的对象进行初始化 ...
Python"隐藏"方法
MeteoriteMan的博客
04-16 6410
如果是公有方法的条件下，我们想调用Python的方法都可以实例化之后随意调用。 试想，如果我们是这么个情况。做过移动开发的都知道，收费接口很多，比如我们做一个直播类的应用。那么这个接口肯定是按流量收费的。 如果我们比如类是如下情况定义的： class zhibo: #公有方法 def zhibo(self): return start#假如 return ...
2 python特殊方法与特殊属性
weixin_37895393的博客
04-23 227
python特殊方法与特殊属性 一些理解 对于Python中的属性和方法，可以通过下划线”_”来实现一定程的私有化： “_”：以单下划线开头只能允许其本身与子类进行访问，(起到一个保护的作用) “__”：双下划线的表示的是私有类型的变量，只允许在本类中访问 python中私有 更多的是一种规范/约定，没有真正达到限制的目的 通过 _className__xxx还是可以访问到私有...
实现PVNet时踩的坑
weixin_44715231的博客
11-29 3131
记录一下在跑通pvnet时踩的各种坑 pvnet 代码地址：https://github.com/zju3dv/pvnet pvnet-rendering 代码地址：https://github.com/zju3dv/pvnet-rendering 1.执行 python lib/utils/data_utils.py： 报错1： Traceback (most recent call last): File "lib/utils/data_utils.py", line 18, in <mo
python类属性访问魔法方法
l_vip的博客
11-18 1111
python类属性访问魔法方法 本文主要讲述类(python3.6)属性访问的魔法方法: __get__, __getattr__, __getattribute__, ___set__, __setattr__ （本文对类属性和实例属性不加严谨的表述） 1. __getattr__, __setattr__ 先定义一个类: class Person(object): name = ''...
python之特殊属性和特殊方法
氮气蜗牛的博客
05-21 695
前面分享完了面对对象的三大特征：封装、继承和多态之后，我们再来看一下特殊属性和特殊方法
python的特殊类_Python类的特殊性质和方法,python,属性
weixin_42569329的博客
02-21 196
python类有很多内建的属性和方法，可以通过dir查看，这些属性是系统自带的，不需要额外导入包；见下图1这些变量都是全局变量，可以用globals()查看当前系统可用的全局变量!!!但这个和python类的内建函数不是同一个概念，见下面的代码>>> globals(){'__name__': '__main__', '__doc__': None, '__package__':...
python中魔法属性(魔术方法)与property属性
托尼stark的博客
04-22 468
1 __doc__:表示类的描述信息 class Foo: """描述类的信息""" def fun(self): pass print(Foo.__doc__) 2 __module__:表示当前操作的对象在那个模块，__class__:表示当前操作的对象的类是什么 #test.py #coding=utf-8 class Person(objec...
python类之特殊属性和魔术方法
cahangyu3700的博客
07-22 202
一 python特殊属性 1 总述 属性 含义 _name_ 类，函数，方法等的名字 _module_ 类定义所现在的模块名 _class_ 对象或类所属的类 _bases_ 类的基类的元素，顺序为他们在基类列表中出现的顺序 _doc_ 类/函数的文档字符传，如果没有定义则为None _mro_ 类的mro,class.mro()返回 _dict_ 类或实例...
Python的魔术方法——构造函数、特殊属性、特殊方法与应用模块
SUOYUEのBLOG
09-06 672
Python 类的构造函数 特殊属性 特殊方法 应用模块
python类（class）常用的魔术方法
亮亮的分享
07-23 580
1、类__init__(self) 构造方法 2、类__new__(cls, *args, **kwargs) 对象实例化方法，其实这才是类里面第一个被调用的方法，在构造函数之前调用，之后才是__init__，只是这个比较特殊，一般不使用。 #案例1： class A(object): def __new__(cls, *args, **kwargs): cls.age = 1 # 可以重写添加属性，方法，参数 return cls #必须返回cls,后续类的方法才能被调用 3、类__ca
Python类的特殊方法与定制技术详解
在Python中，特殊方法（也称为魔术方法）是实现特定行为的关键工具，它们允许程序员按照自己的需求定制类的行为。例如，`__init__`方法是构造器，当创建类的实例时会被自动调用，用于初始化对象的属性。而`__del__`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值