❶ 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)