python advanced programming ( II )

面向对象编程

---

简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。数据封装、继承和多态是面向对象的三大特点。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是

面向对象中的类（Class）的概念。

给对象发消息实际上就是调用对象对应的关联函数，称之为对象的方法（Method）

---

OOP最重要的概念就是类（Class）和实例（Instance），牢记类是抽象的模板，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。(艾维铝酉和cjk区别——#)

定义类通过class关键字

 class Student(object):
     pass  

 #object表示该类是从哪个类继承下来的，如果没有合适的继承类就使用object类，这是所有类最终都会继承的类。

创建实例通过类名+()

 bart = Student()                        

可以给实例的变量绑定属性

 bart.name = 'Bart Simpson'

由于类可以起到模板的作用，在创建实例的时候可以通过定义__init__方法把认为必要的属性强制填写进去绑定

 class Student(object):

      def __init__(self, name, score):   #将name和score属性绑定
          self.name = name
          self.score = score

  #__init__方法的第一个参数永远是self，表示创建的实例本身，因此可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了而必须传入与__init__方法匹配的参数，self不需要传

 >>> bart = Student('Bart Simpson', 59)
 >>> bart.name
 'Bart Simpson'
 >>> bart.score
 59

在类中定义的函数和普通函数相比只有一点不同，就是第一个参数永远是实例变量self，并且调用时不用传递该参数。

访问实例的数据，没必要用外面的函数去访问，可以直接在类的内部定义访问数据的函数，这样，就把“数据”给封装起来了，称为数据封装。这些封装数据的函数是和类本身是关联起来的，称为类的方法

 class Student(object):

     def __init__(self, name, score):
         self.name = name
         self.score = score

     def print_score(self):
         print('%s: %s' % (self.name, self.score))  #调用方法>>>bart.print_score() 

封装的一个好处是不用知道内部实现的细节容易调用，另一个是好处是可以给类增加新的方法

 class Student(object):
     ...

     def get_grade(self):              #给该类增加一个get_grade方法
         if self.score >= 90:
             return 'A'
         elif self.score >= 60:
             return 'B'
         else:
             return 'C'

注：

类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；

方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据（普通函数需要访问类）；

---

使用上述方法可以隐藏内部复杂逻辑，而在属性名称前加上两个下划线__可以访问限制，使得外部代码不能自由修改实例的属性

 class Student(object):

     def __init__(self, name, score):         #之前>>> bart.score  98
                                              #   >>> bart.score = 59
 5                                              #   >>> bart.score   59
         self.__name = name
         self.__score = score                 #之后>>> bart.__name  Error

     def print_score(self):
         print('%s: %s' % (self.__name, self.__score))

如果外部代码要获取属性，可以给类增加get_name和get_score这样的方法

 class Student(object):
     ...

     def get_name(self):
         return self.__name

     def get_score(self):
         return self.__score

如果又要允许外部代码修改属性，可以再给类增加set_score方法

 class Student(object):
     ...

     def set_score(self, score):
         self.__score = score

注：

类似__xxx__是特殊变量，可以直接访问，但是不要定义这样的变量名

一个下划线开头的变量，可以被外部访问，但是约定俗成视为私有变量，不要随意访问

两个下划线开头的变量，可以通过   实例名._类名__变量名   来访问（不同版本.后的可能不同）

总的来说就是，Python本身没有任何机制阻止你干坏事，一切全靠自觉。

---

OOP程序设计中定义一个class的时候，可以从某个现有的class继承，子类将获得了父类的全部功能（方法），也可以对子类增加方法。如果一个变量是子类的数据类型，那么它同时也是父类、爷类...类型，这就是多态

 class Animal(object):                    #编写一个名为Animal的class
     def run(self):
         print('Animal is running...')

 class Dog(Animal):                       #直接从Animal类继承
     pass

 运行
 dog = Dog()
 dog.run()
 Animal is running...

 class Dog(Animal):                      #对子类增加方法

     def run(self):
         print('Dog is running...')
18
19 运行
20 Dog is running...                       #调用时子类会覆盖与父类定义同名的方法

多态的好处

def run_twice(animal):    #定义一个接收Animal类型的函数
    animal.run()          #调用函数时不管参数是父类Animal()其子类比如Dog()，实际调用的都是类中各自定义的叫 run 的方法，只要                            实参是形参的子类，无需修改函数
                                     

注：

如果需要传入Animal类型，对于静态语言（如JAVA）传入的对象必须是Animal类型或其子类，否则无法调用run方法。对于动态语言（如Python），则不一定需要传入Animal类型，只需要保证传入的对象有一个run()方法就可以了。

---

获取对象信息

判断对象类型：基本类型都可以用type()，指向函数或者类的变量也可以用type()判断，返回对应的Class类型。

判断class的类型，可以使用isinstance( ，)函数，返回布尔值。

获得对象的所有属性和方法：可以使用dir()函数，返回一个包含字符串的list，

 >>> hasattr(obj, 'x')     # 有属性'x'吗？
 True
 >>> obj.x
 9
 >>> hasattr(obj, 'y')     # 有属性'y'吗？
 False
 >>> setattr(obj, 'y', 19)     # 设置一个属性'y'
 >>> hasattr(obj, 'y')     # 有属性'y'吗？
 True
 >>> getattr(obj, 'y')     # 获取属性'y'
 19
 >>> obj.y     # 获取属性'y'
 19
 >>> fn = getattr(obj, 'y') # 获取属性'y'并赋值到变量fn

 #通过内置的一系列函数，可以对任意一个Python对象进行剖析，拿到其内部的数据。

注：

由于Python是动态语言，根据类创建的实例可以任意绑定属性。

---

给实例绑定属性

 class Student(object):               #通过self变量
     def __init__(self, name):
         self.name = name

 s = Student('Bob')                   #通过实例变量
 s.score = 90

给类绑定属性

 class Student(object):       #直接在class中定义属性
     name = 'Student'

实例属性比类属性优先级高

给实例绑定方法

 >>> def set_age(self, age): # 定义一个函数作为实例方法
 ...     self.age = age
 ...
 >>> from types import MethodType
 >>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
 >>> s.set_age(25) # 调用实例方法
 >>> s.age # 测试结果
 25

给类绑定方法，相当于给其所有实例绑定了方法

 >>> def set_score(self, score):        #定义一个函数并把它绑定给类
 ...     self.score = score
 ...
 >>> Student.set_score = set_score

限制实例的属性，在定义class的时候定义一个特殊的__slots__变量，比如只允许实例Student添加添加name和age属性：

 class Student(object):
     __slots__ = ('name', 'age')     # 用tuple装允许绑定的属性名称
                                               

如果暴露性地绑定属性（绑定在定义外），无法检查绑定的参数是否合法，可以通过内置方法来解决，然后通过python内置的@property装饰器将getter方法变成属性简单的使用，同时另一个装饰器@.setter把绑值setter方法变成属性。

 class Student(object):

     @property                           #编写获得值的方法并变成属性
     def score(self):
         return self._score

     @score.setter                       #编写带自检的设值（绑定属性）方法并变成属性
     def score(self, value):
         if not isinstance(value, int):
             raise ValueError('score must be an integer!')
         if value < 0 or value > 100:
             raise ValueError('score must between 0 ~ 100!')
         self._score = value

如果只定义getter方法（@property），不定义setter方法（@.setter）就是一个只读属性

注：

动态绑定允许在程序运行的过程中动态给class加上功能，静态语言必须定义在class中。

---

面向对象高级编程

---

通过多重继承，一个子类就可以同时获得多个父类的所有功能。这种继承如果按树型层次继承是复杂度呈指数增长，所以采用称之为MixIn的设计。设计类的继承关系时，设计单一继承下来的主线，将需要混入的额外功能的父类名尾加MixIn，这样就可以优先考虑通过多重继承来组合多个MixIn的功能，而不是设计多层次的复杂的继承关系。

EXP Python自带了TCPServer和UDPServer这两类网络服务，而要同时服务多个用户就必须使用多进程或多线程模型，这两种模型由ForkingMixIn和ThreadingMixIn提供。通过组合，就可以创造出合适的服务来。

 class MyTCPServer(TCPServer, ForkingMixIn):    #编写一个多进程模式的TCP服务
     pass

 class MyUDPServer(UDPServer, ThreadingMixIn):    #编写一个多线程模式的UDP服务
     pass

注：

只允许单一继承的语言（如Java）不能使用MixIn的设计。

---

定制类

枚举类：Enum类可以把一组相关常量定义在一个class中，即用枚举类型定义一个class，每个常量都是class的一个唯一实例。

 from enum import Enum            #定义Monthe类型的枚举类

 Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))                     #可以用Month.XXX引用一个常量

 for name, member in Month.__members__.items():
     print(name, '=>', member, ',', member.value)
 #枚举所有成员，value属性则是自动赋给成员的int常量，默认从1开始计数。

 from enum import Enum, unique     #可以通过从Enum派生出自定义类更精确的控制枚举

 @unique                           #@unique装饰器可以帮助检查保证没有重复值。
 class Weekday(Enum):
     Sun = 0                       # Sun的value被设定为0
     Mon = 1
     Tue = 2
     Wed = 3
     Thu = 4
     Fri = 5
     Sat = 6

type()函数既可以返回一个对象的类型，又可以创建出新的类型。

要创建一个class对象，type()函数依次传入3个参数：

1. class的名称；
2. 继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
3. class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。

 >>> def fn(self, name='world'): # 先定义函数
 ...     print('Hello, %s.' % name)
 ...
 >>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class

通过type()函数创建的类和直接写class是完全一样的，但是type()函数也允许我们动态创建出类来。

元类：除了使用type()动态创建类以外，要控制类的创建行为，还可以使用metaclass，直译为元类，简单的解释就是：先定义metaclass，就可以创建类，最后创建实例，可以把类看成是metaclass创建出来的“实例”。

metaclass是Python面向对象里最难理解，也是最难使用的魔术代码，它可以改变类创建时的行为，功能强大，但不常用，使用起来务必小心。