TableOfContents

Building Abstractions with Procedures

1. The Elements of Programming

1.1. Expressions

1. 486

      1 486
   

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

      1 137 + 349
      2 1000 - 334
      3 5 * 99
      4 10 / 5
      5 2.7 + 10
   

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

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

   或者

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

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

      1 (3 * 5) + (10 - 6)
   

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

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

1.2. Naming and the Environment

1. (define size 2)

      1 size = 2
   

2. size
   2
   (* 5 size)
   10

      1 size
      2 5 * size
   

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

      1 pi = 3.14159
      2 radius = 10
      3 pi * (radius * radius)
      4 circumference = 2 * pi * radius
      5 circumference
   

1.3. Evaluating Combinations

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

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

1.4. Compound Procedures

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

      1 square = lambda x: x*x
   

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

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

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

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

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

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

1.5. The Substitution Model for Procedure Application

1.6. Conditional Expressions and Predicates

1.7. Example: Square Roots by Newton's Method

1.8. Procedures as Black-Box Abstractions

2. Procedures and the Processes They Generate

• 1.2.1 Linear Recursion and Iteration 1.2.2 Tree Recursion 1.2.3 Orders of Growth 1.2.4 Exponentiation 1.2.5 Greatest Common Divisors 1.2.6 Example: Testing for Primality

• 1.3 Formulating Abstractions with Higher-Order Procedures
  • 1.3.1 Procedures as Arguments 1.3.2 Constructing Procedures Using Lambda 1.3.3 Procedures as General Methods 1.3.4 Procedures as Returned Values