编程中的抽象是什么？

当你写下 print("hi") 时，你不会去想这几个字母是怎么出现在屏幕上的。在这一行代码之下，Python 先把文本转换成字节，再请求操作系统把它们写出去；操作系统把字节交给终端，终端再用字体把每个字母绘制成像素。每一层都向上一层提供一个简单的承诺，同时隐藏自己是如何兑现这个承诺的。这种隐藏就是抽象，而每个程序都建立在许多这样的层之上。

抽象的层次

每一层都由下一层构建而成，但不了解下一层也能理解它。你不知道磁盘块是什么，照样能写出能运行的 Python 代码；操作系统也不需要知道文件里装的是 Python 代码，照样能把它存好。

代码中的抽象是如何实现的

程序员主要用两种方式构建自己的抽象层。

过程抽象就是函数。函数名、参数和返回值构成接口，函数体则是被隐藏的细节。一旦有了 average(scores)，程序的其他部分直接使用它即可，不必去看它是怎么相加和相除的。

数据抽象根据“能对一个类型做什么”来定义它，而不是根据它如何存储数据。队列就是“从队尾加入，从队首取出”。至于元素在内存中如何排列，则是内部自己的事：

from collections import deque

class Queue:
    """First in, first out. Callers only see add() and next()."""
    def __init__(self):
        self._items = deque()     # swap this for a list and callers never notice
    def add(self, item):
        self._items.append(item)
    def next(self):
        return self._items.popleft()
    def __len__(self):
        return len(self._items)

orders = Queue()
for dish in ["soup", "pasta", "cake"]:
    orders.add(dish)
while len(orders):
    print("serving", orders.next())

serving soup
serving pasta
serving cake

底部的代码对 deque 一无所知。如果你把它换成普通列表加 pop(0)，输出完全一样，只是队列很长时会更慢，因为删除列表的第一个元素需要移动其余所有元素。接口没有变，所以类外面的代码一行都不用改。

抽象类与接口

在面向对象编程中，抽象通常指规定一组类必须做什么，而把怎么做交给每个类自己决定。在 Python 中，abc 模块可以把方法标记为抽象方法；只要类中还有未实现的抽象方法，就不能实例化：

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def send(self, to, text):
        """Every notifier must say how it sends a message."""

class Email(Notifier):
    def send(self, to, text):
        print(f"email to {to}: {text}")

class SMS(Notifier):
    def send(self, to, text):
        print(f"sms to {to}: {text}")

def remind(notifier, user):
    notifier.send(user, "Your package arrives today")

remind(Email(), "ana@example.com")
remind(SMS(), "+15550100")
try:
    Notifier()
except TypeError:
    print("Notifier is abstract: create an Email or an SMS instead")

email to ana@example.com: Your package arrives today
sms to +15550100: Your package arrives today
Notifier is abstract: create an Email or an SMS instead

remind() 只依赖于抽象：任何带有 send 方法的东西都行。要增加推送通知，只需再写一个新类，remind() 完全不用动。最后这一步，即同一个调用对不同的类执行不同的代码，就是多态：抽象定义共同的接口，多态让它真正运转起来。

Java 用关键字提供了同样的工具：

interface Notifier {
    void send(String to, String text);
}

class Email implements Notifier {
    public void send(String to, String text) { /* talk to the mail server */ }
}

写 new Notifier() 会导致编译错误，因为接口没有可以运行的实现。文档详细讲解了 Java 中的抽象类和接口。

抽象与封装的区别

这两个概念经常一起出现，所以很容易混淆。

抽象决定展示哪些操作；封装确保其余部分保持隐藏。上面的 Queue 两者兼具：add 和 next 是抽象，_items 前面的下划线则是封装。

有漏洞的抽象和其他常见错误

Joel Spolsky 在 2002 年提出了抽象泄漏定律：任何不简单的抽象，都会让一部分被隐藏的细节漏出来。浮点数是最经典的例子。它们看起来就像普通的小数，直到底层的二进制存储方式暴露出来：

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

0.30000000000000004
False

0.1 和 0.2 都无法用二进制位精确存储，所以两者之和会有一点偏差。你可以用好几年浮点数都不必考虑这个问题，但不可能永远不碰到它。这也是为什么了解你所在层次的下一层会很有帮助。

另外两个错误也很常见：

• 过早抽象。 为永远不会出现的情况搭建的类层次结构，只会变成额外需要阅读和修改的代码。Sandi Metz 说过：“重复的代价远比错误的抽象低。”
• 把抽象和 abstract 关键字混为一谈。 抽象类只是工具之一。每个命名得当的函数也都是一种抽象。

下一步学什么

阅读封装和多态，补全你对面向对象的整体认识。操作系统页面介绍了你的程序所依赖的最大的抽象。想要动手练习，Python 课程从一开始就带你编写类和函数，Java 课程则讲解了抽象类和接口。