《Python基础教程（第二版）》学习笔记 -> 第七章 更加抽象

对象的魔力

---

• 多态：意味着可以对不同类的对象使用同样的操作；
• 封装：对外部世界隐藏对象的工作细节；
• 继承：以普通的类为基础建立专门的类对象

1. 多态
   ① 多态和方法
   绑定到对象特性上面的函数称为方法（method）

   >>> from random import choice
   >>> x = choice(['hello,world!',[1,2,'e','e',4]])
   >>> x
   [1, 2, 'e', 'e', 4]
   >>> x.count('e')
   2

   本例中，可以看出列表胜出，但是关键点在于不需要检测类型：只需要知道x有个叫做count的方法，带有一个字符作为参数，并且返回整数数值就够了。

   ②多态的多种形式
   很多函数和运算符都是多态的，但唯一能够毁掉多态的就是适用函数显示地检查类型，比如type，isinstance以及issubclass函数等，如果可能的话，尽量避免适用这些毁掉多态的方式，示例如下：

   >>> def length_message(x):
       print "The length of ",repr(x),"is",len(x)
   
   >>> length_message('Python')
   The length of  'Python' is 6
   >>> length_message({'Python':'best'})
   The length of  {'Python': 'best'} is 1
   >>> length_message([1,2,3,4])
   The length of  [1, 2, 3, 4] is 4
   >>> length_message((1,2))
   The length of  (1, 2) is 2

   repr函数是多态特性的代表之一 ——可以对任何东西使用

2. 封装
   封装是对全局作用域中其他区域隐藏多余信息的原则。
   封装并不等同于多态。多态可以让用户对于不知道是什么类（或者对象类型）的对象进行防腐调用，而封装是可以不用关心对象是如何构建的而直接进行使用。
3. 继承
   继承是可以让一个类从已写好的类方法中完全继承其特性和方法。

类和类型

---

1. 类是什么
   类--一个对象。
   所有的对象都属于某一个类，称为类的实例。
   举例：
   百灵鸟类是“鸟类”的实例，当一个对象所属的类是另外一个对象所属类的子集时，前者就被称为后者的子类（subclass），所以“百灵鸟类”是“鸟类”的子类，“鸟类”是“百灵鸟类”的超类（superclass）。
2. 创建子集的类
   实例：

   __metaclass__ = type
   class Person:
       def setName(self,name):
           self.name = name
       def getName(self):
           return sele.name
       def greet(self):
           print "Hello, world! I'm %s" % self.name
   

   运行结果：

   >>> foo = Person()
   >>> bar = Person()
   >>> foo.setName('Luke')
   >>> bar.setName('Anak')
   >>> foo.greet()
   Hello, world! I'm Luke
   >>> bar.greet()
   Hello, world! I'm Anak
   >>> 

   Person是类的名字，class语句会在函数定义的地方创建子集的命名空间。

3. 特性、函数和方法
   上例中self参数事实上正是方法和函数的区别。方法将他们的第一个参数绑定到所属的实例上，因此这个参数可以不必提供。所以可以讲特性绑定到一个普通函数上，这样就不会有特殊的self参数了：

   >>> class Class:
       def method(self):
           print 'I have a self!'
   
   >>> def function():
       print "I don't ..."
   
   >>> instance = Class()
   >>> instance.method()
   I have a self!
   >>> instance.method = function
   >>> instance.method()
   I don't ...

   又比如：

   >>> class Bird:
       song = "Python"
       def sing(self):
           print self.song
   
   >>> bird = Bird()
   >>> bird.sing()
   Python
   >>> birdsong = bird.sing
   >>> birdsong()
   Python

4. 类的命名空间
   下面两个语句（几乎）等价：
   def foo(x): return x*x
   foo = lambda x: x*x
   定义类时，所有位于class语句中的代码都在特殊的命名空间中执行——类命名空间（class namespace）。这个命名空间可由类内所有成员访问。
5. 指定超类

   # -*- coding: cp936 -*-
   class Filter:
       def init(self):
           self.blocked = []
       def filter(self,sequence):
           return[x for x in sequence if x not in self.blocked]
   class SPAMFilter(Filter):#SPAMFilter 是 Filter 的子类
       def init(self): #重写init方法
           self.blocked = ['spam']

   运行结果：

   >>> f = Filter()
   >>> f.init()
   >>> f.filter([1,2,3])
   [1, 2, 3]
   >>> s = SPAMFilter()
   >>> s .init()
   >>> s.filter(['SPAM','Test','SPAM','pythom','SPAM'])
   ['Test', 'pythom']

   注意SPAMFilter定义的两个要点：

   ①这里用提供新定义的方式重写了Filter的init定义；
   ②filter 方法的定义是从Filter类中拿过来的（继承），所以不用重写它的定义

6. 多个超类
   源代码：

   class Calculator:
       def calculate(self, expression):
           self.value = eval(expression)
   
   class Talker:
       def talk(self):
           print "Hi, my value is" , self.value
   
   class TalkingCalculator(Calculator,Talker):
       pass

   运行结果：

   >>> tc = TalkingCalculator()
   >>> tc.calculate('1+2*3')
   >>> tc.talk()
   Hi, my value is 7

   这种行为成为多重继承（multiple inheritance）。

小结

---

• 对象：对象包括特性和方法。特性只是作为对象的一部分的变量，方法则是存储在对象内的函数。（绑定）方法和其他函数的区别在于方法总是将对象作为自己的第一个参数，这个参数一般称为self。
• 类： 类代表对象的集合，每个对象（实例）都有一个类，类的主要任务是定义 它的实例会用到的方法。
• 多态：多态是实现将不同类型和类的对象进行同样对待的特性——不需要知道对象属于哪个类就能调用的方法。
• 封装：对象可以将他们的内部状态隐藏（或封装）起来。
• 继承：一个类可以是一个或者多个类的子类。子类从超类继承所有的方法。可以使用多个超类。