心智的活动,除了尽力产生各种简单的认知之外,主要表现为如下三个方面:(1)将若干简单认知组合为一个复合的认识,由此产出各种复杂的认知。(2)将两个认知放在一起对照,不管他们如何简单或者复杂,在这样做时,并不能将他们合而为一。由此得到有关他们的相互关系的认知。(3)将有关认识与那些在实际中和它们同在的所有其他认识隔离开,这就是抽象。
所有普遍的认识都是这样得到的。
--John Locke 有关人类理解的随笔,1960
本文为SICP的一些笔记,用于记录一些对计算机程序不同的看法,旨在通过数学计算的思路入门程序设计。SCIP是一本关于计算过程的书,计算过程关心数据的操作,创建程序的目的也是为了数据的处理,表现在代码中便是符号表达式的精心编排,计算过程精密而准确地执行相应程序,初学程序设计的人们就像巫师的徒弟们,学习如何理解和预测咒语的效果,学习并验证结果,不过,学习程序的危险性远远小于巫术。SICP中所有的代码实践为scheme(scheme为Lisp的某个版本,Lisp仍是AI领域中拥有理论上最高演算能力的语言),执行过程为解释器的代码交互过程,依据同样的解释器运行程序原理,也可以用python实现书上的练习题。
每一种编程语言都有三种机制:
基本表达式为程序语言所关心的最简单的个体,而组合的方法即组合这些简单的个体成为复杂的元素。再将复杂的元素进行抽象,便可得到一个单元,单元也可以作为一个简单的个体继续组合,层层递进便组成了完整的程序,这也是为什么许多书中一定会提到递归
。
在程序中,有两类基本要素:过程和数据,数据为用户希望操作的“东西”,而过程就是有关操作这些规则的描述,任何强有力程序设计语言必须表述基本的数据和基本过程,还需提供对过程和数据进行组合和抽象的方法。
最简单的程序入门,观看代码与解释器交互,假设键盘输入了一个表达式
,解释器将表达式的求值结果显示出来,最基本的表达式就是数,例如,给一个数486
:
mt@mt-P243:~$ python Python 2.7.17 (default) [GCC 7.5.0] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> 486 486
将表示数的表达式组合起来,形成复合表达式
Python 2.7.17 (default) [GCC 7.5.0] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> 1000-7 993 >>> 993-7 986 >>> (3*((2*4)+(3+5)))+((10-7)+6) 57
对于复杂的算术式,解释其也按照基本循环进行操作,读入-求值-打印
通过给数据命名,通过使用名字进行运算,将名称标识符称为变量,将数据存到变量中。解决好命名问题,程序就完成一大半,最基本的表达式为变量赋值,此时数据到变量的过程也是一种抽象:
>>> size = 2 >>> size 2
评估组合的过程有两步:
>>> (3*((2*4)+(3+5)))
可用树结构
graph TD root["3*((2*4)+(3+5))"]--> LT["3"] root["3*((2*4)+(3+5))"]--> RT["((2*4)+(3+5))"] RT["((2*4)+(3+5))"]-->RTL["(2*4)"] RT["((2*4)+(3+5))"]-->RTR["(3+5)"] RTL["(2*4)"] -->RTLL["2"] RTL["(2*4)"] -->RTLR["4"] RTR["(3+5)"] -->RTRL["3"] RTR["(3+5)"] -->RTRR["5"]a = (3*((2*4)+(3+5)))+((10-7)+6)
计算步骤:
步骤1 | 猜测 | 商 | 平均值 |
---|---|---|---|
(1) | 1 | 2/1=2 | (2+1)/2=1.5 |
(2) | 1.5 | 2/1.5 = 1.333 | (1.333+1.5)/2=1.4165 |
(3) | 1.4165 | 2/1.4165 = 1.412 | (1.4165+1.412)/2=1.41425 |
(4) | 1.41425 | 2/1.41425 = 1.4142 | (1.41425+1.4142)/2=1.414225 |
如果不限制条件,计算将一直进行下去,所以为了设计程序来计算平方根考虑计算步骤
1)先猜值
2)计算商
3)计算平均值作为下一轮的猜值
如果不加停止条件,那么将会一直计算下去,观察计算结果可以发现猜测值、商还有平均值越来越接近,如果约定一个误差范围,就可作为计算的停止条件(good_enough
)。
1)猜值的终止条件
def square(x): return x*x def good_enough(guess,x): if abs(square(guess)-square(x))<0.001: return True else: return False
2)和3)计算平均,作为下一轮猜值的起始,如果结果很好,立即结束,否则继续猜,迭代过程可写为
def improve_guess(guess,x): return (x/guess + guess)/2 def sqrt_iter(guess,x): print(guess,x) if good_enough(guess,improve_guess(guess,x)): print('guess:'+str(guess)) return guess else: return sqrt_iter(improve_guess(guess,x),x)
程序可写为
def sqrt(x): return sqrt_iter(1.0,x)
程序分解[原问题到子问题的分解]:
graph TD root["sqrt"]--> Node["sqrt_iter"] Node["sqrt_iter"]-->LT["good_enough"] Node["sqrt_iter"]-->RT["improve"] RT["improve"] --> improve_guess LT["good_enough"] --> square LT["good_enough"] --> abs「使用许多基本的算术操作,对操作进行组合,通过定义各种复合过程,然后对复合过程进行抽象」
考虑阶乘
\[n!=n·(n-1)·(n-2)···3·2·1 \]与牛顿法求平方根一样的思路,为了计算第n次迭代,需要考虑n-1次的结果,阶乘可写为
\[n!=n·(n-1)! \]那么就知道两种情况的编码思路:
2)第n次 到 (n-1) 的迭代
def factorial1(n): if n==1: return 1 else: return n* factorial(n-1)
用另一种观点看待问题,1*2然后将结果 *3,再次 *4,直到 n,那么利用一个计数器counter 即可写成如下迭代:
\[product \leftarrow counter \times product \\ counter \leftarrow counter + 1 \]def fact_iter(product, counter, max_count): if counter>max_count: return product else: return fact_iter(counter*product, counter+1, max_count) def factorial2(n): return fact_iter(1,1,n)
factorial1
采用了先展开后计算的思路,而factorial2
采用了先计算后展开的思路,factorial1
称为递归计算过程(表达式越写越长),而factorial2
计算过程中表达式未发生改变,factorial2
多了一个变量用于保存中间的结果,这种迭代过程有时也和计算理论中提到的状态变量类似,计算过程即状态转换的过程,同时还有一个(可能有)的停机过程。
两个整数的最大公约数(GCD)定义为能除尽这两个数的最大整数,算法基于以下观察:如果r是a除以b的余数,那么a和b的公约数正好是b和r的公约数:
\[GCD(a,b)=GCD(b,r) \]此时,一个GCD的计算问题连续地归约到越来越小的整数对,例如
\[GCD(206,40)\\ =GCD(40,6)\\ =GCD(6,4)\\ =GCD(4,2)\\ =GCD(2,0)\\ =2 \]def remainder(a,b): return a%b def gcd(a,b): if b==0: return a else: return gcd(b, remainder(a,b))
上述的过程也就是一类抽象,描述了一些对于数的符合操作,但是同时又不依赖于特定的数--将数作为参数传入函数。人们对功能强大的程序设计语言有一个必然要求,就是能为公共模式命名,建立抽象,而后直接在抽象的层次上工作。
过程作为参数,
(1)计算从a到b的各个整数之和:
def sum_integers(a,b): if a > b: return 0 else: return a + sum_integers(a+1,b)
(2)计算从a到b的各个整数立方和:
def sum_cubes(a,b): if a > b: return 0 else: return cube(a) + sum_cubes(a+1,b)
(3)计算下面的序列之和:
\[\frac{1}{1·3}+\frac{1}{5·7}+\frac{1}{9·11}+···\approx \frac{\pi}{8} \]def pi_sum(a,b): if a > b: return 0 else: return 1/(a*(a+2)) + pi_sum(a+4,b)
明显看出,三个过程共享着一种公共的基础模式:从a算出需要加的项的函数,还有用于提供下一个a值的函数,可以通过一个模板描述
def sum_term(term, a, next, b): if a>b: return 0 else: return term(a)+sum_term(term, next(a), next, b)
而计算立方和时,term(a)
为cube(a)
,next(a)
为下一项,根据这个过程,可以改写上述(1)~(3)的例子
def inc(n): return n+1 def cube(a): return a*a*a def sum_cubes(a,b): return sum_term(cube,a,inc,b)
有了上面这个模板sum_term
,将其作为基本单元,可以形式化其他概念,例如在a和b之间计算定积分的近似值
其中dx
是一个很小的值,可以将公式转化为
def integral(f, a, b, dx): def add_dx(x): return x + dx return sum_term(f, a+dx/2, add_dx, b)*dx
在原先写的pi_sum
函数式,返回了“其输入值加4的过程”和“其输入值加2的乘积倒数的过程”,这个过程可以使用辅助函数,也可以使用lambda表达式,python中的labmda
表达式格式为 lambda <表达式的返回值>: 表达式
lambda x:x+4 lambda x: 1/(x*(x+4))
为了实现和原来pi_sum
的过程,可以使用lambda表达式和模板sum_term
实现一样的功能
def pi_sum(a,b): return sum_term(lambda x: 1.0 / (x * (x + 2)),a, lambda x: x+4,b)
函数调用函数的过程,类似于数学上定义的复合函数的概念,如果f(x)=x
无限套娃,可以找到一个不动点:
例如黄金分割率就是下面函数的不动点
\[f(x)=1+\frac{1}{x} \]利用程序计算过程如下:
tolerance = 0.00001 def fixed_point(f, first_guess): def close_enough(v1,v2): return True if abs(v1-v2)<tolerance else False def try_guess(guess): next_guess = f(guess) if close_enough(next_guess,guess): return next_guess else: return try_guess(next_guess) return try_guess(first_guess) print(fixed_point(lambda x:1+1/x, 1))