过程式编程 vs 面向对象编程&函数式编程

编程范式这个话题，说起来其实挺有意思的。不同的编程范式代表了不同的思维方式，没有绝对的好坏，关键看场景。下面我们逐个聊聊三种主流范式，看看它们各自是怎么解决问题的，又有什么局限。

1. 过程式编程

先看一段简单的过程式代码：

x = 2
y = 4
z = 8
xyz = x + y + z
print(xyz)

你会发现，每个操作都在改变程序的状态——变量在变，内存里的值在变。这就是过程式编程的典型特征：数据放在全局变量里，函数负责处理这些数据。下面这个例子更直观：

rock = []
country = []

def collect_songs():
    song = "Enter a song."
    ask = "Type r or c. q to quit"
    while True:
        genre = input(ask)
        if genre == "q":
            break
        if genre == "r":
            rk = input(song)
            rock.append(rk)
        elif genre == ("c"):
            cy = input(song)
            country.append(cy)
        else:
            print("Invalid.")
    print(rock)
    print(country)

collect_songs()

问题出在哪里？程序的状态全部暴露在全局变量中。一旦程序规模变大，多个函数都会操作同一个全局变量，你很难追踪每个地方到底改了什么。比如，某个函数把全局变量 rock 的列表改了一下，后面另一个函数又因为忘记之前的修改，再次操作同一个变量，数据准确性瞬间崩溃。

后果很直接：功能一多，全局变量跟着增多，到最后改一个变量牵一发而动全身，代码基本没法维护。这种“副作用”（side effect）——比如不小心把某个变量递增了两次——在过程式编程里特别容易发生，而且往往防不胜防。

2. 函数式编程

函数式编程的解决方案很干脆：彻底消灭全局状态。程序员只依赖传入函数的参数，不依赖也不修改外部数据。函数之间通过参数传递状态，这样一来，副作用就被消除了。

函数式代码的核心特征就是“没有副作用”。它既不依赖当前函数之外的数据，也不改变当前函数之外的数据。来看两个对比：

带副作用的函数：

a = 0
def increment():
    global a
    a += 1
    print(a)

# 测试代码：
increment()  # 返回1
print(a)     # 返回1

不带副作用的函数：

def increment(a):
    return a + 1

# 测试代码：
print(increment(2))

第一个函数依赖全局变量 a 并修改了它，这就是副作用。第二个函数只依赖传进来的参数，返回新值，不碰任何外部数据——干净利落。

函数式编程最大的好处，就是彻底消除了由全局状态引发的错误（因为根本就没有全局状态）。但缺点也很明显：有些问题用状态来描述会更直观。比如设计一个人机界面，按钮控制画面是否可见——用全局变量 True/False 多简单，不用全局状态反而要绕一大圈。

3. 面向对象编程

面向对象编程（OOP）同样想解决全局状态的问题，但方法不同：它用对象来保存状态，而不是用函数。类（class）定义了一组具有相同属性和行为的对象模板。比如一袋橘子，每个橘子都是一个对象，它们都有颜色、重量这些属性，但具体值不同。类就是用来建模这种“同类不同个体”的。

在 Python 中，类的定义语法是 class [类名]:，类名惯例用驼峰命名法（首字母大写，如 LikeThis）。类里面可以定义方法（method），方法本质上就是函数，但有一个特殊要求：第一个参数必须是 self——这个名字是惯例，不能省。因为 Python 在调用方法时，会自动把对象本身传进去。

看一个橘子类的例子：

class Orange():
    def __init__(self, w, c):
        self.weight = w
        self.color = c
        print("Created!")

__init__ 是一个特殊方法（魔法方法），在创建对象时自动调用。里面用 self.变量名 定义了实例变量——属于每个对象自己的变量。创建对象时，传入参数即可：

orl = Orange(10, "dark")
print(orl)  # 输出: Created! <__main__.Orange object at 0x02B30490>
print(orl.weight)  # 10
print(orl.color)   # dark

实例变量可以随时修改：

orl.weight = 100
orl.color = "yellow"
print(orl.weight)  # 100
print(orl.color)   # yellow

同一个类可以创建多个不同值的对象：

orl2 = Orange(23, "white")
orl3 = Orange(12, "red")

对象还可以有行为。比如橘子会腐烂，我们可以写一个方法模拟：

class Orange():
    def __init__(self, w, c):
        self.weight = w
        self.color = c
        self.mold = 0
        print("Created!")

    def rot(self, days, temp):
        self.mold = days * temp

orl = Orange(7, "dark")
print(orl.mold)  # 0
orl.rot(10, 98)
print(orl.mold)  # 980

rot 方法接受两个参数（天数、温度），然后修改了对象内部的 mold 属性。这就是面向对象的典型用法：把数据和行为封装在对象内部。

面向对象编程的优点很明显：鼓励代码复用，降低开发和维护成本；把问题拆解成对象，代码更容易理解和维护。缺点则是前期设计需要花更多功夫——你得提前规划好类、方法、继承关系等等。

习题

1. 定义一个叫 Apple 的类，创建 4 个实例变量，表示苹果的 4 种属性。
2. 定义一个叫 Circle 的类，创建 area 方法计算其面积。然后创建一个 Circle 对象，调用其 area 方法，打印结果。可使用 Python 内置的 math 模块中的 pi 函数。
3. 定义一个叫 Triangle 的类，创建 area 方法计算并返回面积。然后创建一个 Triangle 对象，调用其 area 方法，打印结果。
4. 定义一个叫 Hexagon 的类，创建 calculate_perimeter 方法，计算并返回其周长。然后创建一个 Hexagon 对象，调用其 calculate_perimeter 方法，并打印结果。