# -*- 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
#通过实例属性访问类属性（需要谨慎）
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
python基础学习12（核心编程第二版）部分,布布扣,bubuko.com
原文地址：http://www.cnblogs.com/mhxy13867806343/p/3820784.html
