第7章 面向对象

Posted 2020-10-03

面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：

std1 = { ‘name‘: ‘Michael‘, ‘score‘: 98 }

std2 = { ‘name‘: ‘Bob‘, ‘score‘: 81 }

而处理学生成绩可以通过函数实现，比如打印学生的成绩：

def print_score(std):

    print(‘%s: %s‘ % (std[‘name‘], std[‘score‘]))

如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。

class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.score = score

    def print_score(self):

        print(‘%s: %s‘ % (self.name, self.score))

给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：

bart = Student(‘Bart Simpson‘, 59)

lisa = Student(‘Lisa Simpson‘, 87)

bart.print_score()

lisa.print_score()

类与实例：

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

仍以Student类为例，在Python中，定义类是通过class关键字：

class Student(object):

    pass

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

>>> bart = Student()

>>> bart

<__main__.Student object at 0x10a67a590>

>>> Student

<class ‘__main__.Student‘>

可以看到，变量bart指向的就是一个Student的实例，后面的0x10a67a590是内存地址，每个object的地址都不一样，而Student本身则是一个类。

可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：

>>> bart.name = ‘Bart Simpson‘

>>> bart.name

‘Bart Simpson‘

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：

class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.score = score

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

>>> bart = Student(‘Bart Simpson‘, 59)

>>> bart.name

‘Bart Simpson‘

>>> bart.score

59

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数

类的属性：

# class OldboyStudent:

#     school = ‘oldboy‘ #类的数据属性

#     def learn(self): #类的函数属性

#         print(‘is learning‘)

#

#     def eat(self):

#         print(‘is eating‘)

    # print(‘======>‘)

#类体的代码在类定义阶段就会执行,理所应当会产生类的名称空间，用__dict__属性查看

# print(OldboyStudent.__dict__)

# print(OldboyStudent.__dict__[‘school‘])

# print(OldboyStudent.__dict__[‘learn‘])

#类的属性操作

# print(OldboyStudent.school)

# print(OldboyStudent.learn)

#

# def func():pass

# print(func)

# OldboyStudent.learn(123)

# OldboyStudent.x=1111111111111111111111

# OldboyStudent.school=‘Oldboy‘

# del  OldboyStudent.school

# print(OldboyStudent.__dict__)

# OldboyStudent.__dict__[‘x‘]=1111111111111111111111

#产生程序中的对象：类名加括号，调用类，产生一个该类的实际存在的对象，该调用过程称为实例化，产生的结果又可以成为实例

# class OldboyStudent:

#     school = ‘oldboy‘

#     #obj1,‘李大炮‘,18,‘女‘

#     def __init__(self,name,age,sex): #在实例化时,产生对象之后执行

#         # if not isinstance(name,str):

#         #     raise TypeError(‘名字必须是字符串类型‘)

#         self.name=name

#         self.age=age

#         self.sex=sex

#         # return None #__init__方法必须返回None

#         #obj1.name=‘李大炮‘

#         #obj1.age=18

#         #obj1.sex=‘女‘

#

#     def learn(self):

#         print(‘is learning‘)

#

#     def eat(self):

#         print(‘is eating‘)

# obj1=OldboyStudent(‘李大炮‘,18,‘女‘) #

# 分两步：

# 第一步：先产生一个空对象obj1

# 第二步：OldboyStudent.__init__(obj1,‘李大炮‘,18,‘女‘)

# print(obj1.__dict__)

#

# obj2=OldboyStudent(‘张全蛋‘,28,‘男‘)

# obj3=OldboyStudent(‘牛榴弹‘,18,‘女‘)

#

# print(obj2.__dict__)

# print(obj3.__dict__)

#

#

#

# print(obj1.name)#obj1.__dict__[‘name‘]

#

# obj1.name=‘大炮‘

# print(obj1.__dict__)

# obj1.__dict__[‘name‘]=‘炮‘

# print(obj1.name)

#

# obj1.__dict__.pop(‘name‘)

# # print(obj1.name)

# print(obj1.__dict__)

#继承的基本形式

当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

定义

# class ParentClass1(object): #定义父类

#     pass

#

# class ParentClass2: #定义父类

#     pass

#

# class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass

#     pass

#

# class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类

#     pass

#

#

#

#

# print(SubClass1.__bases__)

# print(SubClass2.__bases__)

# print(ParentClass1.__bases__)

比如，我们已经编写了一个名为Animal的class，有一个run()方法可以直接打印：

class Animal(object):

    def run(self):

        print(‘Animal is running...‘)

当我们需要编写Dog和Cat类时，就可以直接从Animal类继承：

class Dog(Animal):

    pass

class Cat(Animal):

    pass

对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类。Cat和Dog类似。

继承有什么好处？最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法：

dog = Dog()

dog.run()

cat = Cat()

cat.run()

运行结果如下：

Animal is running...

Animal is running..

子类方法重用父类的功能

# class OldboyPeople:

#     school = ‘oldboy‘

#     def __init__(self,name,age,sex):

#         self.name=name

#         self.age=age

#         self.sex=sex

#

#     def eat(self):

#         print(‘is eating‘)

#     def teach(self):

#         print(‘这是父类的teach‘)

#

# class OldboyTeacher(OldboyPeople):

#     def __init__(self,name,age,sex,salary,title):

#         # OldboyPeople.__init__(self,name,age,sex)

#         #在Python2中需要写全：super(OldboyTeacher,self)

#         super().__init__(name,age,sex)

#         self.salary=salary

#         self.title=title

#

#     def teach(self):

#         # OldboyPeople.teach(self)

#         super().teach()

#         print(‘%s is teaching‘  %self.name)

# print(OldboyTeacher.mro())

#

# egon_obj=OldboyTeacher(‘egon‘,18,‘male‘,3.1,‘沙河霸道金牌讲师‘)

# # print(egon_obj.title)

# # print(egon_obj.__dict__)

# egon_obj.teach()

总结：

1 继承的功能之一：解决类与类之间的代码重复问题

2 继承是类与类之间的关系，是一种，什么是什么的关系

3 在子类派生出的新的属性，已自己的为准

4 在子类派生出的新的方法内重用父类的功能的方式：指名道姓法OldboyPeople.__init__

  这种调用方式本身与继承是没有关系