Python学习随笔六：抽象之面向对象

写在前面

本节将总结Python的核心概念——创建自己的对象（尤其是类型或者被称为类的对象）：

类和类型

继承

多态

类

基本概念

类可以或多或少的视为种类或者类型的同义词。如鸟类是一个通用的的类，百灵鸟是鸟类的一个子类，而鸟类则是百灵鸟的超类。特定的一只百灵鸟则是类中的对象。

创建自己的类

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)

p.s.

1、使用class关键字

2、关键词后面为类名，通常为大写开头的单词

3、最后为指定继承的超类

4、定义的函数都有不可或缺的参数self，表示对象自动将自己作为第一个参数传入函数中，没有self的话成员方法就没法访问他们要对其特性进行操作的对象本身了。

创建类的实例

>>> foo = Person()
>>> bar = Person()
>>> foo.setName('Ada Xia')
>>> bar.setName('Elan Zhang')
>>> foo.greet()
Hello, world! I'm Ada Xia.
>>> bar.greet()
Hello, world! I'm Elan Zhang.

foo.greet()可以看作Person.greet（foo）方便的简写

插入代码

Ctrl + K

继承

基本概念

函数解决了同一段代码运行多次的问题。然而，如果已经有了一个类，而又想建立一个知识添加几个方法的新类，就可以用到继承

指定超类

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

class Filter:#定义一个过滤的通类，实际不作任何操作
def init(self):
self.bloced = []
def filter(self, sequence):
return [x for x in sequence if x
4000
not in self.blocked]
#列表生成器，生成满足x not in self.blocked的list
>>> f = Filter()
>>> f.init()
>>> f.filter([1,2,3])
[1, 2, 3]
class SPAMFilter(Filter):#Filter的子类
def init(self):
self.blocked = ['SPAM']#可以将序列中的”SPAM”过滤出去
>>> s = SPAMFilter()
>>> s.init()
>>> s.filter(['SPAM','SPAM','SPAM','egg','bacon','SPAM']
['egg', 'bacon']

p.s.

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

2.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

上述行为称为多重继承。在多重继承中，先继承的类中的方法会重写后继承的类中的方法。

多态

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

多态和方法

>>> 'abc'.count('a')
1
>>> [1,2,'a'].count('a')
1

对于变量x来说，不需要知道它是字符串还是列表，就可以调用它的count方法，不用管它是什么类型

即对于x，它的count方法带有一个字符串作为参数，并且返回整数值。

多态的多种形式

很多内建运算符和函数都有多态的性质

>>> 1+2
3
>>> 'Fish'+'license'
'Fishlicense'

很多函数和运算符都是多态的——自己写的很多程序可能都是。唯一能够毁掉多态的就是使用函数显示地检查类型。多态真正重要的是如何让对象按照你所希望的方式工作，而不管它是否是正确的类型（或者类）。