# -*- coding: utf-8 -*-

# ====================

#File: python

#Author: python

#Date: 2014

#====================

__author__ = ‘Administrator‘

#python class

#面向对象编程oop思想，3个特性：封装、继承、多态,在其他方面的功能，比如重载，模拟等，也可以自定义自己需要的类

#在python中，面向对象主要2个：类和类实例

#类与实例

#类与实例有关系 的：类是对象的定义，而实例是真正的实物，存储了类中所定义对象具体信息

#python中如何创建一个类

#经典类

class MC01:

    pass

#新式类

class Mc(object):

    pass

#说明

"""

关键字:class 后面紧接一个类名，然后定义类体代码，新式类和经典类的区别是：新式类必须继承至少一个父类，参数bases可以是一个（单独的继承）或者多个（多重继承）用于继承父类

object是所有类之母，如果没有继承任何其他父类，object将作为默认的父类，位于所有类继承结构最上面，当没有直接或者间接子类化一个对象，就定义成经典类

"""

#创建实例过程叫实例化

myc=MC01()#经典类实例

print dir(myc)

myc1=Mc()#新式类实例

print dir(myc1)

myc1.x=4

myc1.y=5

print dir(myc1)

"""

myc1.x=4

myc1.y=5

.x,.y只是实例属性，而不是Mc()的属性,是myc1的独有属性

"""

#然后就可以对它进行操作

print myc1.x*myc1.y

#方法

#如果给类添加功能，那就是需要方法，如何在类中定义方法，但只能被实例调用，

"""

定义类（与方法），创建一个实例，让这个实例调用方法

"""

#例子

class MyDate(object):#创建类

    def printfoo(self):#创建方法

        print u‘复习下python 调用printfoo(self)方法‘

#self参数，是所有方法声明中都存在，表示实例对象本身，当使用实例调用方法时，解释器会悄悄传递给方法，所以不需要自己传递self，因为它是自动传入的

#在其他语言中self被叫this

#self一般在方法中使用，在静态方法或者类方法中不会，其中类方法只需要类而不需要实例

md=MyDate()#创建实例md

md.printfoo()#调用md.printfoo()方法

#__init__()类似构造器，它在创建一个新对象时被调用，在python中,__init__()实际上不是一个构造器，没有调用‘new‘来创建一个新对象（python没new关键字）

#在创建实例后，在实例过程中,调用__init__()方法时，当一个类被实例化时，可以定义额外的行为，比如，设定初始化值或者其他方法--主要是在实例被创建后，调用返回这个实例之前，支执行某些特定的任务或者设置

#例子

class Adderboox(object):#定义类

    ‘address book‘

    def __init__(self,nm,ph):#初始化

        self.name=nm#设置name参数

        self.phon=ph

        print ‘created instance for:%s‘%(self.name)

    def updates(self,newph):#定义方法

        self.phon=newph

        print ‘update ph:%s‘%(self.phon)

#创建实例化

#jon=Adderboox()#当在初始化中设置了多少参数，就必须要输入多少内容

#TypeError: __init__() takes exactly 3 arguments (1 given)

#jon=Adderboox(‘jonb‘)

#同上TypeError: __init__() takes exactly 3 arguments (2 given)

jon=Adderboox(‘jonb‘,‘123456789‘)

print dir(jon)

#访问实例化属性

print jon.name#访问实例化属性jon.name

print jon.phon

#方法调用（通过实例）

jon.updates(‘1990123456-4567-789‘)

print jon.phon

#updates()只需要一个参数（不计self）

#创建子类

class Endate(Adderboox):#创建子类

    u‘增加员工内容‘

    def __init__(self,nm,ph,id,em):

        Adderboox.__init__(self,nm,ph)

        self.empid=id

        self.email=em

    def updateE(self,new1):

        self.email=new1

        print u‘更新/增加email:%s‘%(self.email)

#当一个类被派生出来，子类会继承基类的属性

#然后其他方法和父类操作类似

#面向对象编程

"""

从简单控制流中按步指令序列进入到更有组织方式中，依靠代码块可以命名子程序和完成既定功能，结构化的或者过程性编程可以让我们把程序组织成逻辑块，以便重复或者重用，这样变的更有逻辑性，出现的情况也更堆满

才能以约束创建成数据

OOD（面向对象设计）

"""

#面向对象设计与面向对象编程关系

#OOD可以由纯结构化语言实现，比如C，但如果想要构造具有对象性质和特点的数据类型，就需要在程序上作更多的努力，当语言中出现OO特性，那么更加高效

#一门面向对象的语言不强制你写的OO方面程序

#oo常用术语

"""

抽象/实现:是指对现在世界问题和实体的本质表现,行为,特性建模，建立相关的子集，可以用于描绘程序结构，从而实现模块，抽象不仅包括了模块属性，还定义数据接口，对某种抽象的实现就对此数据及与之相关的接口现实化，现实化这个过程对于客户程序应当是透明而且无关的

"""

"""

封装/接口：对数据、信息进行隐藏的观念，对沼气属性提供接口和访问函数，通过任何客户端直接对数据访问，作了实现的一部分，在python中所有类属性都是公开的，但可能

名字被混淆了，以阻止未经受权的访问，在设计时，对数据相应的接口，以免客户程序通过不堆满的操作来存取封装数据属性

"""

"""

合成：对扩充类的描述，让很多不同的类合成成一个大的类，解决问题，合成成一个描述复杂异常的系统，

"""

#重点

"""

派生/继承/结构

派生是描述子类创建，新式类保留已存类类型中所有需要的数据和行为，但允许修改或者其他自定义操作，但不会修改原类定义

继承是描述子类属性从祖先类继承的一种方式

泛化/特化

泛化表示所有子类与其父类及祖先尖一样的特点，所有子类可以认为同祖先类是“是一个”的关系，因为一个派生对象（实例）是祖先类的一个‘例子’

特化描述所有子类的自定义，也就是什么属性让它与基祖先类不同

多态指出了对象如何通过他们共同的属性和动作来访问和操作，而不需要考虑他们具体的类

表示了动态绑定的存在，允许重载和运行时类型确定和验证

"""

"""

自省/反射

自省表示给予你：程序员，某种能力来进行像‘手工类型检查’的工作，也叫反射，这个特点：展示了某对象是如何在运行期间取得自身信息

"""

#类class

#创建函数和创建类的方法如下:

def funcs(ars):

    ‘ars is funcs()‘#函数文档字符串

    print ars #语句体

class ClassName(object):

    ‘object is ClassName‘#类文档字符串

    pass#语句体

#说明

"""

类与函数都允许在他们声明中创建函数，闭包或者内部函数，还有在类中定义的方法，它像一个容器类型

"""

#创建类

class C1(object):

    u‘C1是类名,括号里面如果没有父类，就默认使用object所有类的最大的母类‘

    print u‘创建一个简单的类‘#类体(语句体)

#python不支持虚函数或者抽象方法

#类属性class atter

#就是属于另一个对象的数据或者函数元素，通过句号属性标识法来

#例子

"""

sys.stdout.write(‘foo‘)

print module.class.__doc__

list1.append(map(upper,open(x).readlines()))

"""

#类的数据属性

#也叫静态变量或者静态数据，表示这些数据与所属的类是绑定的，不依赖任何实现

#例子

class C(object):

    foo=100#类属性

print u‘类属性:(%s)‘%(C.foo)

C.foo+=1

print C.foo

#Methods方法

class MyClass(object):

    def myMethods(self):#方法,在类中不能叫函数

        print u‘类方法中:myMethods‘

        pass

mc=MyClass()

mc.myMethods()

#如果直接对类中的方法直接调用，就出现异常

#myMethods()NameError: name ‘myMethods‘ is not defined

#使用类调用方法，也会失败

#MyClass.myMethods()TypeError: unbound method myMethods() must be called with MyClass instance as first argument (got nothing instead)

#绑定与非绑定方法

"""

在python中，如果没有实例def a(self):中的a方法是无法调用的，这样限制了所描述绑定的概念，在此，方法必须绑定到（一个实例）才能直接被调用，非绑定的方法可能被调用，但实例对象一定明确给出，才能确定调用成功，

不管是否绑定，方法都是它所在类固有的属性，即使它们几乎问题是通过实例来调用

"""

#决定类的属性

"""

使用内建函数dir()查看，另一个通过访问类的字典属性__dict__

推荐使用__dict__属性

"""

class Mc1(object):

    ‘mcis class‘

    myv1=1.1#静态数据

    def shows(self):#方法

        print self.myv1

print dir(Mc1)

print Mc1.__dict__#字典{}

print Mc1.__name__#类的名字Mc1

print Mc1.__doc__#文档mcis class

print Mc1.__bases__#父类构成的元组(<type ‘object‘>,)

print Mc1.__module__#模块__main__

print Mc1.__class__#对应的类(只对新式类)<type ‘type‘>

#python支持模块部的类继承，1.5引入了__module__

class Cx(object):

    pass

print Cx

print Cx.__module__

"""

类C的命名是__main__.C

"""

#实例

#类如果是数据结构，那么实例则是声明了这样的类型变量

#初始化

#在其他语言中有new关键字，通过new创建实例，

#pythob创建实例的方法

class MYClassNew(object):#定义类（创建类）

    pass

mc12=MYClassNew()#初始化类（创建实例）

print type(mc12)

print type(MYClassNew)

#__init__()构造器方法

#当类被调用时，实例化第一步是创建实例对象，一量对象被创建了，python会检查是否实现了__init__()方法，在默认情况下，如果没有定义或者覆盖特殊方法__init__()

#对实例不会施加任何特别的操作，任何所需的特定操作，都需要程序员实现__init__()方法,覆盖它默认行为，如果没有现在，则返回它的对象，这样就完毕

#当如果已经实现了，那么它将被调用，实例对象作为第一参数(self)被传入进去。像标准方法调用一样，调用类时，传进的任何参数都交给__init__()，实际上，把创建实例的调用当成对构造器的调用

"""

a:没有通过调用new来创建实例，没定义一个构造器，是python为你创建了对象

b:__init__()是在解释器为你创建一个实例后调用的第一个方法，在开始使用它之前，这一步可以让你做些准备工作

__init__()是很多类定义的特殊方法之王，有些特殊方法是预定的，缺省情况下，不进行任何操作，比如

__init__()要定制，对它进行重载，还有方法比如__add___(),__str__等

"""

#__new__()构造器方法

"""

与__init__()相比，__new__()方法更像一个真正的构造器，比如需要一个通过实例化不可变的对象，比如派生字符串，数字等

在这样的情况下，解释器会调用类的__new__()方法，一个静态的方法，并且传入参数在类实例化操作时生成，__new__()会调用父类的__new__()来创建对象（向上代理）

__new__()必须返回一个合法的实例，当解释器在调用__init__()时，就会把这个实例作为self传给它，调用父类的__new__()来创建对象，与其他语言的new一样

__new__()和__init__()在类创建时，都传入(相同)的参数

区别：“__new__：创建对象时调用，返回当前对象的一个实例

__init__：创建完对象后调用，对当前对象的实例的一些初始化，无返回值

”

"""

#注意：如果同时存在__new__ ,__init__则__new__比__init__先运行，__new__将返回一个对象

#__new__()例子

class A(object):

    def __init__(self):

        print ‘__init__1‘

    def __new__(self):

        print ‘__new__1‘

A()

class A1(object):

    def __init__(self):

        print "init"

    def __new__(cls,*args, **kwargs):

        print "new %s"%cls

        return object.__new__(cls, *args, **kwargs)

A1()

"""

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行

"""

#__del__() 解构器方法

"""

由于python具有垃圾对象回收机制（靠引用计数），当实例对象所有引用都被清除时，__del__()才会被执行，一般情况下没被实现

"""

#例子

class F1(object):

    def __init__(self):

        self._bar={‘test‘:self.test}

        print ‘construct‘

    def test(self):

        print ‘test‘

    def __del__(self):

        print ‘del‘

f=F1()

del f

#实例属性

#使用默认值，与函数一样

#def

def func(f=2):

    f*=2

    print f

func()

func(2.3)

#class中默认值，必须在__init__()构造器中初始化

class Afg(object):

    def __init__(self,rw,lv=0,qt=1.23):

        self.rw=rw

        self.lv=lv

        self.qt=qt

        print lv,qt

    def calt(self,d=2):

        abc=str(self.rw)+str(self.lv*self.qt)

        print abc

afg=Afg(‘abc‘)

afg.calt()

#__init__()应当返回None

#新式类

class Cx(object):

    pass

cx1=Cx()

print cx1

#经典类

class Mcx:

    def __init__(self):

        print ‘istaince‘

        return 1

#mcx=Mcx()TypeError: __init__() should return None

#查看实例属性dir(obj)

class Cx1(object):

    pass

c=Cx1()

c.f0=‘i is ‘

c.f1=‘xxoo‘

c.f2=‘you‘

print dir(Cx1)

print dir(c)

print c.f0+c.f1+c.f2

#经典类也可以使用新式类一样方法

class XX:

    pass

xx=XX()

xx.f1=1

print dir(XX)

print dir(xx)

print c.__dict__#获取字典的属性，也可以用vars()方法后面学习

#例子

x=3+3j

c=[type(getattr(x,i)for i in (‘conjugate‘,‘image‘,‘real‘))]

print c

#类属性

class C(object):

    version=1.2#静态成员或者类属性

c=C()#创建实例

print C.version#通过类访问类属性1.2

print c.version#通过实例访问类属性1.2

C.version+=.1#通过类更新类属性1.3

print C.version

print c.version#实例访问类属性，其值也改变1.3

print

#通过实例属性访问类属性（需要谨慎）

class Foo(object):

    x=1.5

foo=Foo()

print foo.x

foo.x=1.7#通过实例更新类属性

print foo.x#实例属性已更新1.7

print Foo.x#没有更新1.5

#删除实例属性

del foo.x

print foo.x#又变回了1.5

#可以通过__dict__实例方法

#foo.x=Foo.x+0.2

foo.x=Foo.x+.2

print foo.x

#如果在类属性可变情况下，结果就不一样

class Fx(object):

    x={2003:‘poe2‘}

fx=Fx()

print fx.x

fx.x[2004]=‘valid path‘

print Fx.x#更新了

print fx.x#更新了

#del  fx.xAttributeError: ‘Fx‘ object attribute ‘x‘ is read-only无法删除

#类属性持久性

#例子:绑定

class Test(object):

    def func(self,mness):

        print mness

#调用绑定方法

objecr=Test()#objecr=Test()生成一个实例，objecr.func返回一个绑定的方法，把实例object1和方法func绑定。

objecr.func(u‘绑定方法self‘)

#调用非绑定方法

obs=Test.func#利用类去引用方法，这样表示得到一个未绑定对象，要调用它就得传一个实例参数，如t(object1,‘未绑定的方法对象，需要传递一个实例‘) 。

obs(objecr,u‘非绑定方法self‘)

#注意:大多数时候，我们都直接调用方法，所以一般不会注意到方法对象。但是如果开始写通用的调用对象的代码时，需要特别仔细地注意未绑定方法，它们需要地传一个实例参数。

"""

未绑定的类方法：没有self

     通过类来引用方法返回一个未绑定方法对象。要调用它，你必须显示地提供一个实例作为第一个参数。

绑定的实例方法：有self

     通过实例访问方法返回一个绑定的方法对象。Python自动地给方法绑定一个实例，所以我们调用它时不用再传一个实例参数。

"""

class A(object):

    def f1(self):

        print u‘普通方法‘

    @staticmethod

    def f2():

        print u‘静态方法‘

    @classmethod

    def f3(cls):

        print cls.__name__

        print u‘类方法‘

if __name__ == ‘__main__‘:

    a=A()

    print dir(a)

    a.f1()#普通方法

    a.f2()#静态方法

    A.f2()#类中静态方法

    A.f3()#类中类方法

#实现静态方法和类方法的两种方式

"""

在2.3之前，用staticmethod和classmethod类型对象包装实现

"""

class Test1(object):

    def foo():

        print u‘staticmethod静态方法‘

    foo=staticmethod(foo)

test1=Test1()

test1.foo()

class Test2(object):

    def foo(cls):

        print cls.__dict__

        print  u‘classmethod(func)类方法‘

test2=Test2()

test2.foo()

#装饰器@

class T1(object):

    @staticmethod

    def foo(cls):

        print u‘静态方法装饰器‘,cls

    @classmethod

    def foo1(cls1):

        print u‘类方法装饰器‘,cls1

t1=T1()

t1.foo(‘str‘)

t1.foo1()

#子类和派生

#语法

"""

class 子类名(父类1,[父类2,.....]):

         pass

"""

#例子

#定义父类

class A1(object):

    def __init__(self,a):

        self.a=a

    def it(self):

        print self.a

        del self.a

#定义子类

class B1(A1):

    def chind(self):

        print u‘父类=%s‘%self.a

a11=A1(‘abcd‘)#父类的实例

print a11.a

b1=B1(‘abc‘)#子类的实例

print b1.a

print dir(a11)

print dir(b1)

a11.it()

b1.chind()#子类调用的方法

b1.it()#子类调用父类的方法

#继承：简单说了就是从父类身上面的属性复制到子类自己身上

class P(object):

    print u‘继承‘

class C(P):

    def __init__(self):

        print u‘继承父类p的属性‘

cxx=C()

print cxx

#__bases__类属性

"""

__bases__类属性，对任何(子)类，它是一个包含其父类的集合元组，是相对所有基类（包括了所有祖先类），如果没有父类的类，它们__bases__属性为空

Python类里的__bases__属性可知道这个类的父类是谁

"""

class AA(object):

    pass

class BB(AA):pass#AA的子类

class CC(BB):pass#BB的子类（AA间接子类）

print AA.__bases__

print CC.__bases__

#通过继承覆盖方法

#也就是在子类中对父类的方法进行覆盖

class P(object):

    def foo(self):

        print u‘未覆盖之前‘

class C(P):

    def foo(self):

        print u‘覆盖之后‘

p=P()

p.foo()

c=C()

c.foo()

#重写__init__不会自动调用父类的__init__

class P(object):

    def __init__(self):

        print ‘P()‘

class C(P):

    def __init__(self):

        print ‘C(P)‘

c=C()

c

#如果想调用父类的__init__(),使用一个子类的实例去调用基类（未绑定）方法

class D(P):

    def __init__(self):

        P.__init__(self)

        print ‘D(P)‘

d=D()

d

#使用super()超类解决上面问题

class D(P):

    def __init__(self):

        super(D,self).__init__()

        print ‘D`(P)‘

d=D()

d

#从标准类型派生

#不可变类型

class Rounds(float):

    def __new__(cls, a):

        return float.__new__(cls,round(a,2))

#使用super()

class Rounds(float):

    def __new__(cls, a):

        return  super(Rounds,cls).__new__(cls,round(a,2))

print Rounds(-1.723456)

#可变类型

class Sortes(dict):

    def keys(self):

        return sorted(super(Sortes,self).keys())

print Sortes(((‘z-c‘,65),(‘a-d‘,34)))

#多重继承

#方法解释顺序MRO

#顺序:深度优先，从左到右进行搜索，

print u‘经典类例子‘

class p1():

    def foo(self):

        print ‘p1‘

class p2():

    def foo(self):

        print ‘p2foo‘

    def bar(self):

        print ‘p2bar‘

class p3(p1,p2):

    pass

class p4(p1,p2):

    def bar(self):

        print ‘p4bar‘

class p5(p3,p4):

    pass

p6=p5()

p6.foo()

p6.bar()

"""

实例p6调用foo()时，搜索顺序:p6=>p3=>p1

实例p6调用bar()时，搜索顺序:p6=>p3=>p1=>p2

经典类的搜索方式是按照“从左至右，深度优先”的方式去查找属性。

d先查找自身是否有foo方法，没有则查找最近的父类C1里是否有该方法，如果没有则继续向上查找，直到在P1中找到该方法，查找结束。

"""

print u‘新式类例子‘

class P1(object):

    def foo(self):

        print ‘p1-foo‘

class P2(object):

    def foo(self):

        print ‘p2-foo‘

    def bar(self):

        print ‘p2-bar‘

class C1(P1,P2):

    pass

class C2(P1,P2):

    def bar(self):

        print ‘C2-bar‘

class D(C1,C2):

    pass

print D.__mro__   #只有新式类有__mro__属性，告诉查找顺序是怎样的

d=D()

d.foo()

d.bar()

"""

实例d调用foo()时，搜索顺序是 D => C1 => C2 => P1

实例d调用bar()时，搜索顺序是 D => C1 => C2

总结：新式类的搜索方式是采用“广度优先”的方式去查找属性。

"""

# 菱形效应引起MRO问题:导致经典类MRO会失败

"""

在版本2.2 中，类型与类的统一，带来了一个新的“问题”，波及所有从object（所有类型的祖先类）派生出来的（根）类，一个简单的继承结构变成了一个菱形。

这导致任何子类的实例化都会最终查找到object类中（新式类中object）是所有类的父类：

比如，D从B,C继承，但是实例化D的时候，你会发现C并不起任何的作用，因为你根本就到达不了C---在A那里卡住了。

"""

class B:

    pass

class C:

    def __init__(self):

        print ‘the default constructor‘

class D(B,C):

    pass

d=D()

"""

issubclass()

issubclass() 布尔函数判断一个类是另一个类的子类或子孙类。它有如下语法：

issubclass(sub, sup)

issubclass() 返回True 的情况：给出的子类sub 确实是父类sup 的一个子类（反之，则为False）。这个函数也允许“不严格”的子类，意味着，一个类可视为其自身的子类，所以，这个函数如果当sub 就是sup，或者从sup 派生而来，则返回True。（一个“严格的”子类是严格意义上的从一个类派生而来的子类。）

从Python 2.3 开始，issubclass()的第二个参数可以是可能的父类组成的tuple（元组），这时，只要第一个参数是给定元组中任何一个候选类的子类时，就会返回True。

"""

class A:

    pass

class B:

    pass

print issubclass(B,A)

"""

isinstance()

isinstance() 布尔函数在判定一个对象是否是另一个给定类的实例时，非常有用。语法如下：

isinstance(obj1, obj2)

isinstance()在obj1 是类obj2 的一个实例，或者是obj2 的子类的一个实例时，返回True（反之，则为False）

"""

print isinstance(1,int)

#getattr():getattr(object, name[, default]) -> value

class A:

    def __init__(self):

        self.name=‘zj‘

    def methond(self):

        print self.name

a=A()

print getattr(a,‘name‘)

#例子 getattr(x,‘f‘)相当于x.f，指定属性不存在，则出现异常

#•hasattr(object, name)

"""

说明：判断对象object是否包含名为name的特性（hasattr是通过调用getattr(ojbect, name)是否抛出异常来实现的）。

参数object：对象。

参数name：特性名称。

"""

print hasattr(list,‘add‘)

print hasattr(list,‘pop‘)

#setattr(object, name, value)

"""

这个函数是函数getattr（）的对应函数，函数的参数依次为：一个对象，一个字符串和一个任意值。字符串代表这个对象的一个属性，

这个属性可以是已经存在的，也可以是这个对象已存在的属性中没有的属性，如果情况属于后者的话，那就是为这个对象新建一个属性，命名为string。并将value赋给属性string

"""

def x():

    pass

setattr(x,‘abc‘,‘123‘)

print getattr(x,‘abc‘)

class X(object):

    pass

x=X()

setattr(x,‘self1‘,23)

print getattr(x,‘self1‘)

#delattr(object, name)

delattr(x,‘self1‘)

#super():__mro__

#语法:super(type[,obj])

"""

给出type,super()返回此type父类，如果要把父类绑定，可以传入obj参数(obj必须是type类型的)，否则父类无法绑定,obj参数也可以是一个类型

但它应当是type一个子类

当obj是一个实例是isinstance(obj,type)必须返回True

当obj是一个类或者类型,issubclass(obj,type)就必须返回True

"""

#vars()与dir()相似，只是给定对象参数必须有一个__dic__属性，返回一个字典，包含了对象存储于其__dict__中属性（键）和值，如果没有提供对象这样的属性

#则出现异常

#如果没有和为vars()一个参数，它将显示一个包含本地名字属性（键）及其值的字典，也就是locals()

class C(object):

    pass

c=C()

c.foo=100

c.bar=‘python‘

print c.__dict__

print vars(c)

#__getattr__(self,obj):

#getattr(a,b)

#__slots__类属性

#字典位置实例的中心，__dict__属性跟踪所有实例属性

"""

比如有一个实例a,它有一个属性xx

那使用a.f来访问它与使用a.__dict__[‘f‘]来访问一样的

字典会占用大量内存，如果数量很少时，有很多实例，这样的情况下，可以使用__slost__,

__slost__是一个类变量，由一序列对象组成，由所有合法标识构成实例属性的集合来表示，可以是一个列表，元组，可迭代对象，也可以是标识实例能拥有唯一属性的简单字符串

当创建一个不存在的名字不在__slost__名字的实例，则异常

"""

class Slotss(object):

    __slots__=(‘a‘,‘b‘)

c= Slotss()

print c

c.a=‘2‘

print c.a

#c.xx=111AttributeError: ‘Slotss‘ object has no attribute ‘xx‘

更多可以看官方文档

https://docs.python.org/2.7/index.html