大象装进冰箱要几步？Python 来解答

最新推荐文章于 2023-11-23 09:51:57 发布

Python中文社区

最新推荐文章于 2023-11-23 09:51:57 发布

阅读量1.5k

点赞数 1

原文链接：https://jinshuju.net/f/kb1Bcq

版权

我想你一定知道这个小品：问把大象装冰箱需要几步？

1、打开冰箱门

2、把大象装进冰箱

3、关上冰箱门

对应的python代码：

def open_ref(ref):
   print("打开冰箱")

def ref_ele(ele):
   print("大象进冰箱")

def close_ref(ref):
   print("关上冰箱")

ref = "冰箱"
ele = "大象"

# 第一步：打开冰箱
open_ref(ref)

# 第二步：把大象放进冰箱
ref_ele(ele)

# 第三步：关上冰箱
close_ref(ref)

在编程中，这种注重过程的思想，就是面向过程。

当解决问题的时候，把事情拆分成：一个个函数，然后按照一定的顺序，执行完这些函数，事情就搞定了。

那么，面向对象又是什么？

面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象（冰箱、大象），然后让每个对象去执行自己的方法，问题得到解决。

对于开篇的问题，面向对象是怎么解决的呢？

创建两个类：大象类和冰箱类。

冰箱.开门

大象.进冰箱

冰箱.关门

# 定义大象类
class Ele(object):
    def __init__(self, name):
        self.name = name

    def ref_ele(self):
        print("大象进冰箱")

# 定义冰箱类
class Ref(object):
    def __init__(self, name):
        self.name = name

    def open_ref(self):
        print("打开冰箱")

    def close_ref(self):
        print("关上冰箱")

ref = Ref('美的')
ele = Ele('可爱象')

ref.open_ref()
ele.ref_ele()
ref.close_ref()

两者的区别与联系

在网上，有一个蛋炒饭和盖浇饭的例子，很生动。

https://zhuanlan.zhihu.com/p/75265007

总的来说，面向过程注重的是步骤，如果需求复杂，“饭”、“菜”搅拌在一起，代码会变得很复杂；

面向对象注重的是对象和职责，“饭”、“菜”分离，不同的对象承担不同的职责，更加适合应对复杂的需求变化。

我们之前写的一些小脚本，实现的一些小功能，大都是面向过程的；接下来，要好好聊一聊面向对象了。

首先，先来了解一下“类”的概念，所谓“类”就是一群具有相同特征或者行为的事物的一个统称，比如“人类”、“猫类”，是抽象的。

那么，“对象”就是一个具体的你、我、他，或者我家那只走丢的猫。

也就是说，“对象”是由类创建出来的，如果说“对象”是一架飞机，那么，“类”就是制造飞机前绘制的模型图。

有了这些概念之后，让我们通过一个例子，来认识一下面向对象的三大特性：封装、继承和多态。

先来看一下实现需求。

一共有三个类，分别是“人类”、“猫类”和“哆啦A梦类”；

“猫类”有一个名字属性，和一个玩游戏的方法；“哆啦A梦类”继承自“猫类”； “人类”有一个和“猫类”或者“哆啦A梦类”玩耍的方法。

1）在 Cat类中封装name属性和game()方法，普通猫只是简单的玩耍。

2）定义DuoLaACat继承自Cat，并且重写game()，哆啦A梦需要和大熊玩耍。

3）定义 Person 类，并且封装一个和猫玩的方法，在方法内部，直接让猫对象调用game()

1、封装

根据职责，将“属性 ”和“ 方法”封装到一个抽象的类中，我的理解就是：隐藏一切可以隐藏的实现细节，只向外界提供简单的编程接口。

本例中，Cat的属性就是name(名字)，方法就是game()，普通的玩耍。

通过Cat类创建的对象jumao=Cat("橘猫")，就可以使用game()方法。外界是不需要知道game()方法的具体实现的，相当于提供了一个调用的接口。

2、继承

实现代码的重用，相同的代码不需要重复的编写。子类针对自己特有的需求，编写特定的代码。

本例中，DuoLaACat继承自Cat，并且重写game()方法，不再是普通的玩耍，因为哆啦A梦需要和大熊玩耍（自己特有的需求）。

3、多态

不同的子类对象调用相同的父类方法，产生不同的执行结果。以继承和重写父类方法为前提，增加代码的灵活度。

本例中，用Person类创建的xiaoming对象，在和橘猫玩的时候，与和哆啦A梦玩的时候，会有不一样的执行结果。

相关的细节都可以在源码中看到：

# 1、普通猫，封装
class Cat(object):
    def __init__(self, name):
        self.name = name
    def game(self):
        print("%s 玩毛线..." % self.name)

# 2、哆啦A梦继承自普通猫
class DuoLaACat(Cat):
    # 多态的体现，重写父类的game()方法
    def game(self):
        print("%s 和大熊玩..." % self.name)

# 3、人类
class Person(object):

    def __init__(self, name):
        self.name = name
    def game_with_cat(self, cat):
        print("%s 和 %s 玩耍..." % (self.name, cat.name))
        # 让狗玩耍
        cat.game()


# 1. 创建一个猫对象
# jumao = Cat("橘猫")
duolacat = DuoLaACat("哆啦A猫")

# 2. 创建一个小明对象
xiaoming = Person("小明")

# 3. 让小明调用和猫玩的方法
xiaoming.game_with_cat(duolacat)

运行结果：
小明 和 哆啦A猫 玩耍...
哆啦A猫 和大熊玩...

另一种运行结果：
小明 和 橘猫 玩耍...
橘猫 玩毛线...