2.4 可变数据

[giscus[bot]]

2.4 可变数据

SICP Python 中文翻译

https://composingprograms.netlify.app/2/4

[sil3nceyang]

看不懂

[CharlieCRX]

因为这一节涉及的内容太多，有很多前置知识作为知识门槛，所以看着头大也很正常。那就多看几遍吧，我在考虑出一份教程，看看能不能简化这个cs61a的课程内容，提高同志们的阅读体验~😀

[jackydra317]

感谢译者！想请教一个问题，调用连接器
（ >>> celsius = connector('Celsius') // >>> fahrenheit = connector('Fahrenheit')））
时会报错”name 'connector' is not defined“，请问是为什么呢？

[jackydra317]

啊啊，不好意思，是我自己没看清楚，谢谢！

[liucheng532]

你好，我在实现的时候，connect也是显示未定义，这个是要import什么包吗

[xuancai-xiu]

约束传递实现看的一头雾水😥

[ttyy33]

2.4.4 局部状态 中的 “以下运行环境图展示了多次调用由 make_withdraw 创建的函数的效果”不是对应的make_withdraw代码

[ttyy33]

是我浏览器缓存的问题，没有问题，重新刷新一下就正常了

[shenQQQ]

约束传递这部分我理解应该是 将整个计算过程，拆解成许多子模块。
再构造出子模块计算的 函数 与 反函数。
然后根据入参的参数位置，选择各个子模块的计算过程是其“函数”还是“反函数”，
最后把所需“函数“和”反函数“的过程组装成最终的计算过程。

[bogedan]

在2.4.4最后一段第一句话这样用中文表达是不是更加合理，“当你在函数内部给一个变量赋值时，Python 会将这个变量视为局部变量。如果在赋值之前尝试引用这个变量，并且它在当前帧中还没有被定义，Python 会抛出一个 UnboundLocalError 异常。”

[Nebula-hub1]

这样看来清晰多了

[Bersulang]

凌晨三点给我头都看大了 😢

[1224267419]

看的头大

[starryious]

看得确实头大...

[In-tron]

虽然很抽象，但是内容很好啊

[SigmaTopia]

看的头大

[AlexKider]

这一章的内容虽然有点难啃，但是关于变量的查值顺序（scope）等真的帮助很大🥲（让我们感谢ChatGPT） 不过一次看完真的有点头大。。。分两部分看吧，实现的感觉可以放在第二部分再看！

[Nebula-hub1]

疑问：
在2.4.4原文中的一段：
当 balance 属性为声明为 nonlocal 后，每当它的值发生更改时，相应的变化都会同步更新到 balance 属性第一次被声明的位置。回想一下，在没有 noncal 声明之前，所有对 balance 的重新赋值操作都会在当前环境的第一帧中绑定。非局部语句指示名称不会出现在第一个（局部）帧或最后一个（全局）帧，而是出现在其他地方。
中有一句话“相应的变化都会同步更新到 balance 属性第一次被声明的位置”这句话是不是不严谨。
例子：

>>> def outer():
	    x = "outer-x"

	    def middle():
	        x = "middle-x"

	        def inner():
	            nonlocal x
	            x = "inner-x"
        
	        inner()
	        print("middle:", x)

	    middle()
	    print("outer:", x)

	outer()

#输出
middle: inner-x
outer: outer-x

如果是这种情况，相应的变化并不是更新到x第一次被声明的地方，更严谨的说法应该是改变的是最近的，非全局的那个作用域中存在的相应变量

[jackyang714]

简单的总结，约束器与连接器的主要作用是进行非线性的运算，在已知等式关系的情况下，给定某一值进行运算，求解等式关系的其他值。
实现思路:1是定义连接器，定义一个字典来储存函数，也即dictionary dispatch。储存各种function，包含求值，更新，删除，以及关联的约束。在更新值的步骤重要的是通知该连接器关联的约束器，使之也更新值
2 定义约束器，定义一个字典来记录function，同上。主要的function即是定义等式关系，进行调用连接器的函数更新值。
3 常数的约束器类似，但更简单，只是调用连接器的设置值操作

[wyZzOvO]

2.4.5 更深层的意义：创建“对象”的雏形
make_withdraw 函数是一个构造函数（Constructor）。它返回的 withdraw 函数是一个行为（Method），而这个行为所操作的数据 balance 是状态（State），并且被很好地封装（Encapsulated） 了起来，外部无法直接访问，只能通过调用 withdraw 来间接修改。

这其实就是面向对象编程（OOP） 中“对象”的雏形！一个对象将数据和对数据的操作捆绑在一起。———— 来自deepseek

[wyZzOvO]

deepseek:

好的，CS61A 的 2.4.9 节“约束传递”（Constraint Propagation）是一个非常有趣但也确实容易让人困惑的话题。它引入了一种全新的编程范式。

我会用一个清晰的类比和分解来帮你理解它。

核心思想：什么是约束传递？
想象一个简单的数学关系：c = a + b。
在传统命令式编程中，你通常会这样做：

给 a 赋值 1

a = 1

给 b 赋值 2

b = 2

计算 c = a + b，得到 3

约束传递则反其道而行之。它的理念是：
我不告诉你先做什么后做什么。我只需要声明他们之间的关系（约束），系统就会自动维护这个关系始终成立。

你可以：

告诉系统：c = a + b（这是一个“约束”）。

然后告诉系统：a 是 1。系统会知道 a 变了，但因为它还不知道 b 和 c，所以什么也不计算。

再告诉系统：b 是 2。系统检测到变化，发现现在 a 和 b 都知道了，于是自动计算出 c = 3 并设置好。

你甚至可以反过来，先告诉系统 c 是 10 和 a 是 4，系统会自动推导出 b 必须是 6。

一个绝佳的类比就是 Excel 表格：

你在单元格 A1 输入 1

在单元格 B1 输入 2

在单元格 C1 输入公式 =A1+B1 (这就是一个“约束”)

Excel 会自动显示 3。

如果你后来把 A1 改成 5，C1 会自动变成 7。

约束传递系统就是一个用 Python 实现的、迷你版的、可编程的 Excel。

系统的三个核心组成部分
要构建这样一个系统，需要三种“角色”：

1. 连接器 (Connector)
   是什么？ 这就是上面例子里的 a, b, c。它是一个对象，用来存储一个值（比如数字）。

关键特性： 它不知道自己怎么被计算出来，它只关心 “我是谁？” 和 “我的值变了，需要通知谁？”。

它有三个核心方法：

set_value(source, new_value): 某个人（source）试图给我赋予一个新值。

get_value(): 获取我当前存储的值。

connect(constraint): 告诉连接器，某个约束关心你的值的变化。当你的值改变时，需要通知这个约束。

2. 约束 (Constraint)
   是什么？ 这就是上面例子里的 加法规则、乘法规则 等。它是一个对象，代表一个关系或规则。

关键特性： 它知道如何计算，但通常不自己存储数据。它关心 “我的输入是谁？” 和 “如果我的某个输入变了，我该如何更新其他输入输出以维持关系？”。

它的核心方法：

new_value(): 当某个连接的连接器值发生变化时，会调用这个方法。约束在这个方法里决定该做什么（例如，计算新的值并设置到另一个连接器）。

forget_value(): 当某个连接的连接器值被撤销时，会调用这个方法。约束需要处理“未知”状态。

3. 网络 (Network / “布线”)
   是什么？ 这是一系列函数（例如 adder(a, b, c)），它的唯一工作就是把一个约束和多个连接器“连接”起来。

它做什么？ 它创建一个约束对象（比如一个加法器约束），然后调用 a.connect(约束)、b.connect(约束)、c.connect(约束)，告诉这三个连接器：“以后你们的值有任何变化，都要通知这个加法器约束”。

关系图：

text
连接器 (a) <----> 约束 (加法器) <----> 连接器 (b)
^ |
| |
| v
+-----------------> 连接器 (c)
(一个约束监控着多个连接器，一个连接器也可以被多个约束监控)

工作流程示例 (以加法器 adder 为例)
假设我们运行以下代码：

python
a = Connector()
b = Connector()
c = Connector()
adder(a, b, c) # 网络函数，将 a, b, c 和加法约束连接起来

a.set_value('user', 10)
b.set_value('user', 5)
建立关系 (adder(a, b, c)): adder 函数创建了一个加法约束，并告诉 a, b, c 三个连接器：“我是你们的约束，你们有变化要通知我”。

设置第一个值 (a.set_value('user', 10)):

a 连接器收到指令，要把自己的值设置为 10。

a 连接器说：“好的，我的值现在是10了。另外，我记得有个加法约束关心我，我得去通知它一下。”

a 连接器调用加法约束的 new_value() 方法，说：“嗨，我（a）变了！”

加法约束被唤醒，它检查所有输入：a 是10，但 b 还不知道（是None），c 也不知道。所以它什么也做不了，只能等待。

设置第二个值 (b.set_value('user', 5)):

b 连接器收到指令，把值设置为 5。

b 连接器更新自己的值，然后也去通知加法约束。

加法约束再次被唤醒。它检查所有输入：a 是10，b 是5，都知道了！而 c 还不知道。

约束开始履行它的职责：它根据规则 c = a + b 计算出 c 应该是 15。

它调用 c.set_value('adder', 15)。注意这里的 source 是 'adder' 而不是 'user'，意思是这个值是由加法器计算得出的，不是用户直接设置的。

c 连接器收到指令，将自己的值设置为15。它也会通知所有关心它的约束（比如可能还有一个乘法约束也连着 c）。

至此，整个系统通过“值变化 -> 通知约束 -> 约束计算 -> 设置新值 -> 触发新的通知...”的链条，自动地将信息（约束）传递（Propagation） 开来，保证了声明的所有关系始终得到满足。

为什么要学这个？
声明式编程（Declarative Programming）：你只需要声明“是什么”（What），而不是“怎么做”（How）。这是一种强大的抽象。

模拟物理世界：很多系统天生就是由约束驱动的（比如电路、物理结构、报表）。用约束系统来建模它们非常直观。

理解计算模型：它展示了数据流（Dataflow）的一种实现方式，即计算是由数据（值）的可用性所驱动的。

总结一下：
2.4.9 节教你构建了一个微型系统。在这个系统里，你创建一些存储单元（连接器），然后用规则（约束） 把它们连接起来。之后，你只需要改变某个单元的值，所有相关的规则都会被自动触发，从而更新其他单元的值以保持所有规则成立。这个过程就是约束传递。

希望这个解释能帮你打开思路！如果对具体的代码实现有疑问，可以再提出。