简介

• 编程范式
• 面向过程编程
• 面向对象编程
• 类和对象

编程范式

编程是指用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程。

一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式，

对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。

不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。

两种最重要的编程范式分别是面向过程编程和面向对象编程。

面向过程编程简介

• 核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式
• 优点：复杂的问题流程化，进而简单化
• 缺点：可扩展性差

import json
import re
def interactive():
    name=input('>>: ').strip()
    pwd=input('>>: ').strip()
    email=input('>> ').strip()
    return {
        'name':name,
        'pwd':pwd,
        'email':email
    }

def check(user_info):
    is_valid=True

    if len(user_info['name']) == 0:
        print('用户名不能为空')
        is_valid=False

    if len(user_info['pwd']) < 6:
        print('密码不能少于6位')
        is_valid=False

    if not re.search(r'@.*?\.com$',user_info['email']):
        print('邮箱格式不合法')
        is_valid=False

    return {
        'is_valid':is_valid,
        'user_info':user_info
    }

def register(check_info):
    if check_info['is_valid']:
        with open('db.json','w',encoding='utf-8') as f:
            json.dump(check_info['user_info'],f)

def main():
    user_info=interactive()

    check_info=check(user_info)

    register(check_info)

if __name__ == '__main__':
    main()

上述的需求中如果要再添加一项联系方式的功能，那么牵一发而动全身，其他代码可能都需要改动，此时缺点就很明显了，扩展性很差。而优点是编程难度较低。

面向对象编程简介

• 核心就是对象二字
• 对象就是特征与技能的结合体
• 优点：可扩展性强
• 缺点：编程复杂度高
• 应用场景：用户需求经常变化，可扩展性高的场景

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

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

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

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

我们以一个例子来说明面向过程和面向对象在程序流程上的不同之处。

假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个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）的概念是很自然的。Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。

所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。

面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。

为什么要用面向对象？

• 使程序更加容易扩展和易更改，使开发效率变的更高
• 基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

名词解释

类：一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型、模板。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

属性：人类包含很多特征，把这些特征用程序来描述的话，叫做属性，比如年龄、身高、性别、姓名等都叫做属性，一个类中，可以有多个属性

方法：人类不止有身高、年龄、性别这些属性，还能做好多事情，比如说话、走路、吃饭等，相比较于属性是名词，说话、走路是动词，这些动词用程序来描述就叫做方法。

实例(对象)：一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

实例化：把一个类转变为一个对象的过程就叫实例化

面向对象3大特性

注意，此处只需知道这几个名词，后面会专门再对着代码学习这几大特性

Encapsulation 封装

在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。

对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。

多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

类、实例、属性、方法

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

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

class Student(object):
    pass

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

查看类的名称空间

class Student(object):
    age = 18

    def __init__(self, name, score):
        self.name = name
        self.score = score
        
    def info_(self):
        print('age:18')
        
print(Student.__dict__)
print(Student.__dict__['info_'])
print(Student.__dict__['age'])

运行结果：

{'__module__': '__main__', 'age': 18, '__init__': <function Student.__init__ at 0x104108598>, 'info_': <function Student.info_ at 0x1041086a8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
<function Student.info_ at 0x1041086a8>
18

类的属性

• 数据属性:相似的特征
• 函数属性:相似的功能

class Student(object):
    age = 18    # 数据属性
        
    def info_(self):    # 函数属性
        print('age:18')

对属性的增、删、改、查

class Student(object):
    age = 18  # 数据属性
    
    def info_(self):  # 函数属性
        print('age:18')

# 查
print(Student.__dict__['age'])
print(Student.age)
# 增
Student.school = 'Tsinghua'
# 删
del Student.age
# 改
Student.school = 'beijing'

print(Student.__dict__)

对象的操作

#__init__方法用来为对象定制对象自己独有的特征
class LuffyStudent:
    school='luffycity'

    def __init__(self,name,sex,age):
        self.Name=name
        self.Sex=sex
        self.Age=age

    def learn(self):
        print('is learning')

    def eat(self):
        print('is sleeping')

#后产生对象
stu1=LuffyStudent('王二丫','女',18) #LuffyStudent.__init__(stu1,'王二丫','女',18)

#加上__init__方法后，实例化的步骤
# 1、先产生一个空对象stu1
# 2、LuffyStudent.__init__(stu1,'王二丫','女',18)

#查
print(stu1.__dict__)
print(stu1.Name)

#改
stu1.Name='李二丫'
print(stu1.__dict__)
print(stu1.Name)

#删除
del stu1.Name
print(stu1.__dict__)

#增
stu1.class_name='python开发'
print(stu1.__dict__)

类的使用

• 与函数不同的是，类在定义的时候就运行了，而函数只有调用了才会执行
• 类内部实际上就是变量的定义和函数的定义

class Student(object):
    pass

定义好了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__”前后分别有两个下划线！！！
注意到 __init__方法的第一个参数永远是self，表示创建的实例本身，因此，在 __init__ 方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身,即** self 就是实例本身！你实例化时python解释器会自动把这个实例本身通过self参数传进去。**

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

>>> bart = Student('Bart Simpson', 59)
>>> bart.name
'Bart Simpson'
>>> bart.score
59

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

构造方法

__init__(…)被称为 构造方法或初始化方法，在例实例化过程中自动执行，目的是初始化实例的一些属性。每个实例通过__init__初始化的属性都是独有的

刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容

类的方法

构造方法

刚才上面已经说了，主要作用是实例化时给实例一些初始化参数，或执行一些其它的初始化工作，总之，因为这个__init__只要一实例化，就会自动执行，so不管你在这个方法里写什么，它都会统统在实例化时执行一遍

普通方法

定义类的一些正常功能，比如人这个类， 可以说话、走路、吃饭等，每个方法其实想当于一个功能或动作

析构方法(解构方法)
实例在内存中被删除时，会自动执行这个方法，如你在内存里生成了一个人的实例，现在他被打死了，那这个人除了自己的实例要被删除外，可能它在实例外产生的一些痕迹也要清除掉，清除的动作就可以写在这个方法里。

class Person(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def talk(self):
        print("Hello, my name is %s, I'm %s years old!" % (self.name, self.age))

    def __del__(self):
        print("running del method, this person must be died.")


p = Person("Alex", 22)
p.talk()

del p

print('--end program--')

实例在内存中被删除时，会自动执行这个方法，如你在内存里生成了一个人的实例，现在他被打死了，那这个人除了自己的实例要被删除外，可能它在实例外产生的一些痕迹也要清除掉，清除的动作就可以写在这个方法里

小结

• 类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
• 方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；
• 通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。
• 和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同

属性的查找方法

属性查找顺序：自己内部找 –> 类里面找。而不会去全局找，

继承与派生

对象自己 –> 类 –> 父类 –> 父类的父类 … （全局变量不行）

派生的概念：xx
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性（不会影响到父类），需要注意的是，一旦重新定义了自己的属性且与父类重名，那么调用新增的属性时，就以自己为准了

数据封装

面向对象编程的一个重要特点就是数据封装。在上面的Student类中，每个实例就拥有各自的name和score这些数据。我们可以通过函数来访问这些数据，比如打印一个学生的成绩：

>>> def print_score(std):
...     print('%s: %s' % (std.name, std.score))
...
>>> print_score(bart)
Bart Simpson: 59

但是，既然Student实例本身就拥有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

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))

要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入：

>>> bart.print_score()
Bart Simpson: 59

这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score，而如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。

封装的另一个好处是可以给Student类增加新的方法，比如get_grade：

class Student(object):
    ...

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

同样的，get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节：

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

绑定方法与非绑定方法

类中定义的函数分成两大类

简介

绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：

绑定到类的方法：用classmethod装饰器装饰的方法。

 为类量身定制

 类.boud_method(),自动将类当作第一个参数传入

（其实对象也可调用，但仍将类当作第一个参数传入）

绑定到对象的方法：没有被任何装饰器装饰的方法。

为对象量身定制

对象.boud_method(),自动将对象当作第一个参数传入

（属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）

非绑定方法：用staticmethod装饰器装饰的方法

不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已
注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说

绑定方法

绑定给对象的方法（略）

绑定给类的方法（classmethod）

classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

#settings.py
HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向对象编程\test1\db'

#test.py
import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()

conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

非绑定方法

在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数

statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果

import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一个普通工具
        m=hashlib.md5(str(time.time()).encode('utf-8'))
        return m.hexdigest()


print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数

classmethod与staticmethod的对比

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @staticmethod
    def from_conf():
        return MySQL(settings.HOST,settings.PORT)

    # @classmethod #哪个类来调用,就将哪个类当做第一个参数传入
    # def from_conf(cls):
    #     return cls(settings.HOST,settings.PORT)

    def __str__(self):
        return '就不告诉你'

class Mariadb(MySQL):
    def __str__(self):
        return '<%s:%s>' %(self.host,self.port)


m=Mariadb.from_conf()
print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：

练习

练习1：定义MySQL类

要求：

• 1.对象有id、host、port三个属性
• 2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一
• 3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化
• 4.为对象定制方法，save和get_obj_by_id，save能自动将对象序列化到文件中，文件路径为配置文件中DB_PATH,文件名为id号，保存之前验证对象是否已经存在，若存在则抛出异常，;get_obj_by_id方法用来从文件中反序列化出对象

内置方法

元类

面向对象的软件开发

领域模型

异常处理

本章总结

本章作业

题目：选课系统开发

• 求有四种角色:学校、学员、课程、讲师**

详细要求:

• 创建北京、上海 2 所学校
• 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
• 课程包含，周期，价格，通过学校创建课程
• 通过学校创建班级， 班级关联课程、讲师
• 创建学员时，选择学校，关联班级
• 创建讲师角色时要关联学校
• 提供两个角色接口

为学员、讲师、管理员分别提供用户界面，并提供对应功能：
1 学员视图， 可以注册， 交学费， 选择班级
2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
3 管理视图，创建讲师， 创建班级，创建课程

注1：上面的操作产生的数据都通过pickle序列化保存到文件里
注2：此作业必须画流程图，图中标注好不同类或对象之间的调用关系

123

【参考】廖雪峰的官方网站