更加适合python小白的object类的特殊方法~

206 篇文章 10 订阅
138 篇文章 8 订阅

人生苦短, 我用python

python 安装包+资料:点击此处跳转文末名片获取

在这里插入图片描述

一、object类的源码

class object:
    """ The most base type """
    def __delattr__(self, *args, **kwargs):   signature unknown
        """ Implement delattr(self, name). """
        pass
    def __dir__(self, *args, **kwargs):  
        """ Default dir() implementation. """
        pass

    def __eq__(self, *args, **kwargs): 
        """ Return self==value. """
        pass

    def __format__(self, *args, **kwargs):  # real signature unknown
        """ Default object formatter. """
        pass


    def __getattribute__(self, *args, **kwargs): 
        """ Return getattr(self, name). """
        pass


    def __ge__(self, *args, **kwargs):  
        """ Return self>=value. """
        pass


    def __gt__(self, *args, **kwargs):  
        """ Return self>value. """
        pass


    def __hash__(self, *args, **kwargs):  
        """ Return hash(self). """
        pass

    def __init_subclass__(self, *args, **kwargs):  
        """
        This method is called when a class is subclassed.

        The default implementation does nothing. It may be
        overridden to extend subclasses.
        """
        pass

    def __init__(self):
        """ Initialize self.  See help(type(self)) for accurate signature. """
        pass

    def __le__(self, *args, **kwargs):  
        """ Return self<=value. """
        pass


    def __lt__(self, *args, **kwargs):  
        """ Return self<value. """
        pass

    def __new__(cls, *more): 
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass


    def __ne__(self, *args, **kwargs):  
        """ Return self!=value. """
        pass

    def __reduce_ex__(self, *args, **kwargs): 
        """ Helper for pickle. """
        pass

    def __reduce__(self, *args, **kwargs): 
        """ Helper for pickle. """
        pass


    def __repr__(self, *args, **kwargs):  
        """ Return repr(self). """
        pass

    def __setattr__(self, *args, **kwargs):  
        """ Implement setattr(self, name, value). """
        pass

    def __sizeof__(self, *args, **kwargs):  
        """ Size of object in memory, in bytes. """
        pass

    def __str__(self, *args, **kwargs): 
        """ Return str(self). """
        pass

    @classmethod  # known case
    def __subclasshook__(cls, subclass): 
        """
        Abstract classes can override this to customize issubclass().

        This is invoked early on by abc.ABCMeta.__subclasscheck__().
        It should return True, False or NotImplemented.  If it returns
        NotImplemented, the normal algorithm is used.  Otherwise, it
        overrides the normal algorithm (and the outcome is cached).
        """
        pass
    __class__ = None
    __dict__ = {}
    __doc__ = ''
    __module__ = ''

二、常用特殊方法解释

1.__getattribute__方法

1)什么时候被调用

这个特殊方法是在我们使用类的对象进行obj.属性名
或getattr(obj,属性名)
来取对象属性的值的时候被调用。

例如:

class Foo(object):
    def __init__(self):
        self.name = 'Alex'

    def __getattribute__(self, item):
        print("__getattribute__ in Foo")
        return object.__getattribute__(self, item)


if __name__ == '__main__':
    f = Foo()
    print(f.name) 
    print(f.age)  

不管属性是否存在,
__getattribute__方法都会被调用。
如果属性存在,则返回该属性的值,
如果属性不存在,则返回None。

注意,
我们在使用hasattr(obj,属性名)来判断某个属性是否存在时,
__getattribute__方法也会被调用。

2)与__getattr__的区别

我们在类的实现中,
可以重写__getattr__方法,
那么__getattr__方法和__getattribute__方法有什么区别??

我们知道__getattribute__方法不管属性是否存在,
都会被调用。

而__getattr__只在属性不存在时调用,
默认会抛出 AttributeError: ‘Foo’ object has no attribute ‘age’
这样的错误,
但我们可以对其进行重写,
做我们需要的操作:

class Foo(object):
    def __init__(self):
        self.name = 'Alex'

    def __getattribute__(self, item):
        print("__getattribute__ in Foo")
        return object.__getattribute__(self, item)

    def __getattr__(self, item):
        print("%s不存在,但我可以返回一个值" % item)
        return 54


if __name__ == '__main__':
    f = Foo()
    print(f.name) 
    print(f.age)  

返回结果:

__getattribute__ in Foo
Alex
__getattribute__ in Foo
age不存在,但我可以返回一个值
54

我们看到,
f.name和f.age都调用了__getattribute__方法,
但是只有f.age时调用了__getattr__方法。
所以,我们可以利用__getattr__做很多事情,
例如从类中的一个字典中取值,
或者处理异常等。

2.__setattr__方法
当我们执行obj.name='alex’或setattr(obj,属性名,属性值),
即为属性赋值时被调用。

class Foo(object):
    def __init__(self):
        self.name = 'Alex'

    def __setattr__(self, key, value):
        print('setattr')
        return object.__setattr__(self, key, value)


if __name__ == '__main__':
    f = Foo()
    f.name = 'Jone' 
    print(f.name)

如果__setattr__被重写(不调用父类__setattr__的话)。
则使用obj.xxx=value赋值就无法工作了。

特别注意,
在类的构造函数中对属性进行初始化赋值时也是调用了该方法:

class Foo(object):
    def __init__(self):
        self.name = 'Alex' 
  ...

当我们需要重写__setattr__方法的时候,
就要注意初始化时要使用object类的__setattr__来初始化:

class Local(object):
    def __init__(self):
       
        object.__setattr__(self, 'DIC', {})

    def __setattr__(self, key, value):
        self.DIC[key] = value

    def __getattr__(self, item):
        return self.DIC.get(item, None)


if __name__ == '__main__':
    obj = Local()
    obj.name = 'Alex'  
    print(obj.name) 

3.__delattr__方法

这个方法对应del obj.属性名
和delattr(obj,属性名)两种操作时被调用。
即,删除对象中的某个属性。

4.__dir__方法

对应dir(obj)获取对象中所有的属性名,
包括所有的属性和方法名。

f = Foo()
print(f.__dir__()) 

返回一个列表。

5.eq__和__hash
eq__是判断obj==other的时候调用的,
默认调用的是object继承下去的__eq

f1 = Foo()
f2 = f1
print(f1 == f2) 
print(f1 is f2)  
print(hash(f1) == hash(f2)) 

默认情况下,
f1 == f2,f1 is f2,hash(f1)==hash(f2)
都应该同时为True(或不相等,同为False)。

如果我们重写了__eq__方法,
例如两个对象的比较变成比较其中的一个属性:

class Foo(object):
    def __init__(self):
        self.name = 'Alex' 
        self.ccc = object.__class__
    def __eq__(self, other):
        return self.name==other.name

即,如果self.name==other.name,
则认为对象相等。

f1 = Foo()
f2 = Foo()
print(f1 == f2)  # True
print(f1 is f2)  # False
print(hash(f1) == hash(f2))  

为什么hash会抛出异常,这是因为如果我们在某个类中重写了__eq__方法,则默认会将__hash__=None。所以,当我们调用hash(obj)时,__hash__方法无法执行。

总结:

当我们实现的类想成为不可hash的类,则可以重写__eq__方法,然后不重写__hash__,__hash__方法会被置None,该类的对象就不可hash了。

默认提供的__hash__方法(hash(obj))对于值相同的变量(类型有限制,有些类型不能hash,例如List),同解释器下hash值相同,而不同解释器下hash值不同。所以,如果我们想要hash一个目标,应该使用hashlib模块。

hash和id的区别,理论上值相同的两个对象hash值应该相同,而id可能不同(必须是同一个对象,即内存地址相同,id才相同。id(obj)是obj的唯一标识。)

6.gtltgele
这几个都是用于比较大小的,我们可以对其进行重写,来自定义对象如何比较大小(例如只比较对象中其中一个属性的值)。

7.str__和__repr
__str__用于定义print(obj)时打印的内容。

class Foo(object):
    def __init__(self):
        self.name = 'Alex'

    def __str__(self):
        return "我是Foo"


if __name__ == '__main__':
    f1 = Foo()
    print(f1)  

在命令行下:

>>> class Foo(object):
...     def __str__(self):
...             return "我是Foo"
...
>>> f1 = Foo()
>>> print(f1)
我是Foo
>>> f1
<__main__.Foo object at 0x0000023BF701C550>

可以看到,使用__str__的话,
print可以打印我们指定的值,
而命令行输出则是对象的内存地址。

repr__用于同时定义python命令行输出obj的内容,
以及print(obj)的打印内容(前提是没有重写__str
)。

class Foo(object):
    def __init__(self):
        self.name = 'Alex'

    def __repr__(self):
        return "我是Foo"


if __name__ == '__main__':
    f1 = Foo()
    print(f1)  # 打印 我是Foo

在命令行下:

>>> class Foo(object):
...     def __repr__(self):
...             return "我是Foo"
...
>>> f1 = Foo()
>>> print(f1)
我是Foo
>>> f1
我是Foo

可以看到,我们只重写了__repr__,
但是print和直接输出都打印了我们指定的值。

当我们同时重写__str__和__repr__时:

>>> class Foo():
...     def __str__(self):
...             return "我是Foo---str"
...     def __repr__(self):
...             return "我是Foo---repr"
...
>>> f1 = Foo()
>>> print(f1)
我是Foo---str
>>> f1
我是Foo---repr

可以看到,在同时重写两个方法时,
__str__负责print的信息,
而__repr__负责命令行直接输出的信息。

8.__new__方法

__new__方法是一个静态方法,
在调用时,
传入你需要实例化的类名以及初始化参数列表。

例如:

class Foo(object):
    """
    这是一个类,名叫Foo
    """
    def __init__(self, name, age):  
        print("执行__init__方法")
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):  
        print("执行__new__方法")
        ret = object.__new__(cls)  
        print(ret)  
        return ret 

注意一下几点:

1)__new__在object被指定为@staticmethod,但更像是一个@classmethod,第一个参数传入类本身cls。

2)__new__在__init__之前运行,为传入的类(Foo)生成一个实例并返回。

3)__init__在__new__之后执行,为__new__返回的类实例进行初始化。

4)__init__是一个实例方法,是由实例来调用的。所以要执行__init__方法,必须先要由__new__生产一个实例。这就是为什么先执行__new__方法的原因。

9.__sizeof__方法
这里注意两个获取占用内存空间的方法,
一个就是对象的__sizeof__方法,
另一个是sys.getsizeof方法,
sys.getsizeof方法中调用了对应对象的__sizeof__方法。

我们通过实验,看看这另个方法有什么不同:

class WithoutAttr(object):
    pass

class WithAttr(object):

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

if __name__ == '__main__':
    without_attr = WithoutAttr()
    with_attr = WithAttr("Alex", age=32)
    print(without_attr.__sizeof__()) 
    print(with_attr.__sizeof__())  
    print(sys.getsizeof(without_attr))  
    print(sys.getsizeof(with_attr)) 

我们可以看到,
sys.getsizeof方法的值比__sizeof__的值大24。
这24个bytes应该是gc管理所消耗的空间。

而且这两个方法的返回值大小都没有包含对象中的属性,
也就是说在垃圾回收的时候,
除了通过getsizeof方法获取对象本身大小,
还要额外通过其他办法去获取其属性的大小,
并进行回收。

观察list对象的占用空间:

list1 = [1, 2, 3, 4, 5, 6]
list2 = [1, 2, 3, 4, 5, 6, 7]
list3 = [1, 2, 3, 4, 5, 6, 7, 'string']
list4 = [1, 2, 3, 4, 5, 6, 7, Foo('Leo', age=32)]
print(list1.__sizeof__()) 
print(sys.getsizeof(list1))  
print(sys.getsizeof(list2))  
print(sys.getsizeof(list3))  
print(sys.getsizeof(list4))  

同样的,getsizeof()比__sizeof__多24bytes。
而列表中,每多一个元素(不管什么类型)都多占8bytes,
我们可以猜想这8bytes是64bit机器中一个指针的大小。
所以,
getsizeof和__sizeof__都是只获取list第一层的内存占用。
当然,
这两个方法内部所包含的空间根据实现是不同的。

10.classdictmodule、__doc__属性
class:返回该生成该对象的类

dict:返回该对象的所有属性组成的字典

print(f1.__dict__) 

module:返回该对象所处模块

class Foo(object):
    def __init__(self):
        self.name = 'Alex'


if __name__ == '__main__':
    f1 = Foo()
    print(f1.__module__)  # 打印__main__

如果该对象对应的类在当前运行的模块,
则打印__main__。

import test3

f = test3.Foo()
print(f.__module__)  

如果对象对应的类在其他模块,则打印模块名。

doc:类的注释说明

class Foo(object):
    """
    这是一个类,名叫Foo
    """
    def __init__(self):
        self.name = 'Alex'


if __name__ == '__main__':
    f1 = Foo()
    print(f1.__doc__)  

在这里插入图片描述


👇问题解答 · 源码获取 · 技术交流 · 抱团学习请联系👇

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值