python学习笔记之六：更加抽象

Python被称为面向对象的语言，创建自己的对象是python非常核心的概念。这里会介绍如何创建对象，以及多态，封装，方法，特性，超类以及继承的概念。

一. 对象的魔力

面向对象程序设计中的术语 对象 基本上可以看做数据以及由一系列可以存取，操作这些数据的方法所组成的集合。对象最重要的几个有点包括以下几个方面：

（1）多态：意味着可以对不同类的对象使用同样的操作，它们会像被施了魔法一样工作；

（2）封装：对外部世界隐藏对象的工作细节；

（3）继承：以普通的类为基础建立专门的类对象；

 

1.1 多态

      多态意味着就算不知道变量所引用的对象类型是什么，还是能对它进行操作，而它也会根据对象类型的不同而表现出不同的行为。

很多函数和运算符都是多态的--而你写的大多数程序可能都是，即便你并非有意这样。只要使用多态函数和运算符，多态就“消除”了。事实上，唯一能够毁掉多态的就是使用函数显示地检查类型，比如type，isinstance以及issubclass函数等。如果可能的话，应该尽力避免使用这些毁掉多态的方式。

 

1.2 封装

      封装是对全局作用域中其他区域隐藏多余信息的原则。多态可以让用户对于不知道是什么类的对象进行方法调用，而封装是可以不用关心对象是如何构建的而直接进行使用。

 假设有个叫OpenObject的类：

>>> o = OpenObject()
>>> o.setName('sss')
>>> o.getName()
'sss'

创建了一个对象，将变量o绑定到该对象上。假设变量o将它的名字存储在全局变量globalName中：

>>> globalName 
'sss'

这样意味着在使用OpenObject类的实例时，不得不关心globalName的内容，要确保不会对它进行任何更改。如果创建了多个OpenObject实例的话就会出现问题，因为变量相同，所以可能会混淆：

>>> o1 = OpenObject()
>>> o2 = OpenObject()
>>> o1.setName('aaa')
>>> o2.getName()
'aaa'

可以看到设定一个名字后，其他的名字也自动设定了。这里我们就需要把名字封装在对象内，将其作为特性存储。特性是对象内部的变量。

      对象有它自己的状态，对象的状态由它的特性来描述，对象的方法可以改变它的特性。所以就像是将一大堆函数捆绑在一起，并且给予它们访问变量的权力，它们可以在函数调用之间保持保存的值。

 

1.3 继承

继承是另一个懒惰的行为，程序员不想把同一段代码写好几次，如果已经有了一个类，又想建立一个非常类似的类，新的类可能只是添加几个方法，这时候就可以让新的类从旧的类继承方法。

 

二. 类和类型

2.1 创建自己的类

__metaclass__ = type 

class Person:
    def setName(self,name):
        self.name = name

    def getName(self):
        return self.name

    def greet(self):
        print self.name

所谓的旧式类和新式类之间是有区别的，在新式类的语法中，需要在模块或者脚本开始的地方放置赋值语句__metaclass__ = type 。

上面的例子中，class语句会在函数定于的地方创建自己的命名空间，self就是对于对象自身的引用。没有它的话，成员方法就无法访问他们要对其特性进行操作的对象本身了。

>>> foo = Person()
>>> bar = Person()
>>> foo.setName('foos')
>>> bar.setName('bars')
>>> foo.greet()
foos
>>> bar.greet()
bars

对象的特性是可以外部访问的：

>>> foo = Person()
>>> foo.name = 'ss'
>>> foo.name
'ss'

 

 2.2 特性，函数和方法

self参数是方法和函数的区别，方法将它们的第一个参数绑定到所属的实例上，因此调用时这个参数不必提供。

      默认情况下，程序可以从外部访问一个对象的特性。有人认为这样破坏了封装的原则，为了避免对象的特性被其他人误用，应该使用私有特性，这是外部对象无法访问，但是getName和setName等访问器能够访问的特性。python并不直接支持私有化，而要靠程序员自己把握在外部进行特性修改的时机。为了让方法或者特性变为私有，只要在它的名字前面加上双下划线即可。

      在类的内部定义中，以双下划线开始的名字都被“翻译”成前面加上单下划线和类名的形式。

（这里我也没大看懂。）

 

 2.3 类的命名空间

创建一个类后，所有位于class语句中的代码都在特殊的命名空间中执行---类命名空间。这个命名空间可由类内所有成员访问。

 

 2.4 指定超类

子类可由扩展超类的定义。将其他类名写在class语句后的圆括号内可由指定超类：

__metaclass__ = type 

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):
    def init(self):
        self.blocked = ['spam']

Filter类的用处在于它可由用做其他类的基类，比如spamFilter类，可以将‘spam’过滤出去：

>>> f = spamFilter()
>>> f.init()
>>> f.filter(['spam','ss','bb','spam'])
['ss', 'bb']

 

 2.5 调查继承

如果想要查看一个类是否是另一个的子类，可以使用内建的issubclass函数：

>>> issubclass(spamFilter,Filter)
True
>>> issubclass(Filter,spamFilter)
False

如果想知道已知类的基类（们），可以直接使用它的特殊特性__bases__：

>>> spamFilter.__bases__
(<class '__main__.Filter'>,)
>>> Filter.__bases__
(<type 'object'>,)

同样，还能使用isinstance方法检查一个对象是否是一个类的实例：

>>> s = spamFilter()
>>> isinstance(s,spamFilter)
True
>>> isinstance(s,Filter)
True
>>> isinstance(s,str)
False

如果想知道一个对象属于哪个类，可以使用__class__特性：

>>> s.__class__
<class '__main__.spamFilter'>

 

 2.6 多个超类

__metaclass__ = type 

class Calculator:
    def calculator(self,expression):
        self.value = eval(expression)

class Talker:
    def talk(self):
        print "hi"

class TalkingCalculate(Calculate,Talker):
    pass

以上这种行为叫多重继承，是个非常有用的工具，但是除非读者特别熟悉多重继承，否则应该尽力避免使用，因为有时候会出现不可预见的麻烦。

      当使用多重继承时，要注意一下超类的顺序：先继承的类中的方法会重写后继承的类中的方法。