对象的魔力

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

多态
① 多态和方法
绑定到对象特性上面的函数称为方法（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函数是多态特性的代表之一 ——可以对任何东西使用
封装
封装是对全局作用域中其他区域隐藏多余信息的原则。
封装并不等同于多态。多态可以让用户对于不知道是什么类（或者对象类型）的对象进行防腐调用，而封装是可以不用关心对象是如何构建的而直接进行使用。
继承
继承是可以让一个类从已写好的类方法中完全继承其特性和方法。

类和类型

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

创建子集的类
实例：

__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语句会在函数定义的地方创建子集的命名空间。

特性、函数和方法
上例中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

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

指定超类

# -*- 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类中拿过来的（继承），所以不用重写它的定义

多个超类
源代码：

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。
类：类代表对象的集合，每个对象（实例）都有一个类，类的主要任务是定义它的实例会用到的方法。
多态：多态是实现将不同类型和类的对象进行同样对待的特性——不需要知道对象属于哪个类就能调用的方法。
封装：对象可以将他们的内部状态隐藏（或封装）起来。
继承：一个类可以是一个或者多个类的子类。子类从超类继承所有的方法。可以使用多个超类。

秒客网

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

对象的魔力

类和类型

小结

相关文章

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

对象的魔力

类和类型

小结

相关文章

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