Python基础教程【读书笔记】 - 2016/7/4

希望通过博客园持续的更新，分享和记录Python基础知识到高级应用的点点滴滴！

第二波：第7章  更加抽象

[总览] 创建自己的对象，是Python的核心概念！Python被称为面向对象的语言。介绍如何创建对象，以及多态、封装、方法、特性、超类以及继承的概念。

[7.1] 对象的魔力

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

　　多态polymorphism：意味着可以对不同类的对象使用同样的操作。

　　封装encapsulation：对外部世界隐藏对象的工作细节。

　　继承inheritance：以普通的类为基础简历专门的类对象。

　　面向对象程序设计最有趣的特性是多态。

[7.1.1] 多态

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

　　1. 多态和方法

　　绑定到对象特性上面的函数称为方法method。

　　2. 多态的多种形式

　　任何不知道对象到底是什么类型，但是又要对对象“做点什么”的时候，都会用到多态。很多内建运算符和函数都有多态的性质。唯一能够毁掉多态的就是使用函数显示地检查类型，比如type、isinstance以及issubclass函数等。

[7.1.2] 封装

　　封装是对全局作用域中其他区域隐藏多余信息的原则。和多态一样，它们都会帮助处理程序组件而不用过多关心多余细节。

　　封装不等同于多态。多态可有让用户对于不知道什么类（或对象类型）的对象进行方法调用，而封装是可以不用关心对象是如何构造的而直接进行使用。

[7.1.3] 继承

　　比如已经有了一个类，而又想建立一个非常类似的类，新的类肯那个只是添加几个方法。在编写新类时，又不想把旧类的代码全部复制故去，此时将使用到类的继承。

[7.2] 类和类型

　　什么是类，以及它和类型又有什么不同或相同。

[7.2.1] 类到底是什么

　　 类是一种对象。所有的对象都属于某一个类，称为类的实例instance。例如，鸟就是“鸟类”的实例。这就是一个有很多子类的一般类。可以将“鸟类”想象成所有鸟的集合，而”百灵鸟类“是其中的一个子集。当一个对象所属的类时另外一个对象所属类的子集时，前者就被称为后者的子类subclass，所以”百灵鸟类“是”鸟类“的子类。相反，”鸟类“是”百灵鸟类“的超类superclass。

　　Python中，习惯上都使用单数名词，并且首字母大写。

　　定义子类只是定义更多的方法的过程。

[7.2.2] 创建自己的类

　　__metaclass__=type

　　class Person:

　　　　def setName(self,name):

　　　　　　self.name=name

　　　　def getName(self):

　　　　　　return self.name

　　　　def greet(self):

　　　　　　print "Hello,World!I'm %s." % self.name

　　新式类的语法中，需要在模块或者脚本开始的地方放置赋值语句__metaclass__=type。

　　这个例子包含3个方法定义，除了它们是写在class语句里面外，一切都像是函数定义。Person是类的名字。class语句会在函数定义的地方创建子集的命名空间。self参数看起来有点奇怪，self它是对于对象自身的引用。在调用foo的setName和greet函数时，foo自动将自己作为第一个参数传入函数中，因此形象地命名为self。因为它总是对象自身，所以习惯上总是叫self。

　　特性是可以在外部访问的。

　　foo.name

　　如果知道foo是Person的实例的话，那么嗨可以把foo.greet()看做Person.greet(foo)方便的简写。

[7.2.3】 特性、函数和方法

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

　　【ToDo：再论私有化】

　　Python并不直接支持私有方式，而要靠程序员自己把握izai外部进行特性修改的时机。毕竟在使用对象前应该知道如何使用，但是可以用一些小技巧达到私有特性的效果。

　　为了让方法或特性变为私有（从外部无法访问），只要在它的名字前面加上双下划线即可：

　　class Secretive:

　　　　def __inaccessible(self):

　　　　　　print "Bet you can't see me..."

　　　　def accessible(self):

　　　　　　print "The secret message is:"

　　　　　　self.__inacessible()

　　现在__inacessible从外界是无法访问的，而在类内部还能使用访问。类的内部定义中，所有以双下划线开始的名字都被”翻译“成前面加上单下划线和雷鸣的形式。

　　如果不需要使用这种方法，但是又想让其他对象不要访问内部数据，那么可以使用但下划线。前面有下划线的名字都不会被带有型号的import语句（from module import *）导入。

[7.2.4] 类的命名空间

　　所有位于class语句中的代码都在特殊的命名空间中执行---类命名空间class namespace。这个命名空间可由类内部所有成员访问。类的定义其实就是执行代码块。

[7.2.5] 指定超累

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

　　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): #重写Filter超类中的init方法

　　　　　　self.blocked=['SPAM']

　　注意SPAMFilter定义的两个要点：

　　　　这里用提供新定义的方式重写了Filter的init定义。

　　　　filter方法的定义是从Filter类中继承的，所以不用重写它的定义。　

　　第二个要点揭示了继承的用处。

[7.2.6] 调查继承

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

　　issubclass(SPAMFilter,Filter)

　　如果想要知道已知类的基类，可以直接使用它的特殊特性__bases__:

　　SPAMFilter.__bases__

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

　　isinstance(s,SPAMFilter)

[7.2.7] 多个超累

　　__bases__这个复数形式，暗示它的基类可能会多于一个。

　　子类从自己的超类继承所有的行为。称为多重继承（multiple inheritance），是个非常有用的工具。

　　当使用多重继承时，有个需要注意的地方。如果一个方法从多个超类继承，那么必须要注意一下超类的顺序：先继承的类中的方法会重写后继承的类中的方法。如果超类们共享一个超类，那么在查找给定方法或者特性时访问超类的顺序称为MRO（Method Resolution Order，方法判定顺序）。

[7.2.8] 接口和内省

　　”接口“的概念与多态有关。在处理多态对象时，只要关心它的接口（或称”协议“）即可---也就是公开的方法和特性。在Python中，不用显示地制定对象必须包含哪些方法才能作为参数接收。

　　可以检查所需方法是否已经存在：

　　hasattr(tc,'talk')

　　上面代码中，对象tc有个叫做talk的特性，但是没有fnord特性。如果需要的话，甚至还能检查talk特性是否可调用：

　　callable(getattr(tc,'talk',None))

[7.3] 一些关于面向对象设计的思考

　　给出一些要点：

　　　　将属于一类的对象放在一起。如果一个函数操纵一个全局变量，那么两者最好都在类内部作为特性和方法出　　　　　现。
　　　　不要让对象过于亲密。方法应该只关心自己实例的特性。

　　　　要小心继承，尤其是多重继承。

　　　　简单就好，多数方法都应能在30秒内被读完，将代码行控制在一页或一屏内。

　　当考虑需要什么类以及类要有什么方法时，应该尝试下面的方法：

　　（1）写下问题的描述（程序要做什么？），把所有名词、动词和形容词加下划线。

　　（2）对于所有名词，用做可能的类。

　　（3）对于所有动词，用作可能的方法。

　　（4）对于所有形容词，用作可能的特性。

　　（5）把所有方法和特性分配到类。

　　这就是面向对象类型的草图。还可以考虑类和对象之间的关系以及它们的作用，可以用以下步骤精炼模型：

　　（1）写下一系列的使用实例，也就是程序应用时的场景，试着包括所有的功能。

　　（2）考虑每个使用实例，保证模型包括所有需要的东西。

【7.4】 小结

　　对象：对象包括特性和方法。特性只是作为对象的一部分的变量，方法则是存储在对象内的函数。方法和其他函数的区别在于方法总是将对象作为自己的第一个参数，这个参数一般称为self。

　　类：类代表对象的集合，每个对象都有一个类。类的主要任务是定义它的实例会用到的方法。

　　多态：多态是实现将不同类型和类的对象进行同样对待的特性。不需要知道对象属于哪个类就能调用方法。

　　封装：对象可以将它们的内部状态隐藏起来。

　　继承：一个类可以使一个或者多个类的子类。子类从超类继承所有方法。

　　接口和内省：需要知道对象到底有什么方法和特性，有些函数可以帮助完成这项工作。

　　面向对象设计：创建容易理解的设计是很重要的。