<<Python基础教程>>学习笔记 | 第07章 | 更加抽象

------

Python:面向对象的编程语言,多态，封装，继承三个主要特性

多态:来自希腊语，意味着有多种形式。

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

任何不知道对象到底是什么类型，但又要对对象做的什么的时候，就要用到多态

>>> 1+23>>> 'hot'+'dog''hotdog'

#和下面的形式是一样的

>>> def add(x,y): return x+y...>>> add(1,2)3>>> add('hot','dog')'hotdog'

#如果要打印信息的长度，只需要对象具有长度即可.

>>> def print_message(x):...     print 'The length of',repr(x),'is',len(x)...

用到的repr()就是多态特性的代表之一:可以对任何东西使用.

>>> print_message('Fnord')The length of 'Fnord' is 5>>> print_message([1,2,3,4])The length of [1, 2, 3, 4] is 4

事实上，唯一能毁掉多态的就是函数显示的检查类型，比如:type,isinstance,issubclass,如果可能的话，尽量避免这些毁掉多态函数的方式。真正重要的是如何让对象按照我们的方式工作。

------

封装:是对全局作用域中其他区域隐藏多余信息的原则。

多态:使用对象，而不用知道其内部细节

两者概念类似，但是封装不等同于多态

多态可以让用户对于不知道是什么类的对象进行方法调用,而封装是可以不用关心对象是如何创建而直接使用。

------

继承:是一种“懒惰”的行为，程序员不想把代码写几次。

类:一种对象. 鸟类(supperclass)-->百灵鸟(subclass)

Note: Python的类名，不用复数，首字母大写，如果多个单词，首字母同样大写Bird

创建自定义类:

class Person:    def setName(self,name):        self.name = name    def getName(self,name):        return self.name    def greet(self):        print "Hello,World! I am %s" % self.name>>> foo = Person()>>> bar = Person()>>> foo.setName('Luke Skywalker')>>> bar.setName('Anakin Skywalker')>>> foo.greet()Hello,World! I am Luke Skywalker>>> bar.greet()Hello,World! I am Anakin Skywalker

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 = 'Squaawk!'        def sing(self):             print self.song>>> bird = Bird()>>> bird.sing()Squaawk!>>> birdsong = bird.sing>>> birdsong()Squaawk!

------

私有化:

在方法前面加__，表示私有方法，不可直接访问:

>>> class Secretive:        def __inaccessible(self):             print "Bet you can't see me..."        def accessible(self):             print "The scret message is:"             self.__inaccessible()>>> s = Secretive()>>> s.__inaccessible()  #不能直接访问Traceback (most recent call last):  File "<pyshell#29>", line 1, in <module>    s.__inaccessible()AttributeError: Secretive instance has no attribute '__inaccessible'>>> s.accessible()      #但能通过其他方法来访问The scret message is:Bet you can't see me...

#不能被外界直接使用，但可以再类内部使用,从而达到间接调用该方法.

#还有一种访问方法，要体会如何使用,主要是用于测试,看下面

>>> Secretive._Secretive__inaccessible<unbound method Secretive.__inaccessible>

#提示未绑定的方法，只要在前面用instance来绑定就可以了。

>>> dir(Secretive)['_Secretive__inaccessible', '__doc__', '__module__', 'accessible']#dir()函数也可以看到instance._ClassName__PrivateMethod()>>> s._Secretive__inaccessible()Bet you can't see me...

Note: 如果不需要使用这种方法，但是又想让其他对象不要访问内部数据，那么可以使用单下划线。

前面有单下划线的不会被from module import * 语句导入

------

类的命名空间:

#下面两个函数应该是一样的

>>> def foo(x): return x*x...>>> foo = lambda x:x*x

#定义类时也一样，所有class语句中的代码都在类命令空间中执行，由类内所有成员访问.类的定义其实就是执行class语句中的代码块.这点非常有用，比如说类的语句并不仅限于def，比如下面的也是一样:

>>> class C:...     print "class C is being defined..."...class C is being defined...

再比如像下面的:

>>> class MemberCounter:...     members = 0...     def init(self):...         MemberCounter.members +=1...>>> m1 = MemberCounter()>>> m1.init()>>> m1.members1>>> m2 = MemberCounter()>>> m2.init()>>> MemberCounter.members2

也可以像下面这样让其自动初始化

>>> class MC:...     m = 0...     def __init__(self):...         self.m +=1...>>> m1 = MC()>>> m1.m1

------

Note: Java 支持4中级别，尽管Python给出了单双下划线，但Python并没有真正的私有化支持

如果在实例中重新绑定members呢? 

>>> m1.members = 'Two'>>> m1.members'Two'>>> m2.members2

#这跟函数的局部，全局变量非常类似

------

指定超类:

class Filter:    def __init__(self):        self.blocked = []      #self.不能少    def filter(self,sequence): #注意这种写法，非常有用        return [x for x in sequence if x not in self.blocked]        class SPAMFilter(Filter):      #继承自父类或超类:Filter    def __init__(self):        #重写超类中的__init__方法         self.blocked = ['SPAM']f1 = Filter()                  #实际上这个什么也没有过滤，[]print f1.filter([1,2,3])s = SPAMFilter()               #过滤掉了列表中所有含'SPAM'的元素print s.filter(['SPAM','eggs','SPAM','bacon','SPAM'])

输出结果:

>>> [1, 2, 3]['eggs', 'bacon']

NOTE: 注意子类SPAMFilter要点:

1. 重写Filter的init初始化方法

2. filter的方法继承自父类(Filter),不用重写.

第二点解示了继承的好处，我们可以写一大堆过滤的类，全部继承自Filter.

每个类都可以使用超类中，已经实现的方法:filter()

------

调查继承:

• 如何判断某类是否是另外一个类的子类呢，用Python自置的类issubclass(子类，父类)

>>> issubclass(SPAMFilter,Filter)True

• 如果想要知道已经类的基类，可以用它的特殊属性__bases__

>>> Filter.__bases__()>>> SPAMFilter.__bases__(<class __main__.Filter at 0x00000000029E2DC8>,)

• 如果想判断一个对象是否是一个类的实例，可以用isinstance

>>> s = SPAMFilter()>>> isinstance(s,SPAMFilter)True>>> isinstance(s,Filter) #同样是超类的一个对象True>>> isinstance(s,str)False

Note: 使用isinstance并不是个好习惯，使用多态好些.

• 如果想知道一个对象属于那个类，可以用__class__特性

>>> s.__class__<class __main__.SPAMFilter at 0x00000000029E2F48>

------

多个超类:

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

#子类不做任何事，从超类中继承所有的方法，从Calculator中继承calculator方法.

从Talker中继承talk的方法.这种行为成为多种继承

>>> TC = TalkingCalculator()>>> TC.calculator('1+2*3')>>> TC.talk()Hi,my value is: 7

Note: 除非对超类特别熟悉，否则尽量避免使用，以免出现不可预知的错误.

------

接口和内省

接口的概念与多态有关。在处理多态对象时，只要关心它的接口即可-也就是公开的方法和特性.

Python，不用显式指定对象必须包含哪些方法才能做为参数接收。

一般来说，只需要让对象实现当前方法即可。 可用hasattr()来检查方法是否已经存在

>>> class Calculator:def calculator(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()

>>> hasattr(tc,'talk')
True
>>> hasattr(tc,'fnord')
False
如果有需要的话，甚至还可以检查talk是否可调用:

>>> callable(getattr(tc,'talk'))
True
>>> callable(getattr(tc,'fnord',None))
False

与getattr相对应的是setattr

>>> setattr(tc,'name','Mr. Smith')
>>> tc.name
'Mr. Smith'

Note: callable函数在Python3.0不再使用，取而代之的是hasattr(x,'__call__')

------

本章函数

callable(object)                          确定对象是否可调用(比如函数或方法)

getattr(object,name[,default])            确定特性的值，可选择提供默认值

hasattr(object,name)                      确定对象是否有给定的特性

isinstance(object,class)                  确定对象是否是类的实例

issubclass(A,B)                           确定A是否是B的子类

random.choice(sequence)                   从非空序列中随机选择元素

setattr(object,name,value)                设定对象的给定特定为value

type(object)                              返回对象的类型

------