进阶学Python：Python面向对象基础！ 八月更文

发表于

这是我参与8月更文挑战的第22天，活动详情查看：8月更文挑战

📖前言

三毛曾经感慨：

“心之何如，有似万丈迷津，横亘千里，其中并无舟子可以渡人，除了自渡，他人爱莫能助。” ——生命的洪流中，终其一生，我们都在学会怎么做自己的摆渡人。

关于安装和汉化可以观看博主的这篇文章《VsCode下载安装及汉化 》以及Python系列：windows10配置Python3.0开发环境！，安装完毕重启VsCode！

🚀Come on！什么是编程范式？

在了解面向对象编程之前，我们需要了解三大编程范式以及其之间的区别和利弊即：面向过程编程、函数式编程、面向对象编程。

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

如果将编程的过程比喻成练习武功，那么编程范式就是武林中的各种流派，而在编程的武林中最常见的三大流派即为：面向过程编程（武当派）、面向对象编程（少林派）和函数式编程（峨眉派）。

编程范式没有好坏之分：“武功的流派是没有高低之分，只要习武之人采用高低之分。”在编程的世界中也是如此，各种编程方式应用在不同的场景都有其方便和优劣之处，谁更好谁更坏不能一概而论。

一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方法，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式，不同的编程范式本质上代表对各种各类的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有一些语言可以同时支持多种编程范式。两种最重要的编程范式分别是面向过程编程和面向对象编程。

✨面向过程编程：

其核心在过程，过程便是解决问题的步骤，即为了解决问题先干嘛后干嘛，面向过程的设计就像一条固定的设计好的流水线，让问题根据这些步骤流程一步步来得到解决。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
python复制代码#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   loginWeiXin.py
@Time    :   2019/10/22 09:23:52
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib

#假设我们让用户登入微信：
username = "Sunny Chen"
password = "12345"
count = 0
while count < 3:
    user = input("please enter your username:")
    passwd = input("please enter your password:")
    if username == user and password == passwd:
        print("welcome to wechat...")
        break
    else:
        print("sorry,incorrent username or password..")
        count += 1
        if count == 3:
            print("sorry,you have tried too many times..")

# 在这个例子里：我们让用户登入微信，然而在整个过程中，我们设计让用户输入用户名和密码，如果用户名和密码正常，就登入成功；而密码错误，则显示用户名或者密码错误；当然我们也不可能让用户一直试下去，只有三次机会，如没成功则显示登入次数太多。
#这便是典型的面向过程设计，根据问题一步步的设计解决步骤。

# 输出为
# please enter your username:Sunny Chen
# please enter your password:12345
# welcome to wechat...

优缺点也很明显：

  1. 优：复杂的问题流程化，进而简单化。即：将一个大的复杂的问题，分成一个个小的步骤去实现，毕竟实现小的问题要简单许多。
  2. 劣：一条流水线或流程就是用来解决一个问题，但是很难去解决一个相当大的问题，这样会显得十分繁琐。即生产一个复杂的机器很难用一条流水线去解决，即便是能，也得是大改，改一个组件，牵一发而动全身。

💕函数式编程：

其核心在函数，将计算机运算看做是数学中函数的计算，并且避免了状态以及变量的概念。

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
python复制代码#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   functionDemo.py
@Time    :   2019/10/22 09:27:41
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib


#最纯粹的函数式编程
def cal(x, y):
    return x + y


#而在python下的函数，通常是为了实现某些特定功能而组织到一起的代码块。

💋面向对象编程：

其核心在对象：即万物皆对象，而每个对象均有特征和功能，通过设计将把这些整合在一块便是面向对象设计，面向对象更加注重对现实世界的模拟，存在的为对象，不存在的可以创造出来作为对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
python复制代码#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   dxDemo.py
@Time    :   2019/10/22 09:28:42
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib


#创建类，该类的特征和功能是相似的
class teacher(object):
    def __init__(self, name, age, course):
        self.name = name
        self.age = age
        self.course = course

    def intro(self):
        print("%s is %s years old." % (self.name, self.age))

    def attend_class(self):
        print("%s teach %s" % (self.name, self.course))


#创建具体的对象，该对象的具体特征和功能。
t1 = teacher("sunny chen", 21, "python")
t1.attend_class()

#这就是Python中面向对象编程，通过定义类对一类事物的特征和功能进行整合，然后在通过对象具体到某一个事物的具体特征和功能。
#即类就相当于 印钞机 ，而对象就相当于人民币

🤳其优缺点：

  1. 编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。
  2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。

🎉面向对象设计和面向对象编程

  1. 面向对象设计其思想为“一切皆对象”，而每个对象均有其特征和功能，将这些特征和功能整合到一块就是面向对象设计，而面向对象编程是通过定义类来整合一类事物的共同属性和函数，并可以通过实例化来创建函数。
  2. 面向对象编程只是实现面向对象设计的一种方式，而面向对象设计也可通过其他方式进行实现。例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
python复制代码#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   mianxiangduixiangDemo.py
@Time    :   2019/10/22 09:32:07
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib


def dogs(name, age, kind):
    def init(name, age, kind):
        dog = {
            "name": name,
            "age": age,
            "kind": kind,
            "intro": intro,
            "yell": yell
        }
        return dog

    def intro(dog):
        print("This %s's name is %s,it's %s years old." %
              (dog["kind"], dog["name"], dog["age"]))

    def yell(dog):
        print("The %s is wangwangwang" % (dog["kind"]))

    return init(name, age, kind)


d1 = dogs("sunny chen", 21, "Look")
print(d1["name"])
d1["intro"](d1)

从上面这个例子中可以看出：面向对象设计不一定需要用面向对象编程，也可以用其他方式实现面向对象设计，但是面向对象编程一定是面向对象设计实现的。

👏对象的理解：

核心是“对象”二字，面向对象的设计必须从上帝视角进行设计，而在上帝眼中，世间存在的万物皆为对象，同时不存在的也可以创造出来。程序员也可以把自己当成小说家，可以塑造一个个人物，而每个人物均有其自身的特征，也具有自身的功能去完成一些事情。。

故从这些例子中看出：与面向过程机械式的思维方式形成鲜明的对比，面向对象更加专注对现实世界事物而非流程的模拟，是一种“上帝式”的思维方式。

🎎python面向对象编程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
python复制代码#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File    :   pythonMXDXDemo.py
@Time    :   2019/10/22 09:34:46
@Author  :   YongJia Chen 
@Version :   1.0
@Contact :   chen867647213@163.com
@License :   (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc    :   None
'''

# here put the import lib


class Dog(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s is eating" % (self.name))

    def info(self):
        print("The dog's name is %s,it's %d years old." %
              (self.name, self.age))


dog1 = Dog("Sunny Chen", 33)
print(dog1.name)

# 首先我们定义了一个Dog类，该类中有一个构造函数和两个方法，当我们实例化时，会自动执行__init__()方法，并且将参数dog1,"alex",33传给该构造函数，
# 注会将实例本身作为参数参入，实例之所以能够调用类方法类属性也是通过这种机制实现的。同时在底部会将这些参数传入该对象的属性字典中，方便调用。

类

　　一个类就是对一类事物的特征和功能的整合，也可以说是对具有相同属性事物的一种抽象和模板。而在该类中定义了这些对象的都具备的属性和方法。比如说：动物类、人类、或者说是汽车类等

对象

　　通过类实例化得到的具体事物，该事物具有具体的属性和方法。例如：具体的人、具体的动物或者说某一个汽车等，这些具体的事物均有该类的属性共同的功能，同时也还可以有具有自身的独特的属性和功能，比如：某个具体的人有所有人均有的属性–说话、吃饭等，当然每个人都是独特的–相貌特征等；

属性

　　一类事物共有的特征即为类的属性，而某个具体事物具有的特征即为对象的属性；比如：人类有身高、年龄、性别等特征。

方法

　　人类不止有身高、体重、年龄等这些特征，还能做许多事情，例如：工作、吃饭、唱歌等功能，而这些功能我们也可以称之为方法。

实例化

　　由一个类创造得到一个具体的实例（对象）的过程，称之为实例化。

　　同时在上述案例中有个特殊的方法 __init__()，这个特殊的函数我们称之为构造函数。

构造函数

　　当该类被实例化的时候就会执行该函数。那么我们就可以把要先初始化的属性放到这个函数里面。同时可能我们还会好奇，为什么上述例子中 __init__(self,name,age) ，而我们在默认传参的时候，只传入了一个函数，这是由于 python 在实例化 dog1 = Dog("sunny",21 ) 时，会将实例对象本身作为参数传入即 self = dog1，这种机制才能使得—该实例才能调用类的属性和方法。

快去动手试试吧！

🎉最后

  • 更多参考精彩博文请看这里：陈永佳的博客
  • 喜欢博主的小伙伴可以加个关注、点个赞哦，持续更新嘿嘿！

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%