SICP的Python实现/SICP的Python实现1.1

返回“程序设计语言”

The Elements of Programming

Expressions

1. 486

   486

2. (+ 137 349)
   486
   (- 1000 334)
   666
   (* 5 99)
   495
   (/ 10 5)
   2
   (+ 2.7 10)
   12.7

   137 + 349
   1000 - 334
   5 * 99
   10 / 5
   2.7 + 10

3. (+ 21 35 12 7)
   75
   
   (* 25 4 12)
   1200

   21 + 35 + 12 + 7
   25 * 4 * 12

   或者

   reduce(int.__add__, [21, 35, 12, 7])
   reduce(int.__mul__, [25, 4, 12])

4. (+ (* 3 5) (- 10 6))
   19

   (3 * 5) + (10 - 6)

5. (+ (* 3
         (+ (* 2 4)
            (+ 3 5)))
      (+ (- 10 7)
         6))

   (3 * ((2*4)+(3+5)) ) + ((10-7)+6)

Naming and the Environment

1. (define size 2)

   size = 2

2. size
   2
   (* 5 size)
   10

   size
   5 * size

3. (define pi 3.14159)
   (define radius 10)
   (* pi (* radius radius))
   314.159
   (define circumference (* 2 pi radius))
   circumference
   62.8318

   pi = 3.14159
   radius = 10
   pi * (radius * radius)
   circumference = 2 * pi * radius
   circumference

Evaluating Combinations

1. (* (+ 2 (* 4 6))
      (+ 3 5 7))

   (2+(4*6)) * (3+5+7)

Compound Procedures

1. (define (square x) (* x x))

   square = lambda x: x*x

2. (square 21)
   441
   
   (square (+ 2 5))
   49
   
   (square (square 3))
   81

   square(21)
   square(2+5)
   square(square(3))

3. (define (sum-of-squares x y)
     (+ (square x) (square y)))
   
   (sum-of-squares 3 4)
   25

   sum_of_squares = lambda x, y: square(x) + square(y)
   sum_of_squares(3, 4)

4. (define (f a)
     (sum-of-squares (+ a 1) (* a 2)))
   
   (f 5)
   136

   f = lambda a:sum_of_squares(a+1, a*2)
   f(5)

The Substitution Model for Procedure Application

Conditional Expressions and Predicates

1. (define (abs x)
     (cond ((> x 0) x)
           ((= x 0) 0)
           ((< x 0) (- x))))

   abs = lambda x: x if x > 0 else ( 0 if x == 0 else (-x if x < 0 else 0))

   或者

   abs = lambda x: x if x > 0 else (0 if x == 0 else -x)

2. (define (abs x)
     (cond ((< x 0) (- x))
           (else x)))

   abs = lambda x: -x if x < 0 else x

3. (define (abs x)
     (if (< x 0)
         (- x)
         x))

   abs = lambda x: -x if x < 0 else x

4. (and (> x 5) (< x 10))

   x > 5 and x < 10

5. (define (>= x y)
     (or (> x y) (= x y)))

   greater_or_equal = lambda x, y: x>y or x==y

6. (define (>= x y)
     (not (< x y)))

   greater_or_equal = lambda x, y: not x < y

Example: Square Roots by Newton’s Method

1. (define (sqrt-iter guess x)
     (if (good-enough? guess x)
         guess
         (sqrt-iter (improve guess x)
                    x)))

   sqrt_iter = lambda guess, x: guess if good_enough(guess, x) else sqrt_iter(improve(guess, x), x)

2. (define (improve guess x)
     (average guess (/ x guess)))

   improve = lambda guess, x: average(guess, x/guess)

3. (define (average x y)
     (/ (+ x y) 2))

   average = lambda x, y: (x+y)/2.0

4. (define (good-enough? guess x)
     (< (abs (- (square guess) x)) 0.001))

   good_enough = lambda guess, x: abs(square(guess)-x)< 0.001

5. (define (sqrt x)
     (sqrt-iter 1.0 x))

   sqrt = lambda x:sqrt_iter(1.0, x)

6. (sqrt 9)
   3.00009155413138
   (sqrt (+ 100 37))
   11.704699917758145
   (sqrt (+ (sqrt 2) (sqrt 3)))
   1.7739279023207892
   (square (sqrt 1000))
   1000.000369924366

   sqrt(9)
   sqrt(100+37)
   sqrt(sqrt(2)+sqrt(3))
   square(sqrt(1000))

Procedures as Black-Box Abstractions

1. (define (square x) (* x x))
   
   (define (square x)
     (exp (double (log x))))
   
   (define (double x) (+ x x))

   square = lambda x: x*x
   from math import exp, log
   square = lambda x: exp(double(log(x)))
   double = lambda x: x+x

2. (define (square x) (* x x))
   
   (define (square y) (* y y))

   square = lambda x: x*x
   square = lambda y: y*y

3. (define (sqrt x)
     (define (good-enough? guess x)
       (< (abs (- (square guess) x)) 0.001))
     (define (improve guess x)
       (average guess (/ x guess)))
     (define (sqrt-iter guess x)
       (if (good-enough? guess x)
           guess
           (sqrt-iter (improve guess x) x)))
     (sqrt-iter 1.0 x))

   def sqrt(x):
       good_enough = lambda guess, x: abs(square(guess)-x)< 0.001
       improve = lambda guess, x: average(guess, x/guess)
       sqrt_iter = lambda guess, x: guess if good_enough(guess, x) else sqrt_iter(improve(guess, x), x)
       return sqrt_iter(1.0, x)

4. (define (sqrt x)
     (define (good-enough? guess)
       (< (abs (- (square guess) x)) 0.001))
     (define (improve guess)
       (average guess (/ x guess)))
     (define (sqrt-iter guess)
       (if (good-enough? guess)
           guess
           (sqrt-iter (improve guess))))
     (sqrt-iter 1.0))

   def sqrt(x):
       good_enough = lambda guess: abs(square(guess)-x)< 0.001
       improve = lambda guess: average(guess, x/guess)
       sqrt_iter = lambda guess: guess if good_enough(guess) else sqrt_iter(improve(guess))
       return sqrt_iter(1.0)