python中怎麼看一個類得屬性,python查看類的屬性

本文目錄一覽：

• 1、python 如何根據一個對象的屬性值查詢該對象其他某個屬性值？
• 2、python怎麼判斷一個對象的屬性
• 3、怎麼判斷 Python 對象是否包含某個屬性
• 4、談談python中類屬性和類實例的屬性的區別

python 如何根據一個對象的屬性值查詢該對象其他某個屬性值？

在 Chrom 類中新增一個類函數，遍歷存儲列表並返回匹配的對象

大概寫了個樣例

運行結果

python怎麼判斷一個對象的屬性

方法一：通過異常捕捉來實現邏輯

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

class FooClass:

pass

k = FooClass()

try:

#do some thing you need

print k.att

except AttributeError as e:

#error: has not attribute

pass

方法二：調用hasattr方法

hasattr(object, name)

說明：判斷對象object是否包含名為name的特性（hasattr是通過調用getattr(ojbect, name)是否拋出異常來實現的）。

參數object：對象。

參數name：特性名稱。

hasattr(list, ‘append’)

True

hasattr(list, ‘add’)

False

方法三：使用dir方法

objlist = dir(k)

if ‘att’ in objlist:

#do some thing you need

print k.att

else:

#error: has not attribute

pass

怎麼判斷 Python 對象是否包含某個屬性

頂級函數hasattr可以查看對象是否包含某某屬性，這裡的屬性包括數據屬性和方法。getattr可以獲取屬性。

如下舉例說明。

a=[1,2,3]

print(‘列表有count屬性:%s’%hasattr(a,’count’))

print(‘列表有append屬性:%s’%hasattr(a,’append’))

print(‘列表有shift屬性:%s’%hasattr(a,’shift’))

print(‘列表的count屬性是方法:%s’%hasattr(getattr(a,’count’),’__call__’))

print(‘列表的append屬性是方法:%s’%hasattr(getattr(a,’append’),’__call__’))

class myclass():

    def __init__(self):

        self.valattr=3

    def method(self):

        pass

mc=myclass()

print(‘myclass有valattr屬性:%s’%hasattr(mc,’valattr’))

print(‘myclass有method屬性:%s’%hasattr(mc,’method’))

print(‘myclass的valattr屬性是方法:%s’%hasattr(getattr(mc,’valattr’),’__call__’))

print(‘myclass的method屬性是方法:%s’%hasattr(getattr(mc,’method’),’__call__’))

談談python中類屬性和類實例的屬性的區別

一般來說，在Python中，類實例屬性的訪問規則算是比較直觀的。

但是，仍然存在一些不是很直觀的地方，特別是對C++和Java程序員來說，更是如此。

在這裡，我們需要明白以下幾個地方：

1.Python是一門動態語言，任何實體都可以動態地添加或刪除屬性。

2.一個類定義了一個作用域。

3.類實例也引入了一個作用域，這與相應類定義的作用域不同。

4.在類實例中查找屬性的時候，首先在實例自己的作用域中查找，如果沒有找到，則再在類定義的作用域中查找。

5.在對類實例屬性進行賦值的時候，實際上會在類實例定義的作用域中添加一個屬性（如果還不存在的話），並不會影響到相應類中定義的同名屬性。

下面看一個例子，加深對上述幾點的理解：

複製代碼

代碼如下:

class A:

cls_i = 0

cls_j

= {}

def __init__(self):

self.instance_i =

self.instance_j =

{}

在這裡，我們先定義類A的一個實例a，然後再看看類A的作用域和實例a的作用域中分別有什麼：

複製代碼

代碼如下:

a = A()

a.__dict__

{‘instance_j’: {}, ‘instance_i’: 0}

A.__dict__

{‘__init__’: , ‘__module__’: ‘__main__’, ‘cls_i’: 0, ‘cls_j’: {},

‘__doc__’: None}

我們看到，a的作用域中有instance_i和instance_j，A的作用域中有cls_i和cls_j。

我們再來看看名字查找是如何發生的：

複製代碼

代碼如下:

a.cls_i

a.instance_i

在查找cls_i的時候，實例a的作用域中是沒有它的，卻在A的作用域中找到了它；在查找instance_i的時候，直接可在a的作用域中找到它。

如果我們企圖通過實例a來修改cls_i的值，那會怎樣呢：

複製代碼

代碼如下:

a.cls_i = 1

a.__dict__

{‘instance_j’: {}, ‘cls_i’: 1, ‘instance_i’: 0}

A.__dict__

{‘__init__’: , ‘__module__’: ‘__main__’, ‘cls_i’: 0, ‘cls_j’: {},

‘__doc__’: None}

我們可以看到，a的作用域中多了一個cls_i屬性，其值為1；同時，我們也注意到A作用域中的cls_i屬性的值仍然為0；在這裡，我們其實是增加了一個實例屬性，並沒有修改到類屬性。

如果我們通過實例a操縱cls_j中的數據（注意不是cls_j本身），又會怎麼樣呢：

複製代碼

代碼如下:

a.cls_j[‘a’] =

‘a’

a.__dict__

{‘instance_j’: {}, ‘cls_i’: 1, ‘instance_i’:

0}

A.__dict__

{‘__init__’: , ‘__module__’: ‘__main__’,

‘cls_i’: 0, ‘cls_j’: {‘a’: ‘a’}, ‘__doc__’: None}

我們可以看到a的作用域沒有發生什麼變化，但是A的作用域發生了一些變化，cls_j中的數據發生了變化。

實例的作用域發生變化，並不會影響到該類的其它實例，但是類的作用域發生變化，則會影響到該類的所有實例，包括在這之前創建的實例：

複製代碼

代碼如下:

A.cls_k = 0