全面理解python命名空間字典

更新時(shí)間：2023年12月29日 10:04:24 作者：梯閱線條

本文主要介紹了全面理解python命名空間字典,python的命名空間由字典實(shí)現(xiàn),屬性為鍵,對(duì)象為值,通過(guò)屬性找到對(duì)象,下面就來(lái)具體了解一下,感興趣的可以了解一下

1.1 dict

__dict__為類和實(shí)例的屬性字典—命名空間字典，通過(guò)字典找到屬性指向的對(duì)象。

實(shí)例無(wú)本身屬性則為空字典。

>>> class MySuper:
    s='梯閱線條'
    def m1(self):
        self.data1='MySuper'
>>> class MyClassA(MySuper):
    def __init__(self):
        self.data2='MyClassA'

# 類名.__dict__ 查看類的屬性字典，
# 前后帶雙下劃線的為內(nèi)置屬性 ， 其他為自定義屬性        
>>> MySuper.__dict__.keys()
dict_keys(['__module__', 's', 'm1', '__dict__', '__weakref__', '__doc__'])
>>> msp=MySuper()
# 實(shí)例名.__dict__ 查看實(shí)例的屬性字典，
# 實(shí)例無(wú)本身屬性則為空。
>>> msp.__dict__.keys()
dict_keys([])
# 調(diào)用m1()通過(guò)self.屬性=值，進(jìn)行屬性賦值
>>> msp.m1()
# 實(shí)例名.__dict__ 只返回實(shí)例賦值的屬性，不返回類的屬性
>>> msp.__dict__.keys()
dict_keys(['data1'])
# 類名.__dict__ 只返回類屬性，不返回實(shí)例屬性
>>> MySuper.__dict__.keys()
dict_keys(['__module__', 's', 'm1', '__dict__', '__weakref__', '__doc__'])
>>> msp2=MySuper()
# 每個(gè)實(shí)例有獨(dú)立的屬性字典
>>> msp2.__dict__.keys()
dict_keys([])
# 創(chuàng)建實(shí)例時(shí)自動(dòng)執(zhí)行__init__()給實(shí)例屬性賦值
>>> mca=MyClassA()
>>> mca.__dict__.keys()
dict_keys(['data2'])

1.2 class

__class__獲取實(shí)例所屬類，再用獲取的類創(chuàng)建實(shí)例。

>>> class MyClass:pass
>>> c1=MyClass()
>>> c1
<__main__.MyClass object at 0x03D19C50>
# __class__ 返回實(shí)例所屬類
>>> c1.__class__
<class '__main__.MyClass'>
# 用返回的類創(chuàng)建實(shí)例對(duì)象
>>> c2=c1.__class__()
>>> c2
<__main__.MyClass object at 0x03D19CF0>

1.3 class.name

class.__name__獲取實(shí)例所屬類的類名。

>>> class MyClass:pass
>>> c1=MyClass()
>>> c1=MyClass()
# __name__ 返回實(shí)例所屬類的名字
>>> c1.__class__.__name__
'MyClass'

1.4 bases

獲取類的直接超類組成的元組。

>>> class MyClass:pass
>>> class MyClassA(MyClass):pass
>>> class MyClassB():pass
>>> class MyClassC(MyClassA,MyClassB):pass
# __bases__ 返回直接超類組成的元組
>>> MyClassC.__bases__
(<class '__main__.MyClassB'>, <class '__main__.MyClassA'>)

1.5 搜索屬性

類屬性由全部實(shí)例共享，實(shí)例屬性每個(gè)實(shí)例相互獨(dú)立。

NO	屬性	描述
1	類屬性	（1）類屬性是指類頂層賦值生成的屬性。（2）全部實(shí)例共享類屬性。
2	實(shí)例屬性	（1）實(shí)例屬性是指通過(guò)self.屬性名=屬性值，或?qū)嵗?屬性名=屬性值，獲取的屬性。（2）每個(gè)實(shí)例的實(shí)例屬性相互獨(dú)立，互不干擾。（3）實(shí)例無(wú)屬性時(shí)，實(shí)例命名空間字典為空。

實(shí)例和類搜索屬性都在屬性命名空間字典查找。

搜索實(shí)例屬性先從實(shí)例屬性命名空間查找，再到類，超類查找，直到找到為止。

搜索類屬性從類屬性命名空間查找，再到超類查找，直到找到為止。

步驟	描述
1	通過(guò)“實(shí)例名.dict”獲取實(shí)例屬性。
2	若無(wú)，則通過(guò)“實(shí)例名.class”獲取實(shí)例所屬類。
3	通過(guò)“類名.dict”獲取類屬性。
4	若無(wú)，則通過(guò)“類名.base”獲取實(shí)例所屬類的直接超類。
5	超類重復(fù)3到4步驟，獲取類屬性。

>>> class MySuper:
    s='梯閱線條'
    def m1(self):
        self.data1='MySuper'

>>> class MyClassA(MySuper):
    def __init__(self):
        self.data2='MyClassA'

>>> msp1=MySuper()
>>> msp1.__dict__
{}
>>> msp1.__class__.__name__
'MySuper'
>>> msp1.m1()
>>> msp1.__dict__
{'data1': 'MySuper'}
>>> mca1=MyClassA()
>>> mca1.__dict__
{'data2': 'MyClassA'}
>>> mca1.__dict__
{'data2': 'MyClassA'}
>>> MySuper.__dict__.keys()
dict_keys(['__module__', 's', 'm1', '__dict__', '__weakref__', '__doc__'])
>>> mca1.m1()
>>> mca1.__dict__
{'data2': 'MyClassA', 'data1': 'MySuper'}
# 搜索s，從 MySuper.__dict__ 類命名空間獲取
>>> mca1.s
'梯閱線條'
# 搜索 data1 和 data2 從 實(shí)例命名看空間獲取
>>> mca1.data1
'MySuper'
>>> mca1.data2
'MyClassA'

1.6 dir

dir(類或?qū)嵗?，返回類或?qū)嵗膶傩?，包括系統(tǒng)屬性，比__dict__.keys()多。

NO	使用	描述
1	類.dict.keys()	返回類屬性，不包括系統(tǒng)屬性
2	實(shí)例.dict.keys()	返回實(shí)例屬性，不包括類屬性
3	子類.dict.keys()	返回子類屬性，不包括超類屬性
4	子類實(shí)例.dict.keys()	返回子類實(shí)例屬性，不包括類和超類屬性
5	dir(類)	返回類屬性，包括系統(tǒng)屬性
6	dir(實(shí)例)	返回實(shí)例屬性，包括類屬性和系統(tǒng)屬性
7	dir(子類)	返回類屬性，包括超類屬性和系統(tǒng)屬性
8	dir(子類實(shí)例)	返回子類實(shí)例屬性，包括類、超類、系統(tǒng)屬性

示例

>>> class MySuper:
    s='梯閱線條'
    def m1(self):
        self.data1='MySuper'

>>> class MyClassA(MySuper):
    def __init__(self):
        self.data2='MyClassA'
    
>>> msp1=MySuper()
# 類.__dict__.keys() 返回類屬性
>>> MySuper.__dict__.keys()
dict_keys(['__module__', 's', 'm1', '__dict__', '__weakref__', '__doc__'])
# dir(類) 比 類.__dict__.keys() 多 系統(tǒng)屬性
>>> dir(MySuper)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'm1', 's']
# dir(實(shí)例) 返回類屬性
>>> dir(msp1)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'm1', 's']
# 實(shí)例.__dict__.keys() 不返回類屬性 ， 返回實(shí)例屬性 
>>> msp1.__dict__.keys()
dict_keys([])

# dir(類) 返回 超類的屬性 
>>> dir(MyClassA)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'm1', 's']
# 類.__dict__.keys() 不返回超類屬性
>>> MyClassA.__dict__.keys()
dict_keys(['__module__', '__init__', '__doc__'])
# dir(實(shí)例) 返回 超類的屬性 
>>> dir(mca1)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'data2', 'm1', 's']
# 實(shí)例.__dict__.keys() 不返回超類屬性
>>> mca1.__dict__.keys()
dict_keys(['data2'])

1.7 繼承層次例子

通過(guò)__class__ 找到實(shí)例所屬的類，通過(guò) bases 找到超類，從而找到實(shí)例和類的繼承層次。

def classtree(cls,indent):
    print('| '* indent + '|-' + cls.__name__)
    # cls.__bases__
    for supercls in cls.__bases__:
        classtree(supercls,indent+1)

def instancetree(inst):
    print('Tree of {}'.format(inst))
    # inst.__class__ 實(shí)例所屬類
    classtree(inst.__class__,0)
    
def selftest():
    class A:pass
    class B(A):pass
    class C(A):pass
    class D(B,C):pass
    class E:pass
    class F(D,E):pass
    instancetree(B())
    instancetree(F())
    
if __name__ == '__main__':
    selftest()
    
''' 運(yùn)行結(jié)果    
E:\documents\F盤>python classtree.py
Tree of <__main__.selftest.<locals>.B object at 0x01978A30>
|-B
| |-A
| | |-object
Tree of <__main__.selftest.<locals>.F object at 0x01978A30>
|-F
| |-D
| | |-B
| | | |-A
| | | | |-object
| | |-C
| | | |-A
| | | | |-object
| |-E
| | |-object
'''

1.8 doc

python文檔字符串__doc__，值為模塊文件開頭、函數(shù)開頭、類開頭、方法開頭的注釋，python會(huì)自動(dòng)封裝這些注釋，并且保存在__doc__。這些注釋寫在三引號(hào)內(nèi)。

1.8.1 自定義文檔字符串

文檔字符串可以通過(guò)不同位置路徑對(duì)象的__doc__獲取。

不同路徑對(duì)象屬性名(函數(shù)名、類名、方法名)可以通過(guò)dir(模塊)獲取。

模塊：模塊名.doc

函數(shù)：模塊名.函數(shù)名.doc

類：模塊名.類名.doc

方法名：模塊名.類名.方法名.doc

示例

'''
模塊文件名：docstr.py
模塊開頭的文檔字符串
'''
S='梯閱線條'
def hellof(name):
    '''
    函數(shù)開頭的文檔字符串
    '''
    print('hello ',name)

class Student:
    '''
    類開頭處的文檔字符串
    '''
    def study(self):
        '''
        方法開頭的文檔字符串
        '''
        pass
    
# 查看不同對(duì)象的__doc__文檔字符串
>>> path=r'E:\documents\F盤'
>>> import os
>>> os.chdir(path)
>>> import docstr
>>> dir(docstr)
['L', 'S', 'Student', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'hellof']
>>> print(docstr.__doc__)

模塊文件名：docstr.py
模塊開頭的文檔字符串
>>> print(docstr.hellof.__doc__)

    函數(shù)開頭的文檔字符串
>>> print(docstr.Student.__doc__)

    類開頭處的文檔字符串
>>> print(docstr.Student.study.__doc__)

        方法開頭的文檔字符串

到此這篇關(guān)于全面理解python命名空間字典的文章就介紹到這了,更多相關(guān)python命名空間字典內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: