2被浏览233分享邀请回答02 条评论分享收藏感谢收起class F(object):
def a(self):
print('hello')
@staticmethod
print('hello')
@classmethod
def c(cls):
print('hello')
for i in _l:
g.__next__().a()
====== 更新大概明白你的意思了，是要生成一副扑克牌，但是你这样是不对的呀，你这样用两个 for 生成了你以为的52张牌，然而在所有的牌中，suit 都是 [ 红桃， 黑桃 blabla]，而所有的 face 都是 [ A, 1, 2, 3, 4 , 5......]至于为什么没有你的方法，因为你的 Desk 列表中每一个元素都是 generator ，generator 是 Python 的内建类，自然没有你的 face_f 方法，你需要调用 next() 方法拿到 lazy 的 Card 类（Python3 中 __next__()）然后再用 face_f ，然而这个 face_f 还是个列表.............感觉你不知道自己在写啥......0添加评论分享收藏感谢收起类属性和对象属性
我们把定义在类中的属性称为类属性，该类的所有对象共享类属性，类属性具有继承性，可以为类动态地添加类属性。
对象在创建完成后还可以为它添加额外的属性，我们把这部分属性称为对象属性，对象属性仅属于该对象，不具有继承性。
类属性和对象属性都会被包含在dir()中，而vars()是仅包含对象属性。vars()跟__dict__是等同的。
类属性和对象属性可类比于Java中的static成员和非static成员，只不python中的类属性和对象属性都是可以动态添加（和删除）的。
class A(object):
name='orisun'
def __init__(self):
self.age=10
class B(A):
city='bei jing'
def __init__(self):
self.tempurature=20
if __name__ == '__main__':
print dir(A)
print dir(a)
print a.__dict__
print vars(a)
print dir(B)
print dir(b)
print b.__dict__
print vars(b)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
{'age': 10}
{'age': 10}
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'city', 'name']
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'city', 'name', 'tempurature']
{'tempurature': 20}
{'tempurature': 20}
动态地为类添加类属性后，该类的所有对象也都添加了该属性（即使是动态添加类属性之前创建的对象）。通过实例修改属性，并不会影响其他实例的同名属性和类上的同名属性。
class A(object):
name='orisun'
def __init__(self):
self.age=10
if __name__ == '__main__':
print dir(a)
A.city='BeiJing'
#动态添加类属性，会反应到所有对象上
A.name='zcy'
#动态修改类属性，会反应到所有对象上
print dir(b)
print dir(a)
print a.name
b.name='tom'
#通过实例修改属性，并不会影响其他实例的同名属性和类上的同名属性
print a.name
print A.name
print b.name
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'city', 'name']
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'city', 'name']
下文中讨论的全部是类属性，不涉及对象属性。
对属性的访问、设置和删除又分为2种情况：
通过对象（实例）访问、设置和删除属性，即obj.attr、obj.attr=val、del obj.attr
通过类访问、设置和删除属性，即Cls.attr、Cls.attr=val、del Cls.attr
本文将针对这2种情况分别讨论。
Descriptor
一个Descriptor是指实现了__get__的类，实现__set__和__delete__是可选的。同时实现了__get__和__set__则称为Data Descriptor，如果只实现了__get__则称为Non-data Descriptor。
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
def __set__(self,obj,val):
def __delete__(self,obj):
先给一个Descriptor的示例，__get__、__set__、__delete__的作用后文再细讲。
通过实例访问属性
__getattribute__、__getattr__、__get__和__dict__[attr]都是跟属性访问相关的方法，它们的优先级:
当类中定义了__getattribute__方法时，则调用__getattribute__。
如果访问的属性存在，且
2.1 &属性是个Descriptor，是调用这个属性的__get__
2.2&属性不是Descriptor，则调用__dict__[attr]
如果类中没有定义该属性，则调用__getattr__
否则，抛出异常AttributeError　
class A(object):
if __name__ == '__main__':
AttributeError: 'A' object has no attribute 'd'
class A(object):
def __getattr__(self,name):
return name+" not found in "+self.__class__.__name__+" object"
if __name__ == '__main__':
d not found in A object
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
class A(object):
d=Descriptor()
def __getattr__(self,name):
return name+" not found in "+self.__class__.__name__+" object"
if __name__ == '__main__':
Descriptor in A
__getattr__并没有被调用。
class A(object):
def __getattr__(self,name):
return name+" not found in "+self.__class__.__name__+" object"
if __name__ == '__main__':
__getattr__并没有被调用。
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
class A(object):
d=Descriptor()
def __getattribute__(self,name):
return '__getattribute__ '
def __getattr__(self,name):
return name+" not found in "+self.__class__.__name__+" object"
if __name__ == '__main__':
__getattribute__
__get__和__getattr__并没有被调用。
通过实例设置属性
跟属性设置相关的方法有3个：__setattr__、__set__和__dict__[attr]=val。它们的优先级跟get正好反过来：
如果类中定义了__setattr__方法，则直接调用__setattr__
如果赋值的属性是个Descriptor，且2.1 &该Descriptor中定义了__set__，则直接调用__set__2.2 &该Descriptor中没有定义__set__，则调用__dict__[attr]=val
如果赋值的属性不是Descriptor，则直接调用__dict__[attr]=val
如果该属性不存在，则动态地添加该属性，然后调用__dict__[attr]=val进行赋值
class A(object):
if __name__ == '__main__':
a.d='hello'
class A(object):
if __name__ == '__main__':
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
class A(object):
d=Descriptor()
if __name__ == '__main__':
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
def __set__(self,instance,value):
class A(object):
d=Descriptor()
if __name__ == '__main__':
Descriptor in A
因为代码&a.d=30&调用了__set__，而__set__又什么都没做，所以属性d还是Descriptor对象（而非30），那么在执行"print a.d"时自然就调到了__get__
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
def __set__(self,instance,value):
print '__set__'
class A(object):
d=Descriptor()
def __setattr__(self,name,value):
print '__setattr__'
if __name__ == '__main__':
__setattr__
Descriptor in A
调用了__setattr__，而__set__并没有被调到。
通过实例删除属性
调用del instance.attr进行属性删除时可能会调到__delattr__或__delete__，它们的优先级跟set雷同。
如果类中定义了__delattr__方法，则直接调用__delattr__
如果赋值的属性是个Descriptor，且该Descriptor中定义了__delete__，则直接调用__delete__
如果赋值的属性是个Descriptor，且该Descriptor中没有定义__delete__，则会报异常AttributeError：属性是只读的
如果赋值的属性不是Descriptor，也会报异常AttributeError：属性是只读的
如果该属性不存在，则报异常AttributeError
class A(object):
if __name__ == '__main__':
AttributeError: 'A' object has no attribute 'd'
class A(object):
if __name__ == '__main__':
AttributeError: 'A' object attribute 'd' is read-only
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
class A(object):
d=Descriptor()
if __name__ == '__main__':
AttributeError: 'A' object attribute 'd' is read-only
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
def __delete__(self,instance):
print '__delete__'
class A(object):
d=Descriptor()
if __name__ == '__main__':
__delete__
class Descriptor(object):
def __get__(self,instance,owner):
return 'Descriptor in '+owner.__name__
def __delete__(self,instance):
print '__delete__'
class A(object):
d=Descriptor()
def __delattr__(self,name):
print '__delattr__'
if __name__ == '__main__':
__delattr__
__delete__并没有被调用。
__get__ &__set__ &__delete__参数说明
class Descriptor(object):
def __get__(self,obj,owner):
return '__get__',self,obj,owner
def __set__(self,obj,val):
print '__set__',self,obj,val
def __delete__(self,obj):
print '__delete__',self,obj
class A(object):
d=Descriptor()
if __name__ == '__main__':
('__get__', &__main__.Descriptor object at 0x&, &__main__.A object at 0x&, &class '__main__.A'&)
__set__ &__main__.Descriptor object at 0x& &__main__.A object at 0x& 3
__delete__ &__main__.Descriptor object at 0x& &__main__.A object at 0x&
可见，3个方法参数中的obj是Descriptor属性所在的对象，而owner参数（__get__中的owner参数）是该对象所属的类。
在上面的讨论中我们是通过实例操作属性，如果你作一下对应转换："实例转换到类，类转换到MetaClass"，那就是通过类操作属性的规则。这种对应转换也是容易理解的，应该类是用于创建对象的，而是用于创建类的。
class MetaClass(object):
class A(object):
__metaclass__=MetaClass
通过类访问属性
通过A.attr访问属性的规则为：
如果MetaClass中有__getattribute__，则直接返回该__getattribute__的结果。
如果attr是个Descriptor，则直接返回Descriptor的__get__的结果。
如果attr是通过属性，则直接返回attr的值
如果类中没有attr，且MetaClass中定义了__getattr__，则调用MetaClass中的__getattr__
如果类中没有attr，且MetaClass中没有定义__getattr__，则抛出异常AttributeError
通过类设置属性
通过A.attr=val给属性赋值时：
如果MetaClass中定义了__setattr__，则执行该__setattr__
如果该属性是Descriptor，且定义了__set__，则执行Descriptor的__set__
如果是普通属性或None-data Descriptor，则直接令attr=val
如果属性不存在，则动态给类添加该属性，然后进行赋值
通过类删除属性
通过del A.attr删除属性时：
如果MetaClass中定义了__delattr__，则执行该__delattr__
如果该属性是Descriptor，且定义了__delete__，则执行Descriptor的__delete__
如果是普通属性，或虽是Descriptor但是没有定义__delete__，则直接从A.__dict__中删除该属性
如果属性不存在，则抛出异常AttributeError
阅读(...) 评论() &2941人阅读
Python类、函数和模块（31）
http://在Python中，可以通过class关键字定义自己的类，然后通过自定义的类对象类创建实例对象。python类的创建创建一个Student的类，并且实现了这个类的初始化函数”__init__”:class Student(object):& & count = 0& & books = []& & def __init__(self, name):& & & & self.name = name接下来就通过上面的Student类来看看Python中类的相关内容。类构造和初始化”__init__”和”__new__”的联系和差别下面先通过一段代码看看这两个方法的调用顺序：12345678class A(object):&&&&def __init__(self,*args, **kwargs):&&&&&&&&print &init %s& %self.__class__&&&&def __new__(cls,*args, **kwargs):&&&&&&&&print &new %s& %cls&&&&&&&&return object.__new__(cls, *args, **kwargs)&a = A()从代码的输出可以看到，当通过类实例化一个对象的时候，”__new__”方法首先被调用，然后是”__init__”方法。一般来说，”__init__”和”__new__”函数都会有下面的形式：123456def__init__(self,*args,**kwargs):&&&&# func_suite&def__new__(cls,*args,**kwargs):&&&&# func_suitereturnobj对于”__new__”和”__init__”可以概括为：__new__特性“__new__”是在新式类中新出现的方法，它有以下行为特性：对于上面的第三点，如果当前类是直接继承自 object，那当前类的 “__new__” 方法返回的对象应该为：123def __new__(cls, *args, **kwargs):&&&&# func_suitereturn object.__new__(cls, *args, **kwargs)重写__new__如果（新式）类中没有重写”__new__”方法，Python默认是调用该类的直接父类的”__new__”方法来构造该类的实例，如果该类的父类也没有重写”__new__”，那么将一直按照同样的规则追溯至object的”__new__”方法，因为object是所有新式类的基类。而如果新式类中重写了”__new__”方法，那么可以选择任意一个其他的新式类（必须是新式类，只有新式类有”__new__”，因为所有新式类都是从object派生）的”__new__”方法来创建实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环。看一段例子代码：12345678910111213141516171819202122232425262728293031323334class Foo(object):&&&&def__new__(cls,*args,**kwargs):&&&&&&&&obj=object.__new__(cls,*args,**kwargs)& &&&&&&& # 这里等价于 super(Foo, cls).__new__(cls, *args, **kwargs)&&&&&&&&&&# object.__new__(Foo, *args, **kwargs)&&&&&&&&# Bar.__new__(cls, *args, **kwargs)&&&&&&&&# Student.__new__(cls, *args, **kwargs)，即使Student跟Foo没有关系，也是允许的，因为Student是从object派生的新式类&&&&&&&&&# 在任何新式类，不能调用自身的“__new__”来创建实例，因为这会造成死循环！所以要避免return Foo.__new__(cls, *args, **kwargs)或return cls.__new__(cls, *args, **kwargs)&&&&&&&&print&Call __new__ for %s&%obj.__class__&&&&&&&&returnobj&&&&&class Bar(Foo):&&&&def__new__(cls,*args,**kwargs):&&&&&&&&obj=object.__new__(cls,*args,**kwargs)&&&&&&&&&&print&Call __new__ for %s&%obj.__class__&&&&&&&&return obj&&&class Student(object):&&&&# 没有“__new__”方法，会自动调用其父类的“__new__”方法object.__new__(cls)来创建实例&&&&pass&classCar(object):&&&&def__new__(cls,*args,**kwargs):&&&&&&&&# 可以选择用Bar来创建实例&&&&&&&&obj=object.__new__(Bar,*args,**kwargs)&&&&&&&&&&print&Call __new__ for %s&%obj.__class__&&&&&&&&returnobj&foo=Foo()bar=Bar()car=Car()代码的输出为：__init__的调用“__new__”决定是否要使用该类的”__init__”方法，因为”__new__” 可以调用其他类的构造方法或者直接返回别的类创建的对象来作为本类的实例。通常来说，新式类开始实例化时，”__new__”方法会返回cls（cls指代当前类）的实例，然后调用该类的”__init__”方法作为初始化方法，该方法接收这个实例（即self）作为自己的第一个参数，然后依次传入”__new__”方法中接收的位置参数和命名参数。但是，如果”__new__”没有返回cls（即当前类，不能是其它类）的实例，那么当前类的”__init__”方法是不会被调用的。例子：Python1234567891011121314151617181920class A(object):&&&&def __init__(self, *args, **kwargs):&&&&&&&&print &Call __init__ from %s& %self.__class__&&&&&def __new__(cls, *args, **kwargs):&&&&&&&&obj = object.__new__(cls, *args, **kwargs)&&&&&&&&print &Call __new__ for %s& %obj.__class__&&&&&&&&return obj&& &class B(object):&&&&def __init__(self, *args, **kwargs):&&&&&&&&print &Call __init__ from %s& %self.__class__&&&&&def __new__(cls, *args, **kwargs):&&&&&&&&obj = object.__new__(A, *args, **kwargs)&&&&&&&&print &Call __new__ for %s& %obj.__class__&&&&&&&&return obj&&&&&&&b = B()print type(b)代码中，在B的”__new__”方法中，通过”obj = object.__new__(A, *args, **kwargs)”创建了一个A的实例，在这种情况下，B的”__init__”函数就不会被调用到。派生不可变类型关于”__new__”方法还有一个重要的用途就是用来派生不可变类型。例如，Python中float是不可变类型，如果想要从float中派生一个子类，就要实现”__new__”方法：Python12345678classRound2Float(float):&&&&def__new__(cls,num):&&&&&&&&num=round(num,2)&&&&&&&&#return super(Round2Float, cls).__new__(cls, num)&&&&&&&&returnfloat.__new__(Round2Float,num)&f=Round2Float(4.14159)printf代码中从float派生出了一个Round2Float类，该类的实例就是保留小数点后两位的浮点数。[]通过内建函数dir()，或者访问类的字典属性__dict__，这两种方式都可以查看类有哪些属性。数据属性类数据属性和实例数据属性在上面的Student类中，”count”&books”&name”和”age”都被称为类的数据属性，但是它们又分为类数据属性和实例数据属性。类变量紧接在类名后面定义，相当于java和c++的static变量实例变量在__init__里定义，相当于java和c++的普通变量&&& class test:& & & & &count = 0;类变量& & & & def __init__(self, c):& & & & & & &&self.count&= 实例变量& & & & & & &self.__class__.count = self.__class__.count + 1;&&& a = test(3)&&& a.count3&&& test.count1[]对于类数据属性和实例数据属性，可以总结为：Note: lz实例对象直接修改类属性只对当前对象有效，类属性和其它实例对象的值并不会改变。特殊的类属性对于所有的类，都有一组特殊的属性：类属性含义__name__类的名字（字符串）__doc__类的文档字符串__bases__类的所有父类组成的元组__dict__类的属性组成的字典__module__类所属的模块__class__类对象的类型Note:文档字符串对于类，函数/方法，以及模块来说是唯一的，也就是说__doc__属性是不能从父类中继承来的。属性隐藏从上面的介绍了解到，类数据属性属于类本身，被所有该类的实例共享；并且，通过实例可以去访问/修改类属性。但是，在通过实例中访问类属性的时候一定要谨慎，因为可能出现属性”隐藏”的情况。继续使用上面的Student类，来看看属性隐藏：wilber = Student(&Wilber&, 28)&print &Student.count is wilber.count: &, Student.count is wilber.countwilber.count = 1 & &print &Student.count is wilber.count: &, Student.count is wilber.countprint Student.__dict__print wilber.__dict__del wilber.countprint &Student.count is wilber.count: &, Student.count is wilber.count&print&wilber.count += 3 & &print &Student.count is wilber.count: &, Student.count is wilber.countprint Student.__dict__print wilber.__dict__&del wilber.countprint&print &Student.books is wilber.books: &, Student.books is wilber.bookswilber.books = [&C#&, &Python&]print &Student.books is wilber.books: &, Student.books is wilber.booksprint Student.__dict__print wilber.__dict__del wilber.booksprint &Student.books is wilber.books: &, Student.books is wilber.books&print&wilber.books.append(&CSS&)print &Student.books is wilber.books: &, Student.books is wilber.booksprint Student.__dict__print wilber.__dict__代码的输出为：分析一下上面代码的输出：Note: 虽然通过实例可以访问类属性，但是，不建议这么做，最好还是通过类名来访问类属性，从而避免属性隐藏带来的不必要麻烦。方法在一个类中，可能出现三种方法，实例方法、静态方法和类方法，下面来看看三种方法的不同。实例方法实例方法的第一个参数必须是”self”，”self”类似于C++中的”this”。实例方法只能通过类实例进行调用，这时候”self”就代表这个类实例本身。通过”self”可以直接访问实例的属性。类外定义实例方法# Function defined outside the class
def f1(self, x, y):
return min(x, x+y)
def g(self):
return 'hello world'
h = g类中调用时使用self.f()就可以[https://docs.python.org/3/tutorial/classes.html ][]类方法类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod装饰器。通过cls可以访问类的相关属性。class Student(object):& & '''& & this is a Student class& & '''& & count = 0& & books = []& & def __init__(self, name, age):& & & & self.name = name& & & & self.age = age&& & @classmethod& & def printClassInfo(cls):& & & & print cls.__name__& & & & print dir(cls)& & pass&Student.printClassInfo() & &wilber = Student(&Wilber&, 28)wilber.printClassInfo()代码的输出为，从这段代码可以看到，类方法可以通过类名访问，也可以通过实例访问。静态方法与实例方法和类方法不同，静态方法没有参数限制，既不需要实例参数，也不需要类参数，定义的时候使用@staticmethod装饰器。同类方法一样，静态法可以通过类名访问，也可以通过实例访问。class Student(object):& & '''& & this is a Student class& & '''& & count = 0& & books = []& & def __init__(self, name, age):& & & & self.name = name& & & & self.age = age&& & @staticmethod& & def printClassAttr():& & & & print Student.count& & & & print Student.books& & pass&Student.printClassAttr() & &wilber = Student(&Wilber&, 28)wilber.printClassAttr()这三种方法的主要区别在于参数，实例方法被绑定到一个实例，只能通过实例进行调用；但是对于静态方法和类方法，可以通过类名和实例两种方式进行调用。[]&访问控制Python中没有访问控制的关键字，例如private、protected等等。但是，在Python编码中，有一些约定来进行访问控制。“_”和” __”的使用 更多的是一种规范/约定，不没有真正达到限制的目的：“_”：以单下划线开头的表示的是protected类型的变量，即只能允许其本身与子类进行访问；同时表示弱内部变量标示，如，当使用”from moduleNmae import *”时，不会将以一个下划线开头的对象引入。“__”：双下划线的表示的是private类型的变量。只能是允许这个类本身进行访问了，连子类也不可以，这类属性在运行时属性名会加上单下划线和类名。单下划线”_”在Python中，通过单下划线”_”来实现模块级别的私有化，一般约定以单下划线”_”开头的变量、函数为模块私有的，也就是说”from moduleName import *”将不会引入以单下划线”_”开头的变量、函数。现在有一个模块lib.py，内容用如下，模块中一个变量名和一个函数名分别以”_”开头：Python12345678910numA&=&10_numA&=&100&def&printNum():&&&&print&&numA is:&,&numA&&&&print&&_numA is:&,&_numA&def&_printNum():&&&&print&&numA is:&,&numAprint&&_numA is:&,&_numA当通过下面代码引入lib.py这个模块后，所有的以”_”开头的变量和函数都没有被引入，如果访问将会抛出异常：Python123456from&lib&import&*print&numAprintNum()&print&_numA#print _printNum()双下划线”__”对于Python中的类属性，可以通过双下划线”__”来实现一定程度的私有化，因为双下划线开头的属性在运行时会被”混淆”（mangling）。在Student类中，加入了一个”__address”属性：Python12345678910class&Student(object):&&&&def&__init__(self,&name,&age):&&&&&&&&self.name&=&name&&&&&&&&self.age&=&age&&&&&&&&self.__address&=&&Shanghai&&&&&&pass&wilber&=&Student(&Wilber&,&28)print&wilber.__address当通过实例wilber访问这个属性的时候，就会得到一个异常，提示属性”__address”不存在。其实，通过内建函数dir()就可以看到其中的一些原由，”__address”属性在运行时，属性名被改为了”_Student__address”（属性名前增加了单下划线和类名）Python1234567&&&&wilber&=&Student(&Wilber&,&28)&&&&dir(wilber)['_Student__address',&'__class__',&'__delattr__',&'__dict__',&'__doc__',&'__format__',&'__getattribute__',&'__hash__',&'__init__',&'__module__',&'__new__',&'__reduce__',&'__reduce_ex__',&'__repr__',&'__setattr__',&'__sizeof__',&'__str__',&'__subclasshook__',&'__weakref__',&'age',&'name']&&&所以说，即使是双下划线，也没有实现属性的私有化，因为通过下面的方式还是可以直接访问”__address”属性&&&&wilber&=&Student(&Wilber&,&28)&&&&print&wilber._Student__addressShanghai&&&双下划线的另一个重要的目地避免子类对父类同名属性的冲突。看下面一个例子：class A(object):& & def __init__(self):& & & & self.__private()& & & & self.public()&& & def __private(self):& & & & print 'A.__private()'&& & def public(self):& & & & print 'A.public()'&class B(A):& & def __private(self):& & & & print 'B.__private()'&& & def public(self):& & & & print 'B.public()'&b = B()当实例化B的时候，由于没有定义__init__函数，将调用父类的__init__，但是由于双下划线的”混淆”效果，”self.__private()”将变成 “self._A__private()”。看到这里，就清楚为什么会有如下输出了：A.__private()B.public()from:ref: []
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2755423次
积分：26337
积分：26337
排名：第238名
原创：555篇
转载：30篇
评论：251条
文章：16篇
阅读：2639
文章：21篇
阅读：126141
阅读：41637
文章：13篇
阅读：83258
阅读：48666
文章：16篇
阅读：121432
文章：18篇
阅读：59108
Contact me