python Class(类) and

发布时间：2019-06-27 09:49:56编辑：auto阅读（1767）

Python类与面向对象
   程序=指令+数据　(或算法+数据结构)。代码可以选择以指令为核心或以数据为核心进行编写。
   两种类型
       (1)以指令为核心：围绕“正在发生什么”进行编写(面向过程编程：程序具有一系列线性步骤；主体思想是代码作用于数据)以指令为中心，程序员的主要工作在于设计算法。
       (2)以数据为核心：围绕“将影响谁”进行编写(面向对象编程OOP：围绕数据及为数据严格定义的接口来组织程序，用数据控制对代码的访问)
   
面向对象编程的核心概念
    所有编程语言的最终目的都是提供一种抽像方法。
    在机器模型("解空间"或"方案空间")与实际解决的问题模型("问题空间")之间，程序员必须建立一种联系。
    (1)面向过程：程序=算法+数据结构
    (2)面向对象：将问题空间中的元素以及它们在解空间中的表示物抽象为对象，并允许通过问题来描述问题而不是方案(可以把实例想象成一种新型变量，它保存着数据，但可以对自身的数据执行操作)
    类是由状态集合(数据)和转换这些状态的操作集合组成
    类：定义了被多个同一类型对象共享的结构和行为(数据和代码)
    (1)类的数据和代码：即类的成员
        数据：成员变量或实例变量
        成员方法：简称为方法，是操作数据的代码，用于定义如何使用成员变量；因此一个类的行为和接口是通过方法来定义的。
    (2)方法和变量：
        私有：内部使用；公共：外部可见

 面向对象的程序设计方法
    所有东西都是对象；程序是一大堆对象的组合。
    通过消息传递，各对象知道自己该做什么。

    消息：即调用请求，它调用的是隶属目标对象的一个方法
    每个对象都有自己的存储空间，并可容纳其它对象；通过封装现有对象，可以制作成新型对象
    每个对象都属于某一类型：
        类型，也即类； 对象是类的实例；类的一个重要特性为“能发什么样的消息给它”。
        同一个类的所有对象都能接收相同的消息。
   
对象的接口
    定义一个类之后，可以根据需要实例化出多个对象
    如何利用对象完成真正有用的工作呢？
        必须有一种办法能向对象发出请求，令其做一些事情(方法)
        每个对象仅能接受特定的请求(方法)；能向对象发送的请求由其“接口”进行定义；对象的“类型”或“类”则规定了它的接口形式。  
   
类
    将同一种具体物事的共同特性抽象出来的表现。
    类内部定义了其状态和转换这些状态的操作。
    类被实例化为对象时才有相关的一些数据，才会对该对象的一些属性进行赋值，这些值就是所谓的数据。从某种角度理解这些对象属性就是变量。为对象属性赋值就是为变量赋值。这些对象的属性(即变量)都是在类中定义的数据结构体。
    方法：就是函数，就是操作变量引用的数据代码。方法的作用就是为了操作数据。        
    类间的关系：
        依赖("uses-a")：一个类的方法操纵另一个类的对象
        聚合("has-a")：类A的对象包含类B的对象
        继承("is-a")：描述特殊与一般关系
   
面向对象编程的原则
    面向对象编程的模型机制有3个原则：封装、继承及多态
    封装(encapsulation)
        隐藏实现方案细节；将代码及其处理的数据绑定在一起的一种编程制作，用于保证程序和数据不受外部干扰且不会被误用。
    继承(Inheritance)
        一个对象获得另一个对象属性的过程；用于实现按层分类的概念
        一个深度继承的子类继承了类层次中它的每个祖先的所有属性
        超类、基类、父类；子类、派生类
    多态性(Polymorphism)
       允许一个接口被多个通用的类动作使用的特性，具体使用哪个动作与应用场景相关。
       一个接口，多个访问：用于为一组相关的动作设计一个通用的接口，以降低程序复杂性。
   
Python的类和实例
    类是一种数据结构，可用于创建实例。一般情况下，类封装了：数据和要用于该数据的方法
    python类是一个可调用对象，即类对象；python2.2之后，类是一种自定义类型，而实例则是声明某个自定义类型的变量
    实例初始化；通过调用类来创建实例
        instance = ClassName(args...)
        类在实例化时可以使用__init__和__del__两个特殊的方法
    类本身是一个对象，被实例化出来的实例也是一种对象。也就是所谓的类对象与实例对象。
    编写类的代码就是一个类对象，但这些代码不会自动执行，只有在被实例化之后，这些类对象的代码执行从而产生了一个具体的实例对象。
        type(list)
        type(l1)
   
Python中创建类
    python使用class关键字创建类，语法格式如下：


class  class_name(bases):
    'class documentation string'
    class_suite

    超类是一个或多个用于继承的父类的集合
    类体可以包含：声明语句、类成员定义、数据属性、方法
        注意：如果不存在继承关系，ClassName后面的"(bases)"可以不提供；类文档为可选
    class 语句的一般形式


class class_name(bases):
    data = value                定义数据(类属性)
    self method(self,....):     定义方法
        self.member = value     定义实例属性

class TestClass():              定义类对象
    pass
                
type(TestClass)
obj1 = TestClass()              被实例化出来的实例对象

 例：Python中，class语句类似def，是可执行代码；直到运行class语句后类才会存在


class FirstClass():        定义类名为FirstClass
    spam = 30              定义数据属性
    def display(self):     定义类方法，属于可调用的属性
        print self.spam
        
x = FirstClass()           实例化出一个对象x
x.display()                调用x对象的display方法
                           class语句内，任何赋值语句都会创建类的属性；每个实例对象都会继承类的属性并获得自己的名称空间。

class SecClass():
    data = 'hello SecClass'
    def printdata(self):
    print "Content from method: %s" % self.data
    
inst2 = SecClass()  
inst2.data              获取对象的data属性
inst2.printdata()       执行对象的printdata()方法
        
class ThirdClass():
    data = 'hello Thirdclass'
    def setdata(self,x)
        self.str1 = x
    def printdata(self):
        print self.str1
        
inst3 = ThirdClass()
inst3.data              返回对象的属性
inst3.setdata('test')   调用对象的setdata()方法，并传递参数'test'
inst3.getdata()         调用对象的getdata()方法


python类方法及调用
    实例（对象）通常包含属性
        可调用的属性：方法
            object.method()
            数据属性
    在OOP中，实例就像是带有"数据"的记录，而类是处理这些记录的"程序"
    通过实例调用方法相当于调用所属类的方法来处理当前实例。类似instance.method(args...)会被自动转换为class.method(instance,args...)。如前面的例子，x.display()会被自动转换为FirstClass.display(x)，即调用类的方法来处理实例x。
    因此，类中每个方法必须具有self参数，它隐含当前实例之意。在方法内对self属性做赋值运算会产生每个实例自己的属性。
    python规定，没有实例，方法不允许被调用，此即为“绑定”
   
    class语句中的赋值语句会创建类属性，如前面例子中的spam
    在类方法中对传给该方法的特殊参数self进行赋值会创建实例属性。
    例
       class Myclass():
           gander = 'Thompson'
           def setName(self,who):
               self.name = who                
       x = Myclass()
       y = Myclass()
       
       x.gender    返回x对象的gender属性，通过爬树搜索，gender属性会从MyClass类中获取到
       x.name      在SetName方法调用之前，Myclass类不会把name属性附加到实例x上，当然也可以重载__init__创建构造器直接为实例提供。所以系统提示错误
       x.setName('tom')
       y.setName('jerry')      调用y对象的setName方法，并传递参数给name属性        
       y.gender, y.name
       x.gender, x.name
   
Python构造器
    python中都有一个构造器的方法
    __varname__() 方法，会被python解释器自动调用。当类被实例化成对象时，这些访问就会被自动调用。
    创建实例时，python会自动调用类中的__init__方法，以隐性地为实例提供属性。__init__方法被称为构造器。如果类中没有定义__init__方法，实例创建之初仅是一个简单的名称空间。
       例
       class Myclass():
           gender = 'Male'
           def __init__(self,who):
               self.name = who
       x = Myclass('tom')
       y = Myclass('jerry')
       x.gender, x.name
       y.gender, y.name
       
析构器
       class Animal:
           name = 'someone'    定义数据属性(成员变量)
           def __init__(self,voice='HI'):  定义构造函数，参数设置默认值
               self.voice = voice
           def __del__(self):      定义析构函数
               pass
           del saySomething(self):     定义方法(成员函数)
               print self.voice        
       tom = Animal()
       tom.saySomething()        
       jerry = Animal("Hello")
       jerry.saySomething()
       
类的特殊属性
       可以使用类的__dict__字典属性或python内置的dir()函数来获取类的属性
       dir(MyClass)
       MyClass.__dict__        每个对象自己的__dict__属性中保存了本对象支持的所有属性和方法
       Class.__name__      以字符串方式返回类的名字
       Class.__doc__           返回类class的文档字符串
       Class.__bases__         返回类class的所有父类构成的元组
       Class.__module__        返回类c定义所在的模块 (python1.5后期版本新增功能)
       Class.__class__             返回实例Class对应的类(仅新式类中)
   
实例的属性
    实例仅拥有数据属性(严格意义上来说，方法是类属性)
        通常通过构造器"__init__"为实例提供属性；这些数据属性独立于其它实例或类；实例释放时，其属性也将被清除
        内建函数dir()或实例的特殊属性__dict__可用于查看实例属性
           dir(inst1)
        实例的特殊属性：
           Inst1.__class__     实例化Inst1的类
           Inst1.__dict__      Inst1的属性
   
Python类方法中可用的变量
    方法的可用变量
        实例变量：指定变量名称及实例自身进行引用
            self.变量名
        局部变量：方法内部创建的变量，可直接使用
        类变量(也称为静态变量)：在类中定义的变量；只有通过指定变量名与类名进行引用
            类名.变量名
            全局变量：直接使用            
       例：
       In [1]: class c1():
          ...:     d1 = 'hello c1 class'
          ...:     def __init__(self,x):
          ...:         self.instdata = x
          ...:        
       In [2]: inst1 = c1(50)
       In [3]: inst1.d1
       Out[3]: 'hello c1 class'
       In [4]: inst1.instdata
       Out[4]: 50
       In [5]: inst2 = c1(60)
       In [6]: inst2.d1
       Out[6]: 'hello c1 class'
       In [7]: inst2.instdata
       Out[7]: 60
       In [8]: inst1.d1 = 'instance1 new value'
       In [9]: inst1.d1
       Out[9]: 'instance1 new value'
       In [10]: inst2.d1
       Out[10]: 'hello c1 class'
       In [11]: c1.d1 = 'class c1 new value'
       In [12]: inst1.d1
       Out[12]: 'instance1 new value'
       In [13]: inst2.d1
       Out[13]: 'class c1 new value'

继承
    继承描述了基类的属性如何“遗传”给派生类
       子类可以继承它的基类的任何属性，包括数据属性和方法；一个未指定基类的类，其默认有一个名为object的基类；python允许多重继承
       创建子类：创建子类时，只需要在类名后跟一个或从其中派生的父类
           class SubClassName(ParentClass1[, ParentClass2, ...])
               'optional class documentation string'
               class_suite    
       例：
       In [14]: class ParentClass(object):
          ....:     'Parent Class'
          ....:     gender = 'Male'
          ....:     def setName(self,who):
          ....:         self.name = who
          ....:
       In [15]: class ChildClass(ParentClass):
          ....:     'Child Class'
          ....:     def displayInfo(self):
          ....:         print self.gender, self.name
          ....:
       In [16]: x = ChildClass()
       In [17]: x.setName('tom')       该方法是继承父类的
       In [18]: x.displayInfo()
       Male tom
       In [19]: dir(ParentClass)
       Out[19]:
       ['__class__',
        '__delattr__',
        '__dict__',
        '__doc__',
        '__format__',
        '__getattribute__',
        '__hash__',
        '__init__',
        '__module__',
        '__new__',
        '__reduce__',
        '__reduce_ex__',
        '__repr__',
        '__setattr__',
        '__sizeof__',
        '__str__',
        '__subclasshook__',
        '__weakref__',
        'gender',
        'setName']

       In [20]: dir(ChildClass)
       Out[20]:
       ['__class__',
        '__delattr__',
        '__dict__',
        '__doc__',
        '__format__',
        '__getattribute__',
        '__hash__',
        '__init__',
        '__module__',
        '__new__',
        '__reduce__',
        '__reduce_ex__',
        '__repr__',
        '__setattr__',
        '__sizeof__',
        '__str__',
        '__subclasshook__',
        '__weakref__',
        'displayInfo',
        'gender',
        'setName']
       In [21]: x.name
       Out[21]: 'tom'
       
   继承方法专用化：继承会先在子类寻找变量名，然后才查找超类，因此，子类可以对超类的属性重新定义来取代继承而来的行为。
   子类可以完全取代从超类继承而来的属性；也可以通过已覆盖的方法回调超类来扩展超类的方法
           例：
           In [22]: class ParClass(object):
              ....:     def setInfo(self, sex='Male'):
              ....:         self.gender = sex
              ....:
           In [23]: class ChiClass(ParClass):
              ....:     def setInfo(self,who):         此方法名与父类方法名相同，所以覆盖父类中的方法
              ....:         self.name = who
              ....:
           In [24]: x = ChiClass()
           In [26]: x.setInfo('tom')
           In [27]: x.name
           Out[27]: 'tom'
           In [28]: x.gender    由此子类中的setInfo方法已经覆盖父类中的setInfo方法，而子类中的setInfo方法并无gender属性，所以系统提示错误信息
           ---------------------------------------------------------------------------
           AttributeError                            Traceback (most recent call last)
           <ipython-input-28-dcfdb2ec694c> in <module>()
           ----> 1 x.gender
           AttributeError: 'ChiClass' object has no attribute 'gender'
           In [29]:
           例：
           In [29]: class ParClass(object):
              ....:     def setInfo(self,sex='Male'):
              ....:         self.gender = sex
              ....:
           In [30]: class ChiClass(ParClass):
              ....:     def setInfo(self,who):         子类中的setInfo方法覆盖父类中的setInfo方法
              ....:         self.name = who
              ....:         ParClass.setInfo(self)     在子类中再次回调其父类中的setInfo方法
              ....:
           In [31]: x = ChiClass()
           In [32]: x.setInfo('tom')
           In [33]: x.name
           Out[33]: 'tom'
           In [34]: x.gender           由于子类中再次调用父类中的setInfo方法，所以此时实例x可以使用父类继承来的gender属性
           Out[34]: 'Male'
           In [35]:

       例：
       class father:    
           def __init__(self):
               self.name="father class"
               print "father __init__"
           def fa_method(self):
               print "father method test"        
           def bad(self):
               print "smoke、drink"

       class son(father):    
           def __init__(self):
               self.name="son class"
               print "son __init__"
               father.__init__(self)   #在子类中调用父类的构造函数
             #super(son,self).__init__()  #通过supper函数也可以调用父类中的构造函数，但父类必须指明是(object)的子类
           def son_method(self):
               print "son method test"              
           #def bad(self):     #实现基类(父类)重写
           #    print "smoke"
           def bad(self):
               father.bad(self)    #引用父类中的bad方法
               print "gamble"
               
       s1=son()    #实例化一个s1对象
       s1.son_method()
       print s1.name
       s1.fa_method()      #继承父类的方法
       s1.bad()            #调用bad方法，该方法默认继承父类，但如果子类中实现了重写，则调用子类中的新方法
   
   python类的继承和属性搜索
       python中几乎所有属性的获取都可以使用“object.attribute”的格式；不过，此表达式会在python中启动搜索--搜索连续的树
       class语句会产生一个类对象，对class的调用会创建实例，实例自动连结至创建了此实例的类
       派生类连结至其基类的方式：将基类列在派生类头部的括号内，其从左至右的顺序会决定树中的次序；由下至上，由左至右

经典类与新式类
   如果类继承了object类，称为新式类；新式类兼容经典类；如果类没有指明继承object，称为经典类
   新式类多出了一些内置方法和属性；通过新式类可以设置访问权限
       对于其它语言来说，object类默认就是所有任何类的基类，不需要手工指明
   继承基类的搜索顺序：经典类深度优先，而新式类广度优先

       例1：
       class A:
           def __init__(self):
               print 'This is A class'
           def save(self):
               print 'save method from A'

       class B(A):
           def __init__(self):
               print 'This is B class'
           #在B类中没有定义Save方法，它会继承父类A

       class C(A):
           def __init__(self):
               print 'This is C class'
           def save(self):
               print 'save method from C---'

       class D(B,C):
           def __init__(self):
               print 'This is D class'

       d1=D()
       d1.save()
       #本例为经典类，在调用d1对象的save()时，它的继承搜索路径是自左至右(先搜索B类中的save方法，B类又继承了A类)
       #所以本例的输出结果为：
       This is D class
       save method from A
       
       例2：
       class A(object):
           def __init__(self):
               print 'This is A class'
           def save(self):
               print 'save method from A'

       class B(A):
           def __init__(self):
               print 'This is B class'
           #在B类中没有定义Save方法，它会继承父类A

       class C(A):
           def __init__(self):
               print 'This is C class'
           def save(self):
               print 'save method from C---'

       class D(B,C):
           def __init__(self):
               print 'This is D class'

       d1=D()
       d1.save()
       #本例为新式类，新式类的搜索为：广度优先(先搜索B，B类没有定义save方法，再搜索C)
       #所以输出结果为：
       This is D class
       save method from C---
       
       例：
       class class3:    
           def __init__(self):
               pass    
           def __del__(self):
               print "销毁中..."
           def go(self):
               print "Go"
           def __call__(self):     #内置__call__方法的使用
               print "Call"
       c3=class3()
       c3.go()
       c3()                        #通过call方法可以调用类的默认方法
       
       特性：经典类和新式类中的特性的区别 ，经典类中的特性全部都是可读可写的(没有只读的功能)
       class Person:
           def __init__(self):
               self.__name__ = 'Thompson'
           @property
           def Name(self):
               return self.__name
       p1 = Person()
       print p1.name        #通过特性Name，读取self.__name的值
       p1.Name = 'xxx'     #通过特性Name，设置self.__name的值

       #新式类中的特性默认都是只读，如果想要设置，那么就需要再创建一个被装饰@xxxx.setter修饰的特性　
       class Person(object):
           def __init__(self):
               self.__name = 'alex'
           @property
           def Name(self):
               return self.__name                
       p1 = Person()
       print p1.Name      #通过特性Name，读取self.__name的值
       p1.Name = 'xx'     # Error 通过特性Name设置self.__name 的值时，会出现错误

       #新式类这么做好处是什么呢？通过这样来防止对私有变量的修改，所有的对象就只能读取，不能修改
       #应用场景:
       class Person(object):
           def __init__(self,gene,clothes):
               self.__gene = gene
               self.__clothes = clothes                
           @property
           def Gene(self):         #通过该方法读取__gene属性
               return self.__gene            
           @property
           def Clothes(self):      #通过该方法读取__clothes属性
               return self.__clothes                
           @Clothes.setter         #此处的名称必须与上面的读取函数名称相同
           def Clothes(self,value):
               self.__clothes = value
       p1 = Person('AB','bikini')      #创建基因为AB的人，衣服是比基尼
       print p1.Gene               #可以获取人的基因
       print p1.Clothes            # 通过Clothes方法读取衣服属性
       p1.Clothes = 'skirt'        #修改p1的衣服为skirt
       print p1.Clothes            #再次读取Clothes属性
       p1.Gene='O'                 #修改基因时系统提示错误，无法修改。
       
类、实例和其它对象常见的内建函数
       issubclass()    布尔函数，判断一个类是否同另一个类派生，语法：issubclass(sub,sup)
       isinstance()    布尔函数，判断一个对象是否是给定类的实例，语法：isinstance(obj1, class_obj2)
       hasattr()       布尔函数，判断一个对象是否拥有指定的属性，语法：hasattr(obj,'attr')；同类的函数还有getattr()、setattr()和delattr()
       super()
           在子类中找出其父类以便于调用其属性；一般情况下仅能采用非绑定方式调用祖先类方法
           而super()可用于传入实例或类型对象，语法：super(type[, obj])
       例：
       In [36]: issubclass(ChiClass,ParClass)
       Out[36]: True
       In [37]: issubclass(ParClass,object)
       Out[37]: True
       In [38]: isinstance(x,ChiClass)     #x为对象名
       Out[38]: True
       In [39]: hasattr(x,'name')
       Out[39]: True
       In [40]: hasattr(x,'gender')
       Out[40]: True

运算符重载
    运算符重载是指在方法(如__name__的方法)中拦截内置的操作--当类的实例出现在内置操作中，python会自动调用自定义的方法，并且返回自定义方法的操作结果。
    运算符重载让类拦截常规的python运算
        类可重载所有python表达式运算符； 类也可重载打印、函数调用、属性点号运算等内置运算
        重载使类实例的行为像内置类型；重载通过提供特殊名称的类方法实现
    运算符重载并非必需，并且通常也不是默认的

    类可以重载python的操作符，重载使我们的对象与内置的一样。
    __x__的名字的方法是特殊的挂钩（hook），python通过这 种特殊的命名来拦截操作符，以实现重载。
    python在计算操作符时会自动调用这样的方法，例如： 如果对象继承了__add__方法，当它出现在+表达式中时会调用这个方法。
    通过重载，用户定义的对象就像内置的一样。 在类中重载操作符
       1、操作符重载使得类能拦截标准的python操作。
       2、类可以重载所有的python的表达式操作符。
       3、类可以重载对象操作：print,函数调用，限定等。
       4、重载使得类的实例看起来更像内置的。
       5、重载是通过特殊命名的类方法来实现的。
       方法名        重载的操作说明        调用表达式
       __init__        构造函数            创建对象：class()
       __del__        析构函数             释放对象的时候
       __add__        “+”                      x + y
       __or__           “|”                        x | y
       __repr__        打印，转换         print x, `x`
       __call__        函数调用                x()
       __getattr__    属性引用             x.undefined
       __getitem__    索引                   x[key],for循环,in测试
       __setitem__    索引赋值             x[key] = value
       __getslice__    分片                    x[low:high]
       __len__         长度                      len(x)
       __cmp__        比较                     x == Y ，x < y
       __radd__      右边的操作符"+"      非实例 + x 例子：

       例：
       class indexer:
           def __getitem__(self,index):
               return index**2
       x=indexer()
       for i in range(5):
           print x[i]
       print ":",__getitem__(x,5)
       输出结果为：
       0
       1
       4
       9
       16
       : 25
       
       例：
       In [13]: class test:
          ....:     def __init__(self,x):
          ....:         self.x=x
          ....:     def __add__(self,y):
          ....:         return x+y
          ....:    
       In [14]: c1=test(5)
       In [15]: print c1.__add__(6)
       11
       In [16]: print c1.x
       5
       In [17]: dir(c1)
       Out[17]: ['__add__', '__doc__', '__init__', '__module__', 'x']

基于特殊的方法定制类
    除了__init__和__del__之外，python类支持使用许多的特殊方法
        特殊方法都以双下划线开头和结尾，有些特殊方法有默认行为，没有默认行为的是为了留到需要的时候再实现。
        这些特殊方法是python中用来扩充类的强大工具，它们可以实现：模拟标准类型、重载操作符
        特殊方法允许类通过重载标准操作符+，＊，甚至包括分段下标及映射操作[]来模拟标准类型。

抽象类
       from abc import ABCMeta,abstractmethod
       class Alert:
           __metaclass__=ABCMeta
           @abstractmethod
           def send(self):pass
           
       class Email(Alert):            
           def __init__(self):
               self.name='email alter'              
           def send(self):
               print 'test'
           
       notify=Email()
       notify.send()
       #抽象类＋抽象方法＝定义接口
       
总结
   可调用对象：函数(内置函数/自定义函数)、类、类方法 (支持调用操作，支持小括号的方法)
       函数的属性：
           __doc__
           __name__
           __dict__
           __code__
           __globals__
       
       实例方法/ 类方法 / 静态方法
       
       方法的属性：
           __doc__
           __name__
           __class__  方法所属的类
           __func__  实现该方法的函数对象
           __self__ 调用此方法的实例
           
       内置函数：
           __doc__
           __name__
           __self__
           
   类：
       __doc__
       __name__
       __bases__
       __dict__        输出对象所有的属性
       __module__  定义了当前类的模块名称
       
   实例:
       __class__
       __dict__
       
   对象都有特殊方法：
       __init__
       __new__()
       __del__()
       __ge__()
       
   a >= b      a.__ge__(b)

关键字：