本文相关描述主要是个人的认知和见解，如有不当之处，还望各位大佬指正。

个人其他博客地址：

简书：https://www.jianshu.com/u/d6960089b087

掘金：https://juejin.cn/user/2963939079225608

小钟同学 | 文 【原创】| QQ：308711822

本文概述：

• 什么是编程范式？
• 常见的几种编程范式有哪些？
• 面向对象的编程一些术语概念

1、 什么是编程范式？

所谓的编程范式其实是可以理解我们使用某种言语编写代码的时候风格或叫编程方式。

• 如：java 仅支持面向对象编程范式(OOP)，如果你想还可以用面向切面编程(AOP),AOP是OOP的延续，针对业务处理过程中的切面进行提取
• 如：python 支持函数式编程（FP）也支持面向对象编程范式(OOP)，如果你想还可以用面向过程编程POP
• ·····

2、 常见的几种编程范式（编程思想）有哪些？

面向过程和面向函数式编程是不同的概念需要区分：

• "面向过程"核心重点在过程,着重的是对解决问题的步骤没一个过程和顺序。类似一种顺序化机械  化的编程（遥想当初刚学的时候就是这鸟样的，一个文件写了几千行），把要解决的问题进行流程化。

• 函数式，也不是封装函数那么简单，其实上面的图解释的有点不对！函数式编程偏向于注重的是执行结果而非执行的过程。它的思想是：将电脑运算视为函数运算，并且避免使用程序状态以及易变对象。

这里不过关的关注者两种方式的编程。

3、面向对象编程 - 专业术语话版本

上面的图示中可以看到：

面向对象程序的设计思想，强调的核心是抽象出一个对象，而不是程序执行流程，它基于类来构思此类此对象包括的数据，以及操作数据的行为方法等进行抽象化。

面向对象过程中一些概念介绍：

PS：以下的部分描述来自菜鸟教程

• 类(Class):

  用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

• 方法（实例方法，静态方法，类方法）:

  类中定义的函数。

• 类变量(静态变量):

  类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。

  类变量既可以被实例变量调用，也可以被类变量调用

  类变量通常不作为实例变量使用。

  在class内的，但不在class的方法内的

• 局部变量:

  定义在方法中的变量，只作用于当前实例的类。

  在函数内、在class的方法内（未加self修饰的）

• 实例变量:

  1.在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

  2.在class的方法内的

• 数据成员:

  类变量或者实例变量用于处理类及其实例对象的相关的数据。

• 方法重写:

  如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

• 继承:

  即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

• 实例化:

  创建一个类的实例，类的具体对象。

• 对象:

  通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

PS:补充其他

• 全局变量:

  定义在模块内、在所有函数外面、在class外面，全局范围内都可以访问

• 静态方法:

  静态方法由类来调用，没有默认参数。在方法定义加上@staticmethod的装饰器，且去除self，就成为静态方法。

  静态方法属于类，和实例无关。

  类似类变量，建议只使用类名.静态方法的调用方式，虽然也可以使用实例名.静态方法方式调用）

• 类方法:

  类方法和静态方法一样由类调用，但是是采用@classmethod装饰，且需至少传入一个cls（代指类本身，类似self）参数。执类方法行时自动将调用该方法的类赋值给cls。

  类似类变量，建议只使用类名.静态方法的调用方式，虽然也可以使用实例名.静态方法方式调用）

• 实例方法:

  实例对象可以调用的函数，函数。通过self来传递实例的属性和方法（不过也可以传类的属性和方法）

  需要类的实例的对象来调用

4、面向对象编程 -白话版本（人话）的

• 文绉绉气昂昂，一支穿云箭来百万码农过大江

• 类(Class):

  物以类聚人以群分，动物有分类类：（其他动物）低级动物和（人）高级动物。人是动物其中一种，所以动物是“类”的统称。

• 方法:

  动物这个群体包含一些固有的能力方法，如人：会吃饭，会睡觉，会喝水·····这些技能都是一种能力和的封装，统称方法。

• 类变量:

  动物共有的一些共同的特有属性信息（所有的此类群体都共享这个属性），如：统一定义所有动物界所有【最长】能有无限的生命值（加油！）

  这个所有的对象的共享的

• 局部变量:

  如：人，我在吃饭的（方法）的时候，突然想给的吃饭技能上不错一些其他的属性，比如我的吃饭的速度是多少，但是这个属性仅限于我的在吃饭的这个技能上（仅限于这个方法内）。

• 实例变量:

  如：统一创建出来的所有人的一样的属性值，如这一类人统一吃饭的最大的饭量的是：五碗米饭，当这个人出生后，这个人就具备了最大饭量是吃 五碗米饭的分量。

• 数据成员:

  类变量、实例变量、方法、类方法、静态方法和属性等的统称。

• 方法重写:

  比如：你爸爸的吃饭技能原来：就是只能吃饭（你爸不喜欢吃鸡腿），把你的生出来后，子承父业的同时又青出于蓝而胜于蓝，你的不仅能吃饭，（你喜欢吃鸡腿）还能再吃饭的同时吃鸡腿。继承了你把吃饭的技能还扩展的你改写了你的爸吃饭的技能上新增新的技能。

• 继承:

  你老爸生了你！你是基于你老爸的基础上派生出来的！

• 实例化:

  创建一个某类的实例，类的具体化。

• 对象:

  动物是一群的，动物具体的到：猴子，够这些就是动物下的具体的某个实体对象。

5、面向对象编程 -代码版本解说

OOP实践人类进化起源史：

1.- 类(Class):定义人类的始祖（猿）：

class Ape():
    pass

2.- 数据成员:定义人类的始祖（猿），拥有什么属性和技能：

• 定义类变量
• 定义局部变量
• 定义方法
• 定义局部变量

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义局部变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

3.- 实例化:人类的始祖（猿）：

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义局部变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

# 创建出第一个猿猴对象
ape_one = Ape("超级赛亚人1号")

运行输出结果：

定义局部变量name属性 超级赛亚人1号

4.- 实例化:人类的始祖（猿）更多对象：

# 创建出第一个猿猴对象
ape_one = Ape("超级赛亚人1号")
# 创建更多的对象
ape_2 = Ape("超级赛亚人2号")
ape_3 = Ape("超级赛亚人3号")

5.- 方法调用:人类的始祖（猿）对象-执行吃饭技能ape_one.eat()：

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义局部变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

# 创建出第一个猿猴对象
ape_one = Ape("超级赛亚人1号")
ape_one.eat()

输出：

定义局部变量name属性 超级赛亚人1号
超级赛亚人1号 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭

6.- 类变量:人类的始祖（猿）共享生命周期时长live 增加：

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义局部变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

Ape.live = Ape.live+30300303
print("类变量属性")
# 创建出第一个猿猴对象
ape_one = Ape("超级赛亚人1号")
ape_one.eat()
print("吃饭完后，我看一下自己的生命周期",ape_one.live)
print("吃饭完后，我看一下的种族所有猿类生命周期",Ape.live)

输出结果：

类变量属性
定义局部变量name属性 超级赛亚人1号
超级赛亚人1号 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭
吃饭完后，我看一下自己的生命周期 100030300303
吃饭完后，我看一下的种族所有猿类生命周期 100030300303

意外吗，惊喜吗？！

Ape.live = Ape.live+30300303 的操作会对所有的对象都有作用 此时创建出其他的对象看看：

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义局部变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

Ape.live = Ape.live+30300303
print("类变量属性")
# 创建出第一个猿猴对象
ape_one = Ape("超级赛亚人1号")
ape_one.eat()
print("吃饭完后，我看一下自己的生命周期",ape_one.live)
print("吃饭完后，我看一下的种族所有猿类生命周期",Ape.live)
ape_2 = Ape("超级赛亚人2号")
ape_2.eat()
print("ape_2吃饭完后，我看一下自己的生命周期",ape_2.live)
print("ape_2吃饭完后，我看一下的种族所有猿类生命周期",Ape.live)

輸出：

类变量属性
定义局部变量name属性 超级赛亚人1号
超级赛亚人1号 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭
吃饭完后，我看一下自己的生命周期 100030300303
吃饭完后，我看一下的种族所有猿类生命周期 100030300303
定义局部变量name属性 超级赛亚人2号
超级赛亚人2号 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭
ape_2吃饭完后，我看一下自己的生命周期 100030300303
ape_2吃饭完后，我看一下的种族所有猿类生命周期 100030300303

7.- 继承:人类的始祖（猿）开始生娃了：

7.1 生子

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义局部变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

# Pithecanthrope 继承了Ape
class Pithecanthrope(Ape):
        pass

7.2 继承了父亲的所有属性和技能，还有了属于自己的新的属性

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义变量name属性",self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name,"拥有吃饭技能","开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速",eat_speed)

# Pithecanthrope 继承了Ape
class Pithecanthrope(Ape):

    def __init__(self,name,sex,age):
        # 继承老爹的名字的属性
        super().__init__(name)
        # 扩展了新的属性
        self.sex =sex
        self.age = age
        print("扩展了新的定义局部变量name属性", self.name)


# 创建新的Pithecanthrope对象、

aithecanthrope_1 = Pithecanthrope(name="超级赛亚人进阶2时代",sex="男",age=10000000)
aithecanthrope_1.eat()

输出结果为：

定义变量name属性 超级赛亚人进阶2时代
扩展了新的定义局部变量name属性 超级赛亚人进阶2时代
超级赛亚人进阶2时代 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭

7.3方法重写1继承了父亲的吃饭技能，但是要有自己-吃的技能上新的吃饭的姿势（不想要老爹的那种吃饭的姿势）

# Pithecanthrope 继承了Ape
class Pithecanthrope(Ape):

    def __init__(self,name,sex,age):
        # 继承老爹的名字的属性
        super().__init__(name)
        # 扩展了新的属性
        self.sex =sex
        self.age = age
        print("扩展了新的定义局部变量name属性", self.name)

    def eat(self):
        print(self.name, "拥有属于自己的新的吃饭技能新姿势", "开始施展吃饭技术的表演！-新姿势")


# 创建新的Pithecanthrope对象、

aithecanthrope_1 = Pithecanthrope(name="超级赛亚人进阶2时代",sex="男",age=10000000)
aithecanthrope_1.eat()

输出：

定义变量name属性 超级赛亚人进阶2时代
扩展了新的定义局部变量name属性 超级赛亚人进阶2时代
超级赛亚人进阶2时代 拥有属于自己的新的吃饭技能新姿势 开始施展吃饭技术的表演！-新姿势

7.4方法重写2继承了父亲的吃饭技能，同时在老弟的基础上新增自己-吃的技能上新的吃饭的姿势（要老爹的那种吃饭的姿势+也要有自己的姿势）

super().eat()

# Pithecanthrope 继承了Ape
class Pithecanthrope(Ape):

    def __init__(self,name,sex,age):
        # 继承老爹的名字的属性
        super().__init__(name)
        # 扩展了新的属性
        self.sex =sex
        self.age = age
        print("扩展了新的定义局部变量name属性", self.name)

    def eat(self):
        super().eat()
        print(self.name, "拥有属于自己的新的吃饭技能新姿势", "开始施展吃饭技术的表演！-新姿势")


# 创建新的Pithecanthrope对象、

aithecanthrope_1 = Pithecanthrope(name="超级赛亚人进阶2时代",sex="男",age=10000000)
aithecanthrope_1.eat()

5、面向对象编程 -多态性

使用了面向对象变成相关封装和继承的特性后，我们相关的业务逻辑的实现相对来说就简单明了。那后续出现的多态，主要是基于什么原因而出现的呐？

首先需要区分多态和多态性是不同的概念：

多态：是指我们的对象的多个形态，多种形态。类似继承派生出来的子类。

• 多态是同一个行为具有多个不同表现形式或形态的能力。

多态性：在编程里面多态性是指具有不同功能的函数可以使用相同的函数名.意思就是我的同一个函数的名称调用，可以实现不同的功能。

• 多态性是同一个接口（函数，在python没有接口的说法），使用不同的实例而执行不同操作。

在面向对象方法里：我们创建了不同的对象，对象各自有自己的方法和属性。每个方法都是对象本身独有的行为。而如何通过相同的函数名的调用，实现不同的行为呐？

在之前的对象的内存说明里面，有说过关于变量的引用。那我们的时不时可以再定义一个类来处理传递应用的方式：

多态性的一种实现（通过引用传递的方法，定义同名的函数调用）：

class Ape():
    pass
    # 定义类变量-共享生命周期时长（所有的猿猴类都共享这个属性值）
    live = 100000000000

    def __init__(self, name):
        # 定义局部变量name属性
        self.name = name  # 此猿猴的名字
        print("定义变量name属性", self.name)

    # 定义技能（方法）
    def eat(self):
        print(self.name, "拥有吃饭技能", "开始施展吃饭技术的表演！")
        # 定义局部的变量
        eat_speed = "每一分钟可以吃一碗米饭"
        print("新增局部的变量，给吃饭的速度加速", eat_speed)


# Pithecanthrope 继承了Ape
class Pithecanthrope(Ape):

    def __init__(self, name, sex, age):
        # 继承老爹的名字的属性
        super().__init__(name)
        # 扩展了新的属性
        self.sex = sex
        self.age = age
        print("扩展了新的定义局部变量name属性", self.name)

    def eat(self):
        super().eat()
        print(self.name, "拥有属于自己的新的吃饭技能新姿势", "开始施展吃饭技术的表演！-新姿势")





p01 = Pithecanthrope(name="赛亚人1号", sex="男", age=121212)
p02 = Pithecanthrope(name="赛亚人2号", sex="男", age=121212)
print("========================")
def eat_act(animal):
    animal.eat()

eat_act(p01)
print("========================")
eat_act(p02)

输出：

定义变量name属性 赛亚人1号
扩展了新的定义局部变量name属性 赛亚人1号
定义变量name属性 赛亚人2号
扩展了新的定义局部变量name属性 赛亚人2号
========================
赛亚人1号 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭
赛亚人1号 拥有属于自己的新的吃饭技能新姿势 开始施展吃饭技术的表演！-新姿势
========================
赛亚人2号 拥有吃饭技能 开始施展吃饭技术的表演！
新增局部的变量，给吃饭的速度加速 每一分钟可以吃一碗米饭
赛亚人2号 拥有属于自己的新的吃饭技能新姿势 开始施展吃饭技术的表演！-新姿势

使用类的方式封装一层eat_act

# Pithecanthrope 继承了Ape
class Pithecanthrope(Ape):

    def __init__(self, name, sex, age):
        # 继承老爹的名字的属性
        super().__init__(name)
        # 扩展了新的属性
        self.sex = sex
        self.age = age
        print("扩展了新的定义局部变量name属性", self.name)

    def eat(self):
        super().eat()
        print(self.name, "拥有属于自己的新的吃饭技能新姿势", "开始施展吃饭技术的表演！-新姿势")


class Manage():

    def __init__(self,ape):
        self.ape =ape

    def eat_act(self):
        self.ape.eat()


p01 = Pithecanthrope(name="赛亚人1号", sex="男", age=121212)
p02 = Pithecanthrope(name="赛亚人2号", sex="男", age=121212)
print("========================")
Manage(p01).eat_act()
print("========================")
Manage(p02).eat_act()

多态性其实和我们的java面向对象编程中的多态是一样，只是实现的方式不一样。

以上是个人对Python面向对象变成一些简要阐述总结。如有纰漏，还希望大佬们多多提点！

End

纯属个人实践中相关经验阐述总结，如有纰漏，还希望大佬们多多提点！小钟同学 | 文  【原创】| QQ：308711822