關(guān)于Python中object類特殊方法的解釋

更新時間：2023年03月28日 14:59:31 作者：Python?學(xué)習(xí)者

在學(xué)習(xí)Python的過程中我們會發(fā)現(xiàn)有一個類?Object類?,它是所有類的父類,Object類規(guī)定了python用于類的內(nèi)置函數(shù),今天我們就來看看幾個常用的特殊方法吧

一、object類的源碼

class object:
    """ The most base type """

    # del obj.xxx或delattr(obj,'xxx')時被調(diào)用，刪除對象中的一個屬性
    def __delattr__(self, *args, **kwargs):  # real signature unknown
        """ Implement delattr(self, name). """
        pass

    # 對應(yīng)dir(obj)，返回一個列表，其中包含所有屬性和方法名（包含特殊方法）
    def __dir__(self, *args, **kwargs):  # real signature unknown
        """ Default dir() implementation. """
        pass

    # 判斷是否相等 equal ，在obj==other時調(diào)用。如果重寫了__eq__方法，則會將__hash__方法置為None
    def __eq__(self, *args, **kwargs):  # real signature unknown
        """ Return self==value. """
        pass

    # format(obj)是調(diào)用，實現(xiàn)如何格式化obj對象為字符串
    def __format__(self, *args, **kwargs):  # real signature unknown
        """ Default object formatter. """
        pass

    # getattr(obj,'xxx')、obj.xxx時都會被調(diào)用，當(dāng)屬性存在時，返回值，不存在時報錯（除非重寫__getattr__方法來處理）。
    # 另外，hasattr(obj,'xxx')時也會被調(diào)用（估計內(nèi)部執(zhí)行了getattr方法）
    def __getattribute__(self, *args, **kwargs):  # real signature unknown
        """ Return getattr(self, name). """
        pass

    # 判斷是否大于等于 greater than or equal，在obj>=other時調(diào)用
    def __ge__(self, *args, **kwargs):  # real signature unknown
        """ Return self>=value. """
        pass

    # 判斷是否大于 greater than，在obj>other時調(diào)用
    def __gt__(self, *args, **kwargs):  # real signature unknown
        """ Return self>value. """
        pass

    # 調(diào)用hash(obj)獲取對象的hash值時調(diào)用
    def __hash__(self, *args, **kwargs):  # real signature unknown
        """ Return hash(self). """
        pass

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

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

    # object構(gòu)造函數(shù)，當(dāng)子類沒有構(gòu)造函數(shù)時，會調(diào)用object的__init__構(gòu)造函數(shù)
    def __init__(self):  # known special case of object.__init__
        """ Initialize self.  See help(type(self)) for accurate signature. """
        pass

    # 判斷是否小于等于 less than or equal，在obj<=other時調(diào)用
    def __le__(self, *args, **kwargs):  # real signature unknown
        """ Return self<=value. """
        pass

    # 判斷是否小于 less than，在obj<other時調(diào)用
    def __lt__(self, *args, **kwargs):  # real signature unknown
        """ Return self<value. """
        pass

    # 創(chuàng)建一個cls類的對象，并返回
    @staticmethod  # known case of __new__
    def __new__(cls, *more):  # known special case of object.__new__
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    # 判斷是否不等于 not equal,在obj!=other時調(diào)用
    def __ne__(self, *args, **kwargs):  # real signature unknown
        """ Return self!=value. """
        pass

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

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

    # 如果不重寫__str__，則__repr__負(fù)責(zé)print(obj)和交互式命令行中輸出obj的信息
    # 如果重寫了__str__，則__repr__只負(fù)責(zé)交互式命令行中輸出obj的信息
    def __repr__(self, *args, **kwargs):  # real signature unknown
        """ Return repr(self). """
        pass

    # 使用setattr(obj,'xxx',value)、obj.xxx=value是被調(diào)用（注意，構(gòu)造函數(shù)初始化屬性也要調(diào)用）
    def __setattr__(self, *args, **kwargs):  # real signature unknown
        """ Implement setattr(self, name, value). """
        pass

    # 獲取對象內(nèi)存大小
    def __sizeof__(self, *args, **kwargs):  # real signature unknown
        """ Size of object in memory, in bytes. """
        pass

    # 設(shè)置print(obj)打印的信息，默認(rèn)是對象的內(nèi)存地址等信息
    def __str__(self, *args, **kwargs):  # real signature unknown
        """ Return str(self). """
        pass

    @classmethod  # known case
    def __subclasshook__(cls, subclass):  # known special case of object.__subclasshook__
        """
        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
    # 某個對象是由什么類創(chuàng)建的，如果是object，則是type類<class 'type'>
    __class__ = None
    # 將對象中所有的屬性放入一個字典，例如{'name':'Leo','age':32}
    __dict__ = {}
    # 類的doc信息
    __doc__ = ''
    # 類屬于的模塊,如果是在當(dāng)前運行模塊，則是__main__，如果是被導(dǎo)入，則是模塊名（即py文件名去掉.py）
    __module__ = ''

二、常用特殊方法解釋

1.getattribute方法

1）什么時候被調(diào)用

這個特殊方法是在我們使用類的對象進(jìn)行obj.屬性名或getattr(obj,屬性名)來取對象屬性的值的時候被調(diào)用。

例如：

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)  # name屬性存在  或者 getattr(f,name)
    print(f.age)  # age屬性不存在

不管屬性是否存在，__getattribute__方法都會被調(diào)用。如果屬性存在，則返回該屬性的值，如果屬性不存在，則返回None。

注意，我們在使用hasattr(obj,屬性名)來判斷某個屬性是否存在時，__getattribute__方法也會被調(diào)用。

2）與getattr的區(qū)別

我們在類的實現(xiàn)中，可以重寫__getattr__方法，那么__getattr__方法和__getattribute__方法有什么區(qū)別？？

我們知道__getattribute__方法不管屬性是否存在，都會被調(diào)用。而__getattr__只在屬性不存在時調(diào)用，默認(rèn)會拋出 AttributeError: ‘Foo’ object has no attribute ‘age’ 這樣的錯誤，但我們可以對其進(jìn)行重寫，做我們需要的操作：

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)  # name屬性存在
    print(f.age)  # age屬性不存在,但__getattr__方法返回了54，所以這里打印54。

返回結(jié)果：

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

我們看到，f.name和f.age都調(diào)用了__getattribute__方法，但是只有f.age時調(diào)用了__getattr__方法。所以，我們可以利用__getattr__做很多事情，例如從類中的一個字典中取值，或者處理異常等。

2.setattr方法

當(dāng)我們執(zhí)行obj.name='alex’或setattr(obj,屬性名,屬性值)，即為屬性賦值時被調(diào)用。

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

    # obj.xxx = value時調(diào)用
    def __setattr__(self, key, value):
        print('setattr')
        return object.__setattr__(self, key, value)


if __name__ == '__main__':
    f = Foo()
    f.name = 'Jone'  # 打印setattr
    print(f.name)

如果__setattr__被重寫（不調(diào)用父類__setattr__的話）。則使用obj.xxx=value賦值就無法工作了。

特別注意，在類的構(gòu)造函數(shù)中對屬性進(jìn)行初始化賦值時也是調(diào)用了該方法：

class Foo(object):
    def __init__(self):
        self.name = 'Alex'  # 這里也要調(diào)用__setattr__
　　...

當(dāng)我們需要重寫__setattr__方法的時候，就要注意初始化時要使用object類的__setattr__來初始化：

class Local(object):
    def __init__(self):
        # 這里不能直接使用self.DIC={}，因為__setattr__被重寫了
        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'  # 向DIC字典中存入值
    print(obj.name)  # 從DIC字典中取出值

3.`delattr`方法

這個方法對應(yīng)del obj.屬性名和delattr(obj,屬性名)兩種操作時被調(diào)用。即，刪除對象中的某個屬性。

if hasattr(f,'xxx'):  # 判斷f對象中是否存在屬性xxx
    delattr(f, 'xxx')  # 如果存在則刪除。當(dāng)xxx不存在時刪除會報錯
    # del f.xxx  # 同上

4.`dir`方法

對應(yīng)dir(obj)獲取對象中所有的屬性名，包括所有的屬性和方法名。

f = Foo()
print(f.__dir__())  # ['name', '__module__', '__init__', '__setattr__', '__getattribute__', '__dir__', '__dict__', '__weakref__', '__doc__', '__repr__', '__hash__', '__str__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__class__']

返回一個列表。

5.`eq`和`hash`

__eq__是判斷obj==other的時候調(diào)用的，默認(rèn)調(diào)用的是object繼承下去的__eq__。

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

默認(rèn)情況下，f1 == f2,f1 is f2,hash(f1)==hash(f2)都應(yīng)該同時為True（或不相等，同為False）。

如果我們重寫了__eq__方法，例如兩個對象的比較變成比較其中的一個屬性：

class Foo(object):
    def __init__(self):
        self.name = 'Alex'  # 這里也要調(diào)用__
        self.ccc = object.__class__
    def __eq__(self, other):
        return self.name==other.name

即，如果self.name==other.name，則認(rèn)為對象相等。

f1 = Foo()
f2 = Foo()
print(f1 == f2)  # True
print(f1 is f2)  # False
print(hash(f1) == hash(f2))  # 拋出異常TypeError錯誤

為什么hash會拋出異常，這是因為如果我們在某個類中重寫了__eq__方法，則默認(rèn)會將__hash__=None。所以，當(dāng)我們調(diào)用hash(obj)時，__hash__方法無法執(zhí)行。

總結(jié)：

當(dāng)我們實現(xiàn)的類想成為不可hash的類，則可以重寫__eq__方法，然后不重寫__hash__，__hash__方法會被置None，該類的對象就不可hash了。

默認(rèn)提供的__hash__方法（hash(obj)）對于值相同的變量（類型有限制，有些類型不能hash，例如List），同解釋器下hash值相同，而不同解釋器下hash值不同。所以，如果我們想要hash一個目標(biāo)，應(yīng)該使用hashlib模塊。

hash和id的區(qū)別，理論上值相同的兩個對象hash值應(yīng)該相同，而id可能不同（必須是同一個對象，即內(nèi)存地址相同，id才相同。id(obj)是obj的唯一標(biāo)識。）

6.`gt、lt、ge、le`

這幾個都是用于比較大小的，我們可以對其進(jìn)行重寫，來自定義對象如何比較大?。ɡ缰槐容^對象中其中一個屬性的值）。

7.`str`和`repr`

__str__用于定義print(obj)時打印的內(nèi)容。

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

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


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

在命令行下：

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

可以看到，使用__str__的話，print可以打印我們指定的值，而命令行輸出則是對象的內(nèi)存地址。

__repr__用于同時定義python命令行輸出obj的內(nèi)容，以及print(obj)的打印內(nèi)容（前提是沒有重寫__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和直接輸出都打印了我們指定的值。

當(dāng)我們同時重寫__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__負(fù)責(zé)print的信息，而__repr__負(fù)責(zé)命令行直接輸出的信息。

8.new方法

__new__方法是一個靜態(tài)方法，在調(diào)用時，傳入你需要實例化的類名以及初始化參數(shù)列表。

例如：

class Foo(object):
    """
    這是一個類，名叫Foo
    """
    # 后于__new__方法執(zhí)行，為__new__方法生成的對象進(jìn)行初始化
    def __init__(self, name, age):  # __new__返回的對象作為self傳入__init__
        print("執(zhí)行__init__方法")
        self.name = name
        self.age = age

    # __new__方法先于__init__方法執(zhí)行，用于生成一個指定類的對象
    def __new__(cls, *args, **kwargs):  # 接收參數(shù)cls為Foo類，然后從f1 = Foo("Alex",age=32)里的name和age
        print("執(zhí)行__new__方法")
        ret = object.__new__(cls)  # 調(diào)用__new__生成一個Foo對象
        print(ret)  # 打印<__main__.Foo object at 0x000001AD868F8668>
        return ret  # 返回生成的Foo對象

注意一下幾點：

1）__new__在object被指定為@staticmethod，但更像是一個@classmethod，第一個參數(shù)傳入類本身cls。

2）__new__在__init__之前運行，為傳入的類（Foo）生成一個實例并返回。

3）__init__在__new__之后執(zhí)行，為__new__返回的類實例進(jìn)行初始化。

4）__init__是一個實例方法，是由實例來調(diào)用的。所以要執(zhí)行__init__方法，必須先要由__new__生產(chǎn)一個實例。這就是為什么先執(zhí)行__new__方法的原因。

9.sizeof方法

這里注意兩個獲取占用內(nèi)存空間的方法，一個就是對象的__sizeof__方法，另一個是sys.getsizeof方法，sys.getsizeof方法中調(diào)用了對應(yīng)對象的__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)
    # 使用__sizeof__方法，不管帶不帶屬性，都是固定大小32
    print(without_attr.__sizeof__())  # 打印32
    print(with_attr.__sizeof__())  # 打印32
    # 使用sys.getsizeof方法，不管帶不帶屬性，都是固定大小56
    print(sys.getsizeof(without_attr))  # 打印56
    print(sys.getsizeof(with_attr))  # 打印56

我們可以看到，sys.getsizeof方法的值比__sizeof__的值大24。這24個bytes應(yīng)該是gc管理所消耗的空間。

而且這兩個方法的返回值大小都沒有包含對象中的屬性，也就是說在垃圾回收的時候，除了通過getsizeof方法獲取對象本身大小，還要額外通過其他辦法去獲取其屬性的大小，并進(jìn)行回收。

觀察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__())  # 打印88
print(sys.getsizeof(list1))  # 打印112，比__sizeof__多24
print(sys.getsizeof(list2))  # 打印120，多一個int，多占8bytes
print(sys.getsizeof(list3))  # 打印128，多一個字符串，也多占8bytes
print(sys.getsizeof(list4))  # 打印128，多一個對象，也多占8bytes

同樣的，getsizeof()比__sizeof__多24bytes。而列表中，每多一個元素（不管什么類型）都多占8bytes，我們可以猜想這8bytes是64bit機(jī)器中一個指針的大小。所以，getsizeof和__sizeof__都是只獲取list第一層的內(nèi)存占用。當(dāng)然，這兩個方法內(nèi)部所包含的空間根據(jù)實現(xiàn)是不同的。

10.`class、dict、module、doc`屬性

__class__：返回該生成該對象的類

print(f1.__class__) # <class '__main__.Foo'>

__dict__：返回該對象的所有屬性組成的字典

print(f1.__dict__) # {'name': 'Alex'} 只有一個屬性name

__module__：返回該對象所處模塊

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


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

如果該對象對應(yīng)的類在當(dāng)前運行的模塊，則打印__main__。

import test3

f = test3.Foo()
print(f.__module__)  # 打印test3

如果對象對應(yīng)的類在其他模塊，則打印模塊名。

__doc__：類的注釋說明

class Foo(object):
    """
    這是一個類，名叫Foo
    """
    def __init__(self):
        self.name = 'Alex'


if __name__ == '__main__':
    f1 = Foo()
    print(f1.__doc__)  # 打印 這是一個類，名叫Foo

到此這篇關(guān)于關(guān)于Python中object類特殊方法的解釋的文章就介紹到這了,更多相關(guān)Python中object類特殊方法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

關(guān)于Python中object類特殊方法的解釋

目錄

一、object類的源碼

二、常用特殊方法解釋

1.getattribute方法

1）什么時候被調(diào)用

2）與getattr的區(qū)別

2.setattr方法

3.`delattr`方法

4.`dir`方法

5.`eq`和`hash`

總結(jié)：

6.`gt、lt、ge、le`

7.`str`和`repr`

8.new方法

9.sizeof方法

10.`class、dict、module、doc`屬性

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

關(guān)于Python中object類特殊方法的解釋

目錄

一、object類的源碼

二、常用特殊方法解釋

1.__getattribute__方法

1）什么時候被調(diào)用

2）與__getattr__的區(qū)別

2.__setattr__方法

3.__delattr__方法

4.__dir__方法

5.__eq__和__hash__

總結(jié)：

6.__gt__、__lt__、__ge__、__le__

7.__str__和__repr__

8.__new__方法

9.__sizeof__方法

10.__class__、__dict__、__module__、__doc__屬性

相關(guān)文章

最新評論

大家感興趣的內(nèi)容

最近更新的內(nèi)容

常用在線小工具

一、object類的源碼

二、常用特殊方法解釋

1.getattribute方法

2）與getattr的區(qū)別

2.setattr方法

3.`delattr`方法

4.`dir`方法

5.`eq`和`hash`

6.`gt、lt、ge、le`

7.`str`和`repr`

8.new方法

9.sizeof方法

10.`class、dict、module、doc`屬性