python的类的属性值
A. python 类属性为类时，如何进行赋值
因为b.name[0]
=
'zhang'修改的是类属性,类属性是全局的,所有的实例共享,如果想私有化,可以添加
def
__init__(
self
):
self.name
=
list(
self.name
)
就可以了.
B. 如图，python中类的属性为啥有两种不同的定义方式，同样都是类的属性，两种有什么区别
第一种：
上图这种叫对象的属性，只有在实例化类之后它们才能调用，如：
s = a(10,20,30) #实例化对象
print(s.lenght) #调用对象属性
注意一点，类名需要大写，然后你init里面的少了self，而且init后面的lenght没有意义。
C. 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()
D. 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)
其他情况见文末参考资料的文档
- 这个调用也属于无条件调用，这点与__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为前缀的方法都是获取对象内部数据的钩子，名称不一样，用途也存在较大的差异，只有在实践中理解它们，才能真正掌握它们的用法。
四、__getitem__方法
如果仅仅想要对象能够通过[]获取对象属性可以简单的：
总结
当这几个方法同时出现可能就会扰乱你了。我在网上看到一份示例还不错，稍微改了下：
E. Python 获取类属性
通常情况下，我们在类对象中定义的属性都会设置访问权限，外部程序无法直接获取，防止恶意的修改，当属性被设置为私有属性后，外部程序该如何访问呢？
例：使用普通方法访问私有属性
例：使用property方法访问私有属性
property()方法接收两个参数，第一个参数为获取属性需要调用的实例方法名，第二个参数为设置属性需要调用的实例方法名，返回值就设置为需要设置、获取的属性名。
当执行到实例.属性时，就会调用获取实例属性的方法，当执行到实例.属性 = xxx时，就会调用设置实例属性的方法。
例：使用@property/@xxx.setter装饰器访问私有属性
F. 谈谈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