❶ python 類中的私有屬性有哪些

類的私有屬性：
__private_attrs：兩個下劃線開頭，聲明該屬性為私有，不能在類地外部被使用或直接訪問。
在類內部的方法中使用時 self.__private_attrs。

類的方法:
在類地內部，使用def關鍵字可以為類定義一個方法，與一般函數定義不同，類方法必須包含參數self,且為第一個參數

類的私有方法 :
__private_method：兩個下劃線開頭，聲明該方法為私有方法，不能在類地外部調用。
在類的內部調用 self.__private_methods

實例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class JustCounter:
__secretCount = 0 # 私有變數
publicCount = 0 # 公開變數

def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 報錯，實例不能訪問私有變數

Python不允許實例化的類訪問私有數據，但你可以使用 object._className__attrName 訪問屬性，將如下代碼替換以上代碼的最後一行代碼：
…………………….
print counter._JustCounter__secretCount

這樣就可以訪問私有屬性了

❷ python類里邊給方法添加屬性進列表

往列表裡添加多個值可回以用答 extend()：

classUser():

def__init__(self,first_name,last_name):
self.first=first_name
self.last=last_name

deftitl(self):
list=[]
#list.append(self.first_name)
#list.append(self.last_name)
list.extend([self.first,self.last])
print(list)

me=User('ssx','xing')
print(me.first+','+me.last)
me.titl()

❸ Python類屬性問題

classp1:
name="p1"
def__init__(self,pname):
p1.name=pname#使用名字name只是函數中的局部變數，加上限定符p1才是類屬性
printpname
classp2(p1):
def__init__(self,pname):
p1.__init__(self,pname)
p=p2('p2')
printp1.name

❹ python類中的 方法 屬性分別什麼意思

就比方說有一個類叫做car

這個類的屬性可以有colorsizebrandpriceyear等描述性的東西

這個類的方法可以是runstopforwardbackward等執行性的東西

classcar:
#定義基本屬性
color=''
size=0
brand=''
price=0
year=0

#定義構造方法
def__init__(self):
self.color=color
self.size=size
self.brand=brand
self.price=price
self.year=year
defrun(self):
print("thecarisrunning")
defstop(self):
print("thecarisstop")
defforward(self):
print("thecarisforward")
defbackward(self):
print("thecarisbackward")

#類調用

benz=car('red',1.8T,'Mercedes',400000,2016)
benz.run()
benz.stop()
benz.forward()
benz.backward()

❺ Python中如何創建一個類，類實現所有字典的功能，並支持屬性取值

Python中如何創建一個類，類實現所有字典的功能，並支持屬性取值
class dic(dict): pass

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

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

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

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

1.Python是一門動態語言，任何實體都可以動態地添加或刪除屬性。
2.一個類定義了一個作用域。
3.類實例也引入了一個作用域，這與相應類定義的作用域不同。
4.在類實例中查找屬性的時候，首先在實例自己的作用域中查找，如果沒有找到，則再在類定義的作用域中查找。
5.在對類實例屬性進行賦值的時候，實際上會在類實例定義的作用域中添加一個屬性（如果還不存在的話），並不會影響到相應類中定義的同名屬性。

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

復制代碼
代碼如下:

class A:
cls_i = 0
cls_j
= {}
def __init__(self):
self.instance_i =
0
self.instance_j =
{}

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

復制代碼
代碼如下:

>>> a = A()
>>>
a.__dict__
{'instance_j': {}, 'instance_i': 0}
>>>
A.__dict__
{'__init__': , '__mole__': '__main__', 'cls_i': 0, 'cls_j': {},
'__doc__': None}

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

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

復制代碼
代碼如下:

>>> a.cls_i
0
>>>
a.instance_i
0

在查找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__': , '__mole__': '__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__': , '__mole__': '__main__',
'cls_i': 0, 'cls_j': {'a': 'a'}, '__doc__': None}

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

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

復制代碼
代碼如下:

>>> A.cls_k = 0

❼ Python中的類屬性和對象屬性的區別詳解

類屬性：
class Employee(object):
emCount=0
def __init__(self,name,salary):
self.nane=name
self.salary=salary
類屬性就是定義類的時候直接定義的屬性 emCount，類似於java裡面的static修飾的屬性，可以直接通過 類名.屬性名訪問：Employee.emCount
實例屬性是在__init()方法中定義的屬性，例如name，和salary,self是指向自己的，類似java的this關鍵字，實際是通過內置的方法setattr()完成的
可以通過重寫setatttr()進行類屬性的增加和獲取

❽ 有沒有Python中的函數來列印一個對象的所有當前的屬性和值

1. 你是兩個不同的事情真的混在一起。
使用dir()或inspect模塊讓你有興趣（什麼__builtins__作為一個例子，你的任何對象，而不是）。
>>> l = dir(__builtins__)
>>> d = __builtins__.__dict__

列印該字典但是看上你喜歡：
>>> print l
['ArithmeticError', 'AssertionError', 'AttributeError',...

或
>>> from pprint import pprint
>>> pprint(l)
['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'DeprecationWarning',
...
>>> pprint(d, indent=2)
{ 'ArithmeticError': <type 'exceptions.ArithmeticError'>,
'AssertionError': <type 'exceptions.AssertionError'>,
'AttributeError': <type 'exceptions.AttributeError'>,
...
'_': [ 'ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'DeprecationWarning',
...

2.
你想瓦爾（）與PPRINT混合：
from pprint import pprint
pprint (vars(your_object))

3.
def mp(obj):
for attr in dir(obj):
print "obj.%s = %s" % (attr, getattr(obj, attr))

4.
目錄有但只會給你的屬性'如果你希望自己的價值觀，以及嘗試的__dict__。
class O:
def __init__ (self):
self.value = 3
o = O()

>>> o.__dict__
{'值'：3}
5.
你的「目錄（）」函數來做到這一點。
>>> import sys
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__', '__stdin__', '__stdo
t__', '_current_frames', '_getframe', 'api_version', 'argv', 'builtin_mole_names', 'byteorder
, 'call_tracing', 'callstats', 'right', 'displayhook', 'dllhandle', 'exc_clear', 'exc_info'
'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefault
ncoding', 'getfilesystemencoding', 'getrecursionlimit', 'getrefcount', 'getwindowsversion', 'he
version', 'maxint', 'maxunicode', 'meta_path', 'moles', 'path', 'path_hooks', 'path_importer_
ache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
, 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoption
', 'winver']
>>>

函數是幫助。
>>> help(sys)
Help on built-in mole sys:
NAME
sys
FILE
(built-in)
MODULE DOCS
CodeGo.net
DESCRIPTION
This mole provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if known

6.
要列印的對象，你可能的當前狀態：
>>> obj # in an interpreter

或
print repr(obj) # in a script

或
print obj

為你的類定義__str__或__repr__方法。從Python__repr__(self)由被叫repr()內置函數和字元串
轉換（反引號）
計算「官方」的字元串
一個對象的表示。如果在所有
可能的話，這應該看起來像一個
有效的Python表達式，可能是
用於重新創建的對象與
值（給定一個適當的
如果這是不可能的 CodeGo.net，
一個字元串表單的「<...有用
描述...>「應該返回。
返回值必須是一個字元串
對象。如果一個類定義再版（）
但不__str__()，然後__repr__()是
當一個「非正式」的字元串
的該實例的代表性
類是必需的。這通常是
用於調試，所以重要的是
該項表示是
信息豐富，__str__(self)由被叫str()內置函數和由列印
「非正式」
一個對象的字元串表示表單。
這不同於__repr__()在這
它並不必須是一個有效的Python
表達式：更方便或
簡潔的表述，如
代替。返回值必須是一個
字元串對象。
7.
可能是值得一試-
是否有相當於Perl的Data ::自卸車一個Python？
我是這樣的-
需要注意的是Perl有一個名為Data ::
Dumper模塊的轉換對象數據返回到perl的源代碼（註：它並沒有轉化代碼回到源，而且幾乎總是你不想在輸出的函數）。這可持久性，但目的是為了調
試。
有許多事情標準的python
PPRINT未能達到，尤其是剛剛停止時，看到一個對象的實例，並為您的對象的內六角指針（降序呃，這個指針是不是一大堆的方式）。因此，概括地
說，python是所有關於這個偉大的面向對象的範式，但你得到的開箱即用的工具是專為與對象比其他工作。
在Perl的Data ::
Dumper允許你控制你想有多深去，並且還檢測循環鏈表結構（這是非常重要的）。這個過程是比較容易實現的perl的對象有超越他們的祝福沒有特別的魔
法（一個普遍良好定義的線程）。
8.
在大多數情況下，使用__dict__或dir()你將會得到你想要。如果您碰巧需要更多的細節，標准庫包含了inspect模塊，它可以讓你獲得細節令人印象深刻的金額。真正的nuggests包括：
函數
類層次結構
的一個函數/類對象的源代碼
局部變數出對象的
如果你只是尋找「沒有我的對象有什麼屬性值？」，然後dir()和__dict__可能是足夠的。如果你真的希望挖掘到任意對象的當前狀態（牢記在python幾乎一切都是對象），然後inspect是值得考慮的。
9.
例如轉儲對象的魔法：

$貓mp.py

#!/usr/bin/python
import sys
if len(sys.argv) > 2:
mole, metaklass = sys.argv[1:3]
m = __import__(mole, globals(), locals(), [metaklass])
__metaclass__ = getattr(m, metaklass)
class Data:
def __init__(self):
self.num = 38
self.lst = ['a','b','c']
self.str = 'spam'
mps = lambda self: repr(self)
__str__ = lambda self: self.mps()
data = Data()
print data

無

$pythonmp.py

<__main__.Data instance at 0x00A052D8>

與靈知utils的：

$pythonmp.py gnosis.magic MetaXMLPickler

<?xml version="1.0"?>
<!DOCTYPE PyObject SYSTEM "PyObjects.dtd">
<PyObject mole="__main__" class="Data" id="11038416">
<attr name="lst" type="list" id="11196136" >
<item type="string" value="a" />
<item type="string" value="b" />
<item type="string" value="c" />
</attr>
<attr name="num" type="numeric" value="38" />
<attr name="str" type="string" value="spam" />
</PyObject>

這是一個有點過時，但仍然堅持工作。
10.
PPRINT包含一個「漂亮的列印機」為你製造數據結構的美觀交涉。格式化器產生的數據結構的表示，可以正確地由解釋器進行解析，並且也很容易對一個人的閱讀。輸出保持在一行上，如果可能的話，與縮進時，多行拆分。
11.
為什麼不能簡單的：
關鍵，在obj的值。字典iteritems（）。：
列印鍵，值
12.
我需要在日誌中列印並無法PPRINT它會打破它。相反，我這樣做，並幾乎得到了的東西。
DO = DemoObject()
itemDir = DO.__dict__
for i in itemDir:
print '{0} : {1}'.format(i, itemDir[i])

❾ python類的屬性有哪幾種如何訪問它們

屬性的訪問機制

一般情況下，屬性訪問的默認行為是從對象的字典中獲取，並當獲取不到時會沿著一定的查找鏈進行查找。例如a.x的查找鏈就是，從a.__dict__['x']，然後是type(a).__dict__['x']，再通過type(a)的基類開始查找。

若查找鏈都獲取不到屬性，則拋出AttributeError異常。

一、__getattr__方法

這個方法是當對象的屬性不存在是調用。如果通過正常的機制能找到對象屬性的話，不會調用__getattr__方法。

classA:
a=1
def__getattr__(self,item):
print('__getattr__call')
returnitem

t=A()
print(t.a)
print(t.b)
#output
1
__getattr__call
b

二、__getattribute__方法

這個方法會被無條件調用。不管屬性存不存在。如果類中還定義了__getattr__，則不會調用__getattr__()方法，除非在__getattribute__方法中顯示調用__getattr__()或者拋出了AttributeError。

classA:
a=1
def__getattribute__(self,item):
print('__getattribute__call')
raiseAttributeError

def__getattr__(self,item):
print('__getattr__call')
returnitem

t=A()
print(t.a)
print(t.b)

所以一般情況下，為了保留__getattr__的作用，__getattribute__()方法中一般返回父類的同名方法：

def__getattribute__(self,item):
returnobject.__getattribute__(self,item)

使用基類的方法來獲取屬性能避免在方法中出現無限遞歸的情況。

三、__get__方法

這個方法比較簡單說明，它與前面的關系不大。

如果一個類中定義了__get__(),__set__()或__delete__()中的任何方法。則這個類的對象稱為描述符。

classDescri(object):
def__get__(self,obj,type=None):
print("callget")

def__set__(self,obj,value):
print("callset")

classA(object):
x=Descri()

a=A()
a.__dict__['x']=1#不會調用__get__
a.x#調用__get__
如果查找的屬性是在描述符對象中，則這個描述符會覆蓋上文說的屬性訪問機制，體現在查找鏈的不同，而這個行文也會因為調用的不同而稍有不一樣：

  • 如果調用是對象實例(題目中的調用方式)，a.x則轉換為調用：。type(a).__dict__['x'].__get__(a, type(a))
  • 如果調用的是類屬性,A.x則轉換為：A.__dict__['x'].__get__(None, A)

  • 其他情況見文末參考資料的文檔

    • 四、__getitem__方法

  • 這個調用也屬於無條件調用，這點與__getattribute__一致。區別在於__getitem__讓類實例允許[]運算，可以這樣理解：
  • __getattribute__適用於所有.運算符；
  • __getitem__適用於所有[]運算符。
  • classA(object):

  • a=1


  • def__getitem__(self,item):

  • print('__getitem__call')

  • returnitem


  • t=A()

  • print(t['a'])

  • print(t['b'])

    • 如果僅僅想要對象能夠通過[]獲取對象屬性可以簡單的：

  • def__getitem(self,item):

  • returnobject.__getattribute__(self,item)

    • 總結

    當這幾個方法同時出現可能就會擾亂你了。我在網上看到一份示例還不錯，稍微改了下：

  • classC(object):

  • a='abc'


  • def__getattribute__(self,*args,**kwargs):

  • print("__getattribute__()iscalled")

  • returnobject.__getattribute__(self,*args,**kwargs)


  • #return"haha"

  • def__getattr__(self,name):

  • print("__getattr__()iscalled")

  • returnname+"fromgetattr"


  • def__get__(self,instance,owner):

  • print("__get__()iscalled",instance,owner)

  • returnself


  • def__getitem__(self,item):

  • print('__getitem__call')

  • returnobject.__getattribute__(self,item)


  • deffoo(self,x):

  • print(x)


  • classC2(object):

  • d=C()


  • if__name__=='__main__':

  • c=C()

  • c2=C2()

  • print(c.a)

  • print(c.zzzzzzzz)

  • c2.d

  • print(c2.d.a)

  • print(c['a'])

  • 可以結合輸出慢慢理解，這里還沒涉及繼承關系呢。總之，每個以__get為前綴的方法都是獲取對象內部數據的鉤子，名稱不一樣，用途也存在較大的差異，只有在實踐中理解它們，才能真正掌握它們的用法。

❿ python如何查看一個對象有哪些屬性

使用dir命令，如
text="string"
dir(text)