Python程序设计与算法思维（2021版）课后答案

第 1 章

1. 计算机使用二进制数，因为如果它们只需要区分两种电气状态，就更容易可靠地构建电子设备。
2. 6 = 110
3. 44 = 101100
4. 72 = 1001000
5. 131 = 10000011
6. 100 = 4
7. 1011 = 11
8. 101010 = 42
9. 1001110 = 78
10. 制作饼干面糊：
    • 混合干配料。
    • 奶油黄油和糖。
    • 打入鸡蛋。
    • 搅拌干配料。
11. 烘烤饼干：
    • 将烤箱设置为适当的温度。
    • 设置计时器。
    • 将饼干放入烤箱。
    • 让饼干烘烤。
12. 添加糖霜和洒水：
    • 混合糖霜的配料。
    • 撒上糖霜，撒在饼干上。
13. 显示的合法标识符为 、 、 和 。printedannual_salaryabcsum_of_datab4
14. c.print("Hello, world!")

15. 语句输出：

    "Quotes"
    Slashes \//
    How '"confounding' "\" it is!
    

16. 语句输出：

    name    age     height
    Archie  17      5'9"
    Betty   17      5'6"
    Jughead 16      6'
    

17. 语句输出：

    Shaq is 7'1
    The string "" is an empty message.
    \'""
    

18. 语句输出：

        a   b   c"
    \\
    "
    '''
    C:
    in  he downward spiral
    

19. 语句输出：

    Dear "DoubleSlash" magazine,
    
        Your publication confuses me.  Is it
    a \\ slash or a  slash?
    
    Sincerely,
    Susan "Suzy" Smith
    

20. print语句以生成所需的输出：

    print("\"Several slashes are sometimes seen,\"")
    print("said Sally. \"I've said so.\" See?")
    print("\\ / \\\\ // \\\\\\ ///")
    

21. print语句以生成所需的输出：

    print("This is a test of your")
    print('knowledge of "quotes" used')
    print("in 'string literals.'")
    print()
    print("You're bound to \"get it right\"")
    print("if you read the section on")
    print("''quotes.''")
    

22. print语句以生成所需的输出：

    print("/ \\ // \\\\ /// \\\\\\")
    

23. 程序中的错误：

    1. 第 1 行：关键字丢失。def
    2. 第 2 行：缺少结束。)
    3. 第3行：括号内的文本应用引号引起来。

24. 程序中的错误：

    1. 第 2 行：应缩进。
    2. 第 3 行：应缩进。
    3. 第 3 行：缺少结束标记。"
25. 一个。def example():

26. 程序输出：

    This is message1.
    This is message2.
    This is message1.
    Done with message2.
    Done with main.
            

27. 程序输出：

    Inside first function
    Inside third function
    Inside first function
    Inside second function
    Inside first function
    Inside second function
    Inside first function
    Inside third function
    Inside first function
    Inside second function
    Inside first function
            

28. 程序输出：

    Inside first function
    Inside first function
    Inside second function
    Inside first function
    Inside third function
    Inside second function
    Inside first function
    Inside first function
    Inside second function
    Inside first function
    Inside third function
            

29. 程序输出：

    Inside second function
    Inside first function
    Inside first function
    Inside second function
    Inside first function
    Inside third function
    Inside first function
    Inside second function
    Inside first function
            

30. 程序中的错误：

    1. 行 2：该行缩进一个太远。
    2. 第 2 行：括号的内容不在引号中。
    3. 第 3 行：函数调用拼写错误。
    4. 第 5 行：函数名称后缺少括号。
    5. 第 5 行：函数名称和括号后缺少 A。:
    6. 第 6 行：缺少结束。)
    7. 第 7 行：字符串内的 s 需要转义。"
    8. 第 7 行：该行不应包含 .;

---

第 2 章

1. 表达式的结果：

   1. 8
   2. 11
   3. 6
   4. 4
   5. 33
   6. -16
   7. 6.4
   8. 6
   9. 30
   10. 1
   11. -1
   12. 5.0
   13. 2
   14. 18
   15. 3
   16. 4
   17. 4
   18. 15
   19. 8
   20. 1

2. 表达式的结果：

   1. 9.0
   2. 9.6
   3. 2.0
   4. 6.0
   5. 6.0
   6. 8.0
   7. 1.25
   8. 3.0
   9. 3.0
   10. 3.0
   11. 5.0
   12. 6.4
   13. 37.0
   14. 8.5
   15. 9.6
   16. 4.0
   17. 4.8
   18. 25.5
3. e.grade = 4.0
4. 最后一位数字：number % 10

5. 程序中的错误：

   1. 第 3 行：应该在 和 之间有一个 。,is"x
   2. 第 6 行：应在引号之外。, x
   3. 第9行：应省略该词。int
   4. 第 11 行：单词应用引号括起来。and
6. 倒数第二位：或(number % 100) // 10(number // 10) % 10
7. 倒数第三位：或(number % 1000) // 100(number // 100) % 10

8. 、 和 代码后面的 值：abc

               a: 6
               b: 9
               c: 16
               

9. 代码的值和代码之后的值：firstsecond

               first: 19
               second: 8
               

   代码交换变量和 的值。firstsecond

10. 重写的代码缩短版本：

    first = 8,
    second = 19
    first += second
    second = first - second
    first -= second
    

11. 、 和 代码后面的 值：ijk

    i: 4
    j: 2
    k: 1
    

12. 代码输出：

    46
    36
    23
    13
    

13. 使用变量来避免冗余表达式的程序版本：

    def main():
        # Calculate my pay at work, based on how many hours I worked each day
        total_hours = 4 + 5 + 8 + 4
        salary = 8.75
        pay = total_hours * salary
        tax_rate = 0.20
        taxes_owed = pay * tax_rate
                        
        print("My total hours worked:")
        print(total_hours)
        print("My hourly salary:")
        print("$" + str(salary))
        print("My total pay:")
        print(pay)
        print("My taxes owed:")
        print(taxes_owed)
    
    main()
    

14. def main():
        for i in range(1, 5):
            print("2 times", i, "=", (2 * i))
            
    main()
    

15. 2 * count
16. 15 * count - 11
17. -10 * count + 40
18. 4 * count - 11
19. -3 * count + 100

20. for i in range(1, 7):
        print(18 * i - 22)
    

21. 功能输出：odd_stuff

    4
    2
    1
    0
    

22. 回路输出：

    9 1
    7 2
    4 3
    0 4
    

23. 回路输出：

    +---+
    \   /
    /   \
    \   /
    /   \
    \   /
    /   \
    +---+
    

24. 回路输出：

    T-minus 5, 4, 3, 2, 1, Blastoff!
    

25. 循环输出：

    1 2 3 4 5 6 7 8 9 10 
    2 4 6 8 10 12 14 16 18 20 
    3 6 9 12 15 18 21 24 27 30 
    4 8 12 16 20 24 28 32 36 40 
    5 10 15 20 25 30 35 40 45 50
    

26. 循环输出：

    ****!****!****!
    ****!****!****!
    

27. 2 * line + 2 * SIZE
28. 4 * line + (3 * SIZE)
29. -line + (2 * SIZE + 3)

30. 输出表：

    线	\	!	/
    1	0	22	0
    2	2	18	2
    3	4	14	4
    4	6	10	6
    5	8	6	8
    6	10	2	10

    • expression for and : \/2 * line - 2
    • expression for : !-4 * line + 26

31. Table for output:

    line	\	!	/
    1	0	14	0
    2	2	10	2
    3	4	6	4
    4	6	2	6

    • expression for and : \/2 * line - 2
    • expression for : !-4 * line + 18
    • generalized for constant: -4 * line + (4 * SIZE + 2)

---

Chapter 3

1. 15 42
   10 25
   

2. 1 3 5 
   1 3 5 7 9 11 13 15 
   1 3 5 7 9 11 13 15 17 19 21 23 25 
   

3. 1 2 3 4 5 
   1 2 3 4 5 6 7 
   1 2 3 4 
   number = 8
   

4. whom and who like it
   it and him like whom
   whom and him like him
   stu and boo like who
   her and him like who
   

5. touch your eye to your head
   touch your head to your eye
   touch your shoulders to your elbow
   touch your eyes and ears to your eyes and ears
   touch your toes to your Toes
   touch your shoulders to your knees toes
   

6. say coke not pepsi or pop
   say soda not soda or pepsi
   say pepsi not koolaid or pop
   say say not pepsi or pepsi
   

7. def print_strings(s, n):
       for i in range(1, n + 1):
           print(s, end=" ")
       print()
   

8. The program changes the value of its parameter on line 9, but this doesn't affect the variable in . The (incorrect) output is: Temperaturetempctempcmain

   Body temp in C is: 0.0
   

9. results of expressions: math

   1. 1.6
   2. 2
   3. 36.0
   4. 64.0
   5. 10.0
   6. 116.0
   7. 7
   8. 5
   9. -5
   10. 8.0
   11. 11.0
   12. 102.0
   13. 17.0
   14. 20.0
   15. 13.0
   16. 14.0

10. Output of the program:

    3 0
    1 2 4
    4 3
    5 2 4
    8 1
    5 9 4
    

11. grade = 2.7
    math.round(grade)
                               # grade = 2.7
    grade = math.round(grade)
                               # grade = 3.0
    
    min = math.min(grade, math.floor(2.9))
                               # min = 2.0
    x = math.pow(2, 4)
                               # x = 16.0
    x = math.sqrt(64)
                               # x = 8.0
    count = 25
    math.sqrt(count)
                               # count = 25
    count = math.sqrt(count)
                               # count = 5
    
    a = math.abs(math.min(-1, -3))
                               # a = 3
    

12. def count_quarters(cents):
        return cents % 100 // 25
    

13. def main():
        age = int(input("How old are you?"))
        print("You have", (65 - age), "years until retirement.")
    
    main()
    

14. number = int(input("Type an integer: "))
    print(number, "times 2 =", (number * 2))
    

15. phrase = input("What is your phrase? ")
    times = int(input("How many times should I repeat it? "))
    for i in range(1, times + 1): 
        print(phrase)
    

16. 绘制矩形的正确语法：

    e.p.draw_rect(10, 20, 50, 30)

17. 代码中的错误：

    1. 在第二行，呼叫应该在 上进行，而不是在什么都没有。draw_lineDrawingPanelp
    2. 在第二行中，参数的顺序不正确。

    以下是更正后的代码：

    p = DrawingPanel(200, 200)
    p.draw_line(50, 86, 20, 35)
    

18. 黑色矩形正在第二次绘制，因此它覆盖了白色的内圈。以下代码修复了此问题：

    panel = DrawingPanel(200, 100)
    p.set_color("black") 
    p.fill_rect(10, 10, 50, 50)
    p.set_color("white")
    p.fill_oval(10, 10, 50, 50) 
    

19. 该程序绘制一系列逐渐变小的黑色圆圈，每个圆圈的右边缘和下边缘都触及窗口的右角和下角。它的输出如下所示：

    

---

第 4 章

1. 翻译成逻辑测试的英文陈述：

   1. z % 2 == 1
   2. z <= math.sqrt(y)
   3. y > 0
   4. x % 2 != y % 2
   5. y % z == 0
   6. z != 0
   7. abs(y) > abs(z)
   8. (x >= 0) == (z < 0)
   9. y % 10 == y
   10. z >= 0
   11. x % 2 == 0
   12. abs(x - y) < abs(z - y)

2. 关系表达式的结果：

   1. True
   2. False
   3. True
   4. False
   5. True
   6. False
   7. False
   8. True
   9. True

3. 程序中的错误：

   1. 第 5 行：应为 ，行应以冒号结尾===
   2. 第 5 行：此处超出范围（第 4 行应为smallersmaller = minimum(a, b)
   3. 第10行：应该是（或者更好的是，不需要测试）=>>=if

4. 调用输出：if_else_mystery_1

   叫	输出
   一个。if_else_mystery_1(3, 20)	13 21
   b.if_else_mystery_1(4, 5)	5 6
   c.if_else_mystery_1(5, 5)	6 5
   d.if_else_mystery_1(6, 10)	7 11

5. 调用输出：if_else_mystery_2

   叫	输出
   一个。if_else_mystery_2(10, 2)	10 6
   b.if_else_mystery_2(3, 8)	9 9
   c.if_else_mystery_1(4, 4)2	3 4
   d.if_else_mystery_2(10, 30)	29 30

6. 用于从用户读取整数的代码，然后打印该数字是否为偶数或其他数字：evenodd

   number = int(input("Type a number: "))
   if number % 2 == 0:
       print("even")
   else:
       print("odd")
   

7. 代码错误地打印出不可被 3 整除的偶数是奇数。这是因为该语句与嵌套最紧密的语句 （） 匹配，而不是与外部语句匹配。以下更改更正了此问题。elseifnumber % 3 == 0if

   if number % 2 == 0:
       if number % 3 == 0:
           print("Divisible by 6.")
   else:
       print("Odd.")
   

8. 重构代码以减少冗余：

   a = 2
   if x < 30:
       x += 1
   print("Python is awesome!", x)
   

9. 重构代码以减少冗余：

   times = int(input("Is your money multiplied 1 or 2 times? "))
   donation = int(input("And how much are you contributing? "))
   sums += times * donation
   total += donation
   
   if times == 1:
       count1 += 1
   elif times == 2:
       count2 += 1
   

   如果用户可以键入任何数字，则代码可能需要其他语句来递增正确的 count 变量。if

10. 读取红色/绿色/蓝色的代码：

    choice = input("What color do you want? ")
    if choice.lower() == "r":
        print("You have chosen Red.")
    elif choice.lower() == "g":
        print("You have chosen Green.")
    elif choice.lower() == "b":
        print("You have chosen Blue.")
    else:
        print("Unknown color:", choice)
    

11. 给定函数的问题在于变量需要在循环外部声明。以下代码修复了此问题：sum_tosumfor

    def sum_to(n):
        sums = 0
        for i in range(1, n + 1):
            sums += i
        return sums
    

12. 显示的函数不会返回正确的答案。它应该使用累积总和来计算因素;当它找到每个因子时，它不应该返回循环内。相反，它应该在循环外部声明一个计数器，该计数器随着每个因子的出现而递增。以下代码修复了此问题：count_factors

    def count_factors(n):
        count = 0
        for i in range(1, n + 1): 
            if n % i == 0:
                count += 1
        return count
    

13. 表达式等于而不是预期，因为舍入误差。6.8000000000000016.8

14. 表达式等于而不是预期，因为舍入误差。解决方法是测试该值是否接近而不是完全等于它，如以下代码所示：gpa * 39.6000000000000019.69.6

    gpa = 3.2
    diff = abs(gpa * 3 - 9.6)
    if diff < 0.1:
        print("You earned enough credits.")
    

15. 函数的前提条件是三个边长构成一个有效的三角形。即：print_triangle_type

    • 传递的所有三个边长均为 >= 0。
    • 任何边的长度都不会超过任何两条其他边的总和。

16. 该函数的前提条件是等级参数的值介于 0 和 100 之间。get_grade

17. 当 代码失败时是三个数字中的最小值;例如，当参数的值为 （4， 7， 2） 时，代码应返回 4，但返回 2。该方法可以正确编写为：median_of_3n3

    def median_of_3(n1, n2, n3):
        if n1 < n2 and n1 < n3:
            if n2 < n3:
                return n2
            else:
                return n3
        elif n2 < n1 and n2 < n3:
            if n1 < n3:
                return n1
            else:
                return n3
        else: # n3 < n1 and n3 < n2
            if n1 < n2:
                return n1
            else:
                return n2
    

    或以下较短版本：

    def median_of_3(n1, n2, n3):
        return max(max(min(n1, n2), min(n2, n3)), min(n1, n3))
    

18. 当多个数字是奇数时，代码将失败，因为它使用 而不是 。测试不应嵌套，因为它们不是相互排斥的;多个数字可能是奇数。以下代码修复了此问题：elifif

    def print_num_odd(n1, n2, n3):
        count = 0
        if n1 % 2 != 0:
            count += 1
        if n2 % 2 != 0:
            count += 1
        if n3 % 2 != 0:
            count += 1
        print(count, "of the 3 numbers are odd.")
    

    以下不带语句的版本也有效：if

    def print_num_odd(n1, n2, n3):
        count = n1 % 2 + n2 % 2 + n3 % 2
        print(count, "of the 3 numbers are odd.")
    

19. 程序输出：

    efg
    nopqrs
    
    qr
    

20. 测试字符串是否以大写字母开头的语句：

    if "A" <= the_string[0] <= "Z":
        ...
    

21. 以下表达式将生成所需的结果：

    name = "Marla Singer"
    space = name.find(" ")
    last_name = name[(space + 1) :]
    first_initial = name[0]
    last_name_first_initial = last_name + ", " + first_initial + "."
    print(last_name_first_initial)
    

    或者，您可以使用这个较短的版本：

    name = "Marla Singer"
    print(name[(name.find(" ") + 1):] + ", " + name[0] + ".")
    

22. 用于检查字符串并确定其字母数量来自字母表的后半部分（或以后）的代码：'n'

    # assuming that the string is stored in the variable s
    count = 0
    for ch in s.lower():
        if ch >= 'n':
            count += 1
    print(count, "letters come after n.")
    

---

第 5 章

1. 执行正文 10 次。输出为：

   1 11 21 31 41 51 61 71 81 91

2. 执行正文 0 次。无输出。
3. 无限循环。输出为：

   250
   250
   250
   ...
   

4. 执行正文 3 次。输出为：

   2 4 16

5. 执行正文 5 次。输出为：

   bbbbbabbbbb

6. 执行正文 7 次。输出为：

   10
   5
   2
   1
   0
   0
   0
   

7. n = 1
   while n <= maxs:
       print(n)
       n += 1
   

8. total = 25
   number = 1
   while number <= (total / 2):
       total = total - number
       print(total, number)
       number += 1
   

9. i = 1
   while i <= 2:
       j = 1
       while j <= 3:
           k = 1
           while k <= 4:
               print("*", end="")
               k += 1
           print("!", end="")
           j += 1
       print()
       i += 1
   

10. 调用输出：mystery

    叫	输出
    一个。mystery(1)	1 0
    b.mystery(6)	4 2
    c.mystery(19)	16 4
    d.mystery(39)	32 5
    e.mystery(74)	64 6

11. 调用输出：mystery

    叫	输出
    一个。mystery(19)	19 0
    b.mystery(42)	21 1
    c.mystery(48)	3 4
    d.mystery(40)	5 3
    e.mystery(64)	1 6

12. 生成介于 0 和 10 之间的随机整数（包括 0 和 10）的代码：

    import random
    num = random.randint(0, 10)
    

13. 生成介于 50 和 99 之间的随机奇数整数（包括 50 和 99）的代码。

    import random
    num = random.randint(25) * 2 + 51
    

14. 该代码有一个栅栏问题;它将在最后一个字母后打印一个破折号。下面的代码更正了此问题：print_letters

    def print_letters(text):
        if len(text) > 0:
            print(text[0], end="")
            for i in range(1, len(text)): 
                print("-" + text[i], end="")
            print()   # to end the line of output
    

15. 反复提示用户输入数字的 Sentinel 循环，并在键入数字后显示用户输入的最大和最小数字：-1

    SENTINEL = -1
    num = int(input("Type a number (or " + str(SENTINEL) + " to stop): "))
    mins = num
    maxs = num
    while num != SENTINEL:
        if num < mins:
            mins = num
        elif num > maxs:
            maxs = num
    
        num = int(input("Type a number (or " + str(SENTINEL) + " to stop): "))
        
    if mins != SENTINEL:
        print("Maximum was", maxs)
        print("Minimum was", mins)
    

16. 表达式的结果：boolean

    1. True
    2. True
    3. False
    4. True
    5. True
    6. False
    7. False
    8. True
    9. True
    10. True
    11. True
    12. False

17. def is_vowel(c):
        c = c.lower()  # case-insensitive
        return c == "a" or c == "e" or c == "i" or c == "o" or c == "u"
    

    艺术

    def is_vowel(c):
        return "aeiouAEIOU".find(c) >= 0
    

18. 在此代码中，布尔标志未正确使用，因为如果代码找到该数字的因子，则 将设置为 ，但在下一次通过循环时，如果下一个数字不是因子，则将再次重置为 。以下代码修复了此问题：is_primeprimeFalseprimeTue

    def is_prime(n):
        prime = True
        for i in range(2, n): 
            if n % i == 0:
                prime = False
        return prime
    

19. 使用布尔禅的代码的改进版本：start_end_same

    def start_end_same(string):
        return string[0] == string[-1]
    

20. 使用布尔禅的代码的改进版本：has_pennies

    def has_pennies(cents):
        return cents % 5 != 0
    

21. 调用输出：mystery

    叫	返回的值
    一个。mystery(3, 3)	3
    b.mystery(5, 3)	1
    c.mystery(2, 6)	2
    d.mystery(12, 18)	6
    e.mystery(30, 75)	15

22. 当当前日期是闰年结束时，Zune 代码将陷入无限循环。在闰年的 12 月 31 日，该值将为 366，因此代码进入语句但不输入语句。因此，循环不会减去任何天，也永远不会终止。可以通过向循环添加布尔标志来修复它：daysif is_leap_yearif days > 366

    days = get_total_days_since_1980()   
    year = 1980
    stop = False
    while days > 365 and not stop:   # subtract out years
        if is_leap_year(year):
            if days > 366:
                days -= 366
                year += 1
            else:               # new code here
                stop = True     # new code here
        else:
            days -= 365
            year += 1
    

23. 布尔表达式的否定：
    1. not b
    2. (x <= y) or (y <= z)
    3. (x != y) and (x > z)
    4. (x % 2 == 0) or not b
    5. (x // 2 != 13) and not b and (z * 3 != 96)
    6. (z >= x) or (z <= y and x < y)
24. 年龄/GPA 读取代码应重新转换为用户年龄的有效整数和用户 GPA 的有效实数。如果用户键入了错误类型的令牌，则应使用输入行并重新设置用户。下面的代码实现更正的行为：

    success = False
    while not success:
        age = input("Type your age: ") 
        try:
            age = int(age)
            success = True
        except ValueError:
            print("Not an integer; try again.")
            
    success = False
    while not success:
        gpa = input("Type your GPA: ") 
        try:
            gpa = float(gpa)
            success = True
        except ValueError:
            print("Not a float; try again.")
    
    print("age =", age, " GPA = ", gpa)
    

25. 编写提示输入三个整数的代码，对它们求平均值，然后打印平均值;对无效输入的鲁棒性：

    prompt = "Please enter a number: "
    num1 = get_int(prompt)
    num2 = get_int(prompt)
    num3 = get_int(prompt)
    average = (num1 + num2 + num3) / 3.0
    print("Average:", average)
    

26. B点

    点	y < x	y == 0	count > 0
    点 A	有时	有时	从不
    总是	有时	有时
    C点	总是	总是	总是
    点 D	有时	有时	有时
    E点	从不	有时	有时

27. B点

    点	n > b	a > 1	b > a
    点 A	有时	有时	有时
    总是	有时	有时
    C点	有时	总是	总是
    点 D	有时	总是	从不
    E点	从不	有时	有时

28. 点	next == 0	prev == 0	next == prev
    点 A	有时	总是	有时
    B点	从不	有时	有时
    C点	从不	从不	总是
    点 D	有时	从不	有时
    E点	总是	有时	有时

---

第 6 章

1. 文件是存储在计算机上的信息的命名集合。我们可以通过打开文件，然后使用 or 方法读取文件：readreadlines

   with open("input.txt") as file:
       lines = name.readlines()
   

2. with open("input.txt") as file:
       lines = name.readlines()
   

3. 返回的呼叫：split

   c.["welcome...to", "the", "matrix."]

4. 返回的呼叫：split

   b.["in", "fourteen-hundred", "92", "columbus", "sailed", "the", "ocean", "blue", ":)"]
5. "numbers.dat"或"C:/Users/yana/Documents/programs/numbers.dat"
6. "data/homework6/input.dat"或"C:/Users/yana/Documents/programs/data/homework6/input.dat"
7. 只有一种合法的方式来引用此文件：通过其绝对路径，"C:/Users/yana/Documents/homework/data.txt"
8. "names.txt"或"/home/yana/Documents/hw6/names.txt"
9. "data/numbers.txt"或"/home/yana/Documents/hw6/data/numbers.txt"
10. 只有一种合法的方式来引用此文件：通过其绝对路径，"/home/yana/download/saved.html"

11. 将生成以下输出：

    input: 6.7        This file has
    input:         several input lines.
    input: 
    input:   10 20         30   40
    input: 
    input: test
    6 total
    

12. 如果 和 使用时产生的输出：readlinessplit

    input: 6.7
    input: This
    input: file
    input: has
    input: several
    input: input
    input: lines.
    input: 
    input: 10
    input: 20
    input: 30
    input: 40
    input: 
    input: test
    14 total
    

13. 将自身打印为输出的程序：

    def main():
        with open("input.txt") as file:
            lines = file.readlines()
            for line in lines:
                print(line.strip())
    
    main()
    

14. 提示用户输入文件名并将该文件的内容作为输出输出到控制台的代码：

    def print_entire_file():
        file_name = input("Type a file name: ")
        with open(file_name) as file:
            lines = file.readlines()
            for line in lines:
                print(line.strip())
    

15. 将文本行作为输入行并生成框内相同文本作为输出的程序：

    # precondition: no line in input is longer than width
    def print_box(lines, width):
        print_top_bottom(width)
        for line in lines:
            spaces = width - len(line.strip())
            print("| " + line.strip() + (" " * spaces) + " |")
        print_top_bottom(width)
    
    def print_top_bottom(width):
        print("+", end="")
        for i in range(0, width + 2): 
            print("-", end="")
        print("+")
    

16. 将以下四行文本打印到名为 的文件中的代码：message.txt

    with open("message.txt", "w") as my_file:
        print("Testing,", file=my_file)
        print("1, 2, 3.", file=my_file)
        print("", file=my_file)
        print("This is my output file.", file=my_file)
    

17. 反复提示用户输入文件名直到用户键入系统上存在的文件名的代码。

    import os.path
    
    def get_file_name():
        file_name = ""
        while not os.path.isfile(file_name):
            file_name = input("Type a file name: ")
        return file_name
    

18. 调用 之前使用的代码：get_file_nameprint_entire_file

    # reprompts until file name is valid
    def print_entire_file_2():
        file_name = get_file_name()
        with open(file_name) as file:
            lines = file.readlines()
            for line in lines:
                print(line.strip())
    

---

第 7 章

1. 第一个元素：numbers[0]
2. 最后一个元素：或 或 或numbers[9]numbers[len(numbers) - 1]numbers[-1]

3. data = [27, 51, 33, -1, 101]
   

4. 使用循环将 -6 和 38 之间的所有奇数存储到数组中的代码：

   odds = [0] * 22
   for i in range(len(odds)): 
       odds[i] = i * 2 - 5
   

5. 执行代码后，列表包含以下元素值：numbers

   [0, 4, 11, 0, 44, 0, 0, 2]
   

6. 执行代码后，列表包含以下元素值：data

   [3, 3, 0, 0, 6, 9, 0, -18]
   

7. data = [7, -1, 13, 24, 6]
   

8. letters[:2]
9. letters[3:4]
10. letters[3:]
11. letters[:3:-1]
12. letters[1::2]

13. def maximum(data):
        maxs = data[0]
        for i in range(1, len(data)): 
            if data[i] > maxs:
                maxs = data[i]
        return maxs
    

14. def average(a):
        mean = 0.0
        for i in range(0, len(a)): 
            mean += a[i]
        return mean / len(a)
    

15. data[3:3] = ["dark", "and"]
16. data[1] = "IS"

17. i = 0
    while i < len(data):
        if "a" in data[i]:
            data.pop(i)
        else:
            i += 1
    

18. 列表遍历是对列表的每个元素的顺序处理。可以通过这种方式解决的问题包括打印列表、比较两个列表的相等性以及在列表中搜索给定值。

19. 使用循环打印名为 的列表的每个元素的代码：fordata

    for i in range(len(data)): 
        print("element [", i, "] is", data[i])
    

20. 执行代码后，数组包含以下元素值：list

    [3, 24, 8, -6, 6, 1]
    

21. [1, 2, 6, 8]
22. [10, 30, 40, 20, 60, 50]
23. [-4, 1, 25, 4, 16, 9, 64, 36, 49]
24. [20, 10, 20, 30, 30, 20]
25. [8, 7, 8, 2, 9, 7, 4, 4, 2, 8]
26. [33, 28, 33, -1, 3, 28, 17, 9, 33, 17, -1, 33]

27. def all_less(list1, list2):
        if len(list1) != len(list2):
            return False
        for i in range(len(list1)): 
            if list1[i] >= list2[i]:
                return False
        return True
    

28. 执行代码后，列表包含以下元素值：numbers

    [20, 30, 40, 50, 60, 70, 80, 90, 100, 100]
    

29. 执行代码后，列表包含以下元素值：numbers

    [10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
    

30. 执行函数后，列表包含以下元素值：mysterya1

    [26, 19, 14, 11, 10]
    

31. 执行函数后，列表包含以下元素值：mystery2numbers

    [7, 3, 1, 0, 25, 4, 18, -1, 5]
    

32. 函数调用的结果：mystery3

    1. 0
    2. 9
    3. 6
    4. 8
    5. 2

33. def average_length(strings):
        sums = 0
        for i in range(len(strings)): 
            sums += len(strings[i])
        return sums / len(strings)
    

34. def is_palindrome(lis):
        for i in range(len(lis) // 2): 
            if lis[i] != lis[len(lis) - 1 - i]:
                return False
        return True
    

35. [s[0].upper() for s in letters]
36. [s + s for s in letters]
37. [(s, s[0]) for s in letters]

38. 程序输出：

    2 [0, 0, 1, 0]
    1 [0, 0, 1, 0]
    3 [0, 0, 1, 1]
    2 [0, 0, 1, 1]
    

39. 程序输出：

    2 [0, 1]
    1 [0, 1]
    1 [1, 2]
    0 [1, 2]
    

40. def swap_pairs(lis):
        for i in range(0, len(lis), 2): 
            swap(lis, i, i + 1)
    

41. 这四个错误是：
    1. 在第 2 行中，不能通过将 1 添加到元组的某个元素来修改元组的值。
    2. 在第 4 行，不能调用元组。append
    3. 在第 6 行上，不能调用元组。reverse
    4. 在第 9 行，不能调用元组。clear

42. def nearest_points(points):
        min_dist = 0
        for i in range(len(points)):
            for j in range(i + 1, len(points)):
                dist = distance(points[i], points[j])
                if min_dist == 0 or dist < min_dist:
                    min_dist = dist
        return min_dist
        
    def distance(p1, p2):
        dx = p2[0] - p1[0]
        dy = p2[1] - p1[1]
        return math.sqrt(dx * dx + dy * dy)
    

43. 执行代码后，列表包含以下元素值：numbers

    [[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
    

44. 循环初始化 的第三行以存储数字 1 到 7：data

    for i in range(7): 
        data[2][i] = i + 1
    

45. 构造包含 5 行和 10 列的整数二维列表的代码，该列表由乘法表填充：

    table = []
    for i in range(5):
        table.append([0] * 10)
    for i in range(5): 
        for j in range(10): 
            table[i][j] = i * j
    

46. 循环将第二列的内容复制到第五列：

    for i in range(6): 
        matrix[i][4] = matrix[i][1]
    

47. 执行函数后，列表包含以下元素值：mystery2dnumbers

    [[4, 5, 6, 6], [5, 6, 7, 7], [6, 7, 8, 8]]
    

48. jagged = []
    value = 1
    for i in range(5):
        jagged.append([0] * (i + 1))
        for j in range(i + 1):
            jagged[i][j] = value
            value += 1
    

49. 像素列表尺寸（待办事项）
50. to_red_channel（待办事项）

---

第 8 章

1. 您可以使用 for-each 循环检查字典的每个元素。您可以使用关键字检查键是否在字典中。in

2. 如果您尝试将键/值对添加到字典中，并且它已经具有具有相同键的对，则旧对将被新对替换。如果它已经有一对具有相同值，但不具有相同的键，则添加新对而不删除旧对。

3. 您可以通过将键传递给函数来按排序顺序循环访问字典的键。sorted

4. 用于声明将人们的姓名与其年龄相关联的字典的代码：

   ages = {}
   ages["Stuart"] = 85
   ages["Marty"] = 12
   ages["Allison"] = 25
   

   艺术

   ages = {"Stuart": 85, "Marty": 12, "Allison": 25}
   

5. 代码执行后字典中包含的键和值：

   {17: 'Steve', 34: 'Louann', 5: 'Moshe', 27: 'Donald', 2350: 'Orlando', 15: 'Moshe'}
   

6. 代码执行后字典中包含的键和值：

   {132: 'OneThreeTwo', 8: 'Ocho', 9828: 'Ninety-eight18', 8650: 'Eighty-sixForty-one', 50: 'Fifty', 79: 'Seventy-nine'}
   

7. 传递每个字典的方法时生成的输出：mystery

   1. {'one': 'un', 'four': 'quatre', 'deux': 'two', 'cinq': 'five', 'three': 'trois'}
   2. {'computer': 'program', 'car': 'drive', 'board': 'skate'}
   3. {'begin': 'ready', 'boy': 'girl', 'first': 'last', 'ebert': 'siskel', 'H': 'T'}
   4. {'cotton': 'rain', 'light': 'tree', 'tree': 'violin', 'seed': 'tree'}

8. 传递每对字典时传递函数时返回的结果：mystery

   1. {'mumble': 'fire', 'baz': 'wind', 'bar': 'earth', 'foo': 'air'}
   2. {'one': 'dos', 'five': 'quatro', 'three': 'tres'}
   3. {'c': 'seven', 'g': 'seven', 'b': 'years', 'e': 'ago'}

9. 传递每个列表时传递函数时返回的结果：mystery

   1. {1: [1], 2: [1, 1], 3: [], 4: [1], 34: [], 14: []}
   2. {1: [1, 1, 1], 2: [1, 1], 4: [1, 1]}
   3. {43: [1], 44: [], 45: [1, 1], 54: [1]}

10. 传递每个字典的函数时返回的结果：mystery

    1. {3: {'and'}, 4: {'hello', 'world'}}
    2. {1: {'banana', 'kiwi'}, 2: {'peach'}, 3: {'apple', 'nectarine'}}
    3. {'the': {'is', 'has'}, 'and': {'the', 'and'}}
11. start_letters待办事项
12. dict_comprehensions待办事项

13. 如果要避免重复或希望能够快速搜索集合，则应使用集合而不是列表。

14. 您可以使用 for-each 循环检查集合中的每个元素。

15. 您可以使用关键字检查值是否包含在集中。in

16. 代码执行后，该集包含以下元素（按某种顺序）：

    {32, 18274, 18212, 9, 12, 29999, 9074}
    

17. 代码执行后，该集包含以下元素（按某种顺序）：

    {4, 42, 11, 12, 84, 247, 94}
    

18. 要执行并集，请使用 创建一个新集，其中包含两个集中的所有项目。要执行交集，请使用 创建一个新集，其中两个集中只有项目。set1 | set2set1 & set2

19. 要找到所有不饿、年老或贫穷或两者兼而有之的男人：(male - hungry) & (old | poor)

20. 传递每个列表时生成的函数：mystery
    1. {'jessica', 'amanda', 'helene'}
    2. {'riley'}
    3. {'charlie', 'phil', 'alex', 'roy', 'tyler'}

---

第 9 章

1. 递归是一种技术，其中算法以其自身来表示。递归函数与常规函数的不同之处在于，它在其主体中包含对自身的一个或多个调用。

2. 基本情况是递归函数不需要进行递归调用来解决问题的情况。递归情况是递归函数调用自身的情况。递归函数需要这两种情况，因为递归情况被重复调用，直到达到基本情况，从而停止递归调用链。

3. 每次调用时函数生成的输出：mystery1

   1. 1
   2. 1, 2
   3. 1, 3
   4. 1, 2, 4
   5. 1, 2, 4, 8, 16
   6. 1, 3, 7, 15, 30
   7. 1, 3, 6, 12, 25, 50, 100

4. 每次调用时函数生成的输出：mystery2

   1. 113
   2. 140, 70
   3. 168, 84, 42
   4. 120, 60, 30
   5. 160, 80, 40, 20, 10

5. 每次调用时函数生成的输出：mystery_x_y

   1. 4
   2. 8, 4, 8
   3. 16, 8, 16
   4. 12, 8, 4, 8, 12
   5. 12, 9, 6, 3, 6, 9, 12

6. 函数的递归版本：double_reverse

   def double_reverse(s):
       if len(s) > 0:
           last = s[-1]
           print(last, end="")
           print(last, end="")
           double_reverse(s[0:-1])
   

7. 所示函数的版本没有任何基本情况，因此递归调用永远不会停止。可以通过添加不进行递归调用的检查来修复它。powy == 0

8. 该函数的第二个版本比第一个版本更有效，因为它需要较少的递归调用。这两个版本都是递归的。pow

9. 函数为每次调用返回的值：mystery4

   1. 6
   2. 4
   3. 7
   4. 0
   5. 1

10. 方法为每个调用返回的值：mystery5

    1. 57
    2. 1029
    3. -74
    4. 2438
    5. 132483

11. 函数的递归版本：factorial

    def factorial(n):
        if n == 0:
            return 1
        else:
            return n * factorial(n - 1)
    

12. 基本情况陈述有一个错误：它应该测试小于10的数字，而不是大于10。以下是正确的行：if

    if n < 10:
    

13. 当递归所需的参数与客户端要传递的参数不匹配时，请使用具有客户端所需签名的函数和具有递归所需签名的帮助器函数。

14. 以下版本的代码提高了效率：fibonacci

    def fibonacci(n):
        if n <= 2:
            return 1
        else:
            return fibonacci2(n, 3, 1, 1)
    
    def fibonacci2(n, i, prev, curr):
        if n == i:
            return prev + curr
        else:
            return fibonacci2(n, i + 1, curr, prev + curr)
    

15. 分形是递归构造以包含自身较小版本的图像。递归函数在绘制分形图像时很有用，因为它们可以优雅地表达图像的递归性质。

16. 用于创建和绘制正六边形的代码：

    def draw_hexagon(panel, x, y, size):
        p1 = (x, y + size // 2)
        p2 = (x + size // 3, y)
        p3 = (x + 2 * size // 3, y)
        p4 = (x + size, y + size // 2)
        p5 = (x + 2 * size // 3, y + size)
        p5 = (x + size // 3, y + size)
        panel.fill_polygon(p1, p2, p3, p4, p5)
    

17. 递归是实现回溯算法的有效方法，因为决策的记忆和要返回的点由递归调用堆栈表示。“选择，探索，取消选择”的模式由每个单独选择的递归调用优雅地表示。

18. 决策树是对递归回溯函数在算法中任何一点可以做出的选择集的描述。

19. 如果回溯解决方案在递归函数中首先而不是最后一个探索了 NE，则（1， 2）的路径的图将得出的决策树：explore

    start (0, 0)
    |
    +--- NE (1, 1)
    |    |
    |    +--- NE NE (2, 2)
    |    |
    |    +--- NE N (1, 2) - output
    |    |
    |    +--- NE E (2, 1)
    |
    +--- N (0, 1)
    |    |
    |    +--- N NE (1, 2) - output
    |    |
    |    +--- N N (0, 2)
    |    |    |
    |    |    +--- N N NE (1, 3)
    |    |    |
    |    |    +--- N N N (0, 3)
    |    |    |
    |    |    +--- N N E (1, 2) - output
    |    |
    |    +--- N E (1, 1)
    |         |
    |         +--- N E NE (2, 2)
    |         |
    |         +--- N E N (1, 2) - output
    |         |
    |         +--- N E E (2, 1)
    |
    +--- E (1, 0)
         |
         +--- E NE (2, 1)
         |
         +--- E N (1, 1)
         |    |
         |    +--- E N NE (2, 2)
         |    |
         |    +--- E N N (1, 2) - output
         |    |
         |    +--- E N E (2, 1)
         |
         +--- E E (2, 0)
    

20. 如果解决方案首先而不是最后探索 NE，则解决方案将按以下顺序打印：

    moves: NE N
    moves: N NE
    moves: N N E
    moves: N E N
    moves: E N N
    

21. 在整棵树的第二层有 64 个条目。在整棵树的第三层有 512 个条目。

22. 如果我们的 8 Queens 算法尝试了棋盘上每个可能的方块来放置每个女王，那么在整棵树的第 8 层也是最后一级，将有 （64*63*62*61*60*59*58*57） = 178，462，987，637，760 个条目。我们的算法通过在电路板的每一列中只放置一个女王来避免如此大量的选择。

23. 8 Queens 函数在找到问题解决方案后停止。这是因为代码在其递归调用周围具有以下行：explore

    if explore(b, col + 1):
        return True
    

    可以修改代码，以便通过将代码更改为以下内容来查找并输出问题的每个解决方案：

    explore(b, col + 1)
    

    并将基本情况更改为以下内容：

    if col > len(b):
        print("One solution is as follows:")
        b.print() 
        return True
    

---

第 10 章

1. 可以使用循环对列表执行顺序搜索，也可以使用 对列表进行排序，然后使用 对列表执行二进制搜索。sortbisect.bisect_left

2. 最接近二进制搜索算法需要在一百万个整数列表中检查的元素数的值：

   e. 小于 1%（10，000 或更少）

3. 如果对列表进行排序，则应使用二进制搜索。否则，您将不得不使用顺序搜索。

4. O（日志 N）

5. O（N）

6. O（N2)

7. O（N2)

8. 给定算法的复杂度类，以 N 为单位：

   1. O（N）
   2. O（N2)
   3. O（N）
   4. O（N）
   5. O（N）
   6. O（1）

9. 给定语句的复杂性类：

   1. O（N 对数 N）
   2. O（N2)
   3. O（N2 对数 N）
   4. O（N）
   5. O（N^4）
   6. O（N）
   7. 哎呀！）

10. 两个顺序搜索的运行时复杂性均为 O（N）。

11. 二进制搜索需要排序的数据集，因为它使用排序跳转到下一个索引。如果元素无序，则不能保证搜索找到目标元素。

12. 对 60 个元素的二进制搜索最多检查 6 个元素，因为 log2 60（四舍五入时）等于 6。

13. 该算法将检查索引 4 并返回 4。
14. 该算法将检查索引 4 和 6，并将返回 6。
15. 该算法将检查索引 4、6 和 7，并将返回 7。
16. 该算法将检查索引 4、2、1 和 0，并将返回 0。

17. 该算法将检查索引 4、6 和 5，并将返回 -1。该算法无法正常工作，因为输入数组未排序。

18. 二进制搜索算法将检查以下索引，并为每个搜索返回以下值：

    1. -5： 检查 6， 2， 4， 3;返回 -4
    2. 0： 检查 6;返回 6
    3. 11： 检查 6， 10， 8， 9;返回 -10
    4. -100： 检查 6， 2， 0;返回 -1

19. 在选择排序算法的一次传递（单个交换）之后，列表的状态为：

    d.[-4, 17, 3, 94, 46, 8, 29, 12]

20. 选择排序算法的所有步骤：

    1. [29, 17, 3, 94, 46, 8, -4, 12]
       [-4, 17, 3, 94, 46, 8, 29, 12]
       [-4, 3, 17, 94, 46, 8, 29, 12]
       [-4, 3, 8, 94, 46, 17, 29, 12]
       [-4, 3, 8, 12, 46, 17, 29, 94]
       [-4, 3, 8, 12, 17, 46, 29, 94]
       [-4, 3, 8, 12, 17, 29, 46, 94]
       

    2. [33, 14, 3, 95, 47, 9, -42, 13]
       [-42, 14, 3, 95, 47, 9, 33, 13]
       [-42, 3, 14, 95, 47, 9, 33, 13]
       [-42, 3, 9, 95, 47, 14, 33, 13]
       [-42, 3, 9, 13, 47, 14, 33, 95]
       [-42, 3, 9, 13, 14, 47, 33, 95]
       [-42, 3, 9, 13, 14, 33, 47, 95]
       

    3. [7, 1, 6, 12, -3, 8, 4, 21, 2, 30, -1, 9]
       [-3, 1, 6, 12, 7, 8, 4, 21, 2, 30, -1, 9]
       [-3, -1, 6, 12, 7, 8, 4, 21, 2, 30, 1, 9]
       [-3, -1, 1, 12, 7, 8, 4, 21, 2, 30, 6, 9]
       [-3, -1, 1, 2, 7, 8, 4, 21, 12, 30, 6, 9]
       [-3, -1, 1, 2, 4, 8, 7, 21, 12, 30, 6, 9]
       [-3, -1, 1, 2, 4, 6, 7, 21, 12, 30, 8, 9]
       [-3, -1, 1, 2, 4, 6, 7, 21, 12, 30, 8, 9]
       [-3, -1, 1, 2, 4, 6, 7, 8, 12, 30, 21, 9]
       [-3, -1, 1, 2, 4, 6, 7, 8, 9, 30, 21, 12]
       [-3, -1, 1, 2, 4, 6, 7, 8, 9, 12, 21, 30]
       

    4. [6, 7, 4, 8, 11, 1, 10, 3, 5, 9]
       [1, 7, 4, 8, 11, 6, 10, 3, 5, 9]
       [1, 3, 4, 8, 11, 6, 10, 7, 5, 9]
       [1, 3, 4, 8, 11, 6, 10, 7, 5, 9]
       [1, 3, 4, 5, 11, 6, 10, 7, 8, 9]
       [1, 3, 4, 5, 6, 11, 10, 7, 8, 9]
       [1, 3, 4, 5, 6, 7, 10, 11, 8, 9]
       [1, 3, 4, 5, 6, 7, 8, 11, 10, 9]
       [1, 3, 4, 5, 6, 7, 8, 9, 10, 11]
       

21. 合并 32 个元素将生成总共 63 个调用，并将执行该操作 31 次。merge_sortmerge

22. 元素在选择排序的最外层循环的五次传递后的状态已经发生：

    [1, 2, 3, 4, 5, 11, 9, 7, 8, 10]
    

23. 跟踪合并排序算法：

    [7,   2,   8,   4,   1,   11,   9,   5,   3,   10]
    [7,   2,   8,   4,   1], [11,   9,   5,   3,   10]
    [7,   2], [8,   4,   1], [11,   9], [5,   3,   10] 
    [7], [2], [8], [4,   1], [11], [9], [5], [3,   10]
                   [4], [1],                 [3], [10]
              [8], [1,   4],            [5], [3,   10]
    [2,   7], [1,   4,   8], [9,   11], [3,   5,   10]
    [1,   2,   4,   7,   8], [3,    5,   9,  10,   11]
    [1,   2,   3,   4,   5,   7,    8,   9,  10,   11]
    

24. 元素在选择排序的最外层循环的五次传递后的状态已经发生：

    [-3, -1, 1, 2, 4, 8, 7, 21, 12, 30, 6, 9]
    

25. 跟踪合并排序算法：

    [7,   1,   6,   12,   -3,   8,    4,   21,   2,   30,   -1,   9]
    [7,   1,   6,   12,   -3,   8],  [4,   21,   2,   30,   -1,   9]
    [7,   1,   6], [12,   -3,   8],  [4,   21,   2], [30,   -1,   9]
    [7], [1,   6], [12], [-3,   8],  [4], [21,   2], [30], [-1,   9]
         [1], [6],       [-3], [8],       [21], [2],       [-1], [9]
    [7], [1,   6], [12], [-3,   8],  [4], [2,   21], [30], [-1,   9]
    [1,   6,   7], [-3,    8,  12],  [2,   4,   21], [-1,    9,  30]
    [-3,  1,   6,    7,    8,  12], [-1,   2,    4,    9,   21,  30]
    [-3, -1,   1,    2,    4,   6,    7,   8,    9,   12,   21,  30]
    

26. 以下关于排序和大哦的陈述是正确的：

    b.合并排序通过在每个步骤中将列表分成两半，然后递归地排序并将两半合并在一起来实现 O（N log N） 运行时。

27. 合并排序算法的痕迹：

    1. [29, 17, 3, 94, 46, 8, -4, 12]
       [29, 17, 3, 94], [46, 8, -4, 12]
       [29, 17], [3, 94], [46, 8], [-4, 12]
       [29], [17], [3], [94], [46], [8], [-4], [12]
       [17, 29], [3, 94], [8, 46], [-4, 12]
       [3, 17, 29, 94], [-4, 8, 12, 46]
       [-4, 3, 8, 12, 17, 29, 46, 94]
       

    2. [6, 5, 3, 7, 1, 8, 4, 2]
       [6, 5, 3, 7], [1, 8, 4, 2]
       [6, 5], [3, 7], [1, 8], [4, 2]
       [6], [5], [3], [7], [1], [8], [4], [2]
       [5, 6], [3, 7], [1, 8], [2, 4]
       [3, 5, 6, 7], [1, 2, 4, 8]
       [1, 2, 3, 4, 5, 6, 7, 8]
       

    3. [33, 14, 3, 95, 47, 9, -42, 13]
       [33, 14, 3, 95], [47, 9, -42, 13]
       [33, 14], [3, 95], [47, 9], [-42, 13]
       [33], [14], [3], [95], [47], [9], [-42], [13]
       [14, 33], [3, 95], [9, 47], [-42, 13]
       [14, 33], [3, 95], [9, 47], [-42, 13]
       [3, 14, 33, 95], [-42, 9, 13, 47]
       [-42, 3, 9, 13, 14, 33, 47, 95]
       

---

第 11 章

1. 过程编程将程序视为要执行的一系列操作或命令。面向对象编程将程序视为一组名为对象的交互实体，每个实体都跟踪相关数据和行为。

2. 对象是封装数据和对数据进行操作的行为的实体。类是一类对象的蓝图，用于指定对象将具有的数据和行为以及如何构造它。

3. 程序输出：

   14 14
   7 9 14 2
   18 18
   7 9 14 18
   

4. 对象的状态可能包括刚刚计算的数字，以及当前正在输入的另一个数字。更复杂的对象还可能包括存储附加值的内存功能。对象的行为可能包括加法、减法、乘法、除法以及执行其他数学运算（如幂、对数和三角函数，如正弦和余弦）的方法。CalculatorCalculatorCalculator

5. 属性是存在于对象内部的变量。参数是方法内部的变量，其值是从外部传入的。属性具有不同的语法，因为它们是在类的顶部声明的，而不是在方法的标头中声明的。属性的作用域位于整个类中，而参数的作用域仅限于方法。

6. Name表示人名的类：

   # A Name object represents a name such as "John Q. Public".
   # This version contains only data attributes and a constructor.
   class Name:
       def __init__(self, first, middle, last):
           self.first_name = first
           self.middle_initial = middle
           self.last_name = last
   

7. 访问器为客户端提供对对象中某些数据的访问权限，而赋值器允许客户端以某种方式更改对象的状态。访问者的名称通常以“get”或“is”开头，而突变者的名称通常以“set”开头。

8. 在对象上调用方法的正确语法：compute_interestBankAccount

   d.result = acct.compute_interest(42)

9. Name类，有两种方法：

   # A Name object represents a name such as "John Q. Public".
   # This version adds the methods get_normal_order and get_reverse_order.
   class Name:
       def __init__(self, first, middle, last):
           self.first_name = first
           self.middle_initial = middle
           self.last_name = last
   
       # The name in normal order such as "John Q. Public".
       def get_normal_order(self):
           return self.first_name + " " + self.middle_initial + ". " + self.last_name
   
       # The name in reverse order such as "Public, John Q.".
       def get_reverse_order(self):
           return self.last_name + ", " + self.first_name + " " + self.middle_initial + "."
   

10. 若要使类的对象可打印，请在其中定义一个方法。__str__

11. 该语句等效于以下内容：print

    c.print(d1.__str__())

12. __str__类的方法：Name

    # Returns a string representation of this Name, such as "John Q. Public".
    def __str__(self):
        return self.first_name + " " + self.middle_initial + ". " + self.last_name
    

    艺术

    # Returns a string representation of this Name, such as "John Q. Public".
    def __str__(self):
        return self.get_normal_order()
    

13. 抽象是一种在较高层次上关注问题而不必担心次要细节的能力。对象通过为我们提供具有复杂行为的更强大的数据片段来提供抽象，而无需直接管理和操作数据。

14. 若要访问私有属性，请创建返回其值的属性。例如，添加一个属性以访问对象的 data 特性。还可以编写从对象返回数据的访问器方法。name_name

15. 类的封装版本：Name

    # A Name object represents a name such as "John Q. Public".
    # This version is encapsulated with underscored attributes and properties.
    class Name:
        # Initializes a new Name with the given values.
        def __init__(self, first, middle, last):
            self._first = first
            self._middle = middle
            self._last = last
    
        # Returns the person's first name.
        @property
        def first_name(self):
            return self._first
    
        # Returns the person's middle initial.
        @property
        def middle_initial(self):
            return self._middle
    
        # Returns the person's last name.
        @property
        def last_name(self):
            return self._last
    
        # The name in normal order such as "John Q. Public"
        def get_normal_order(self):
            return self._first + " " + self._middle + ". " + self._last
    
        # The name in reverse order such as "Public, John Q.".
        def get_reverse_order(self):
            return self._last + ", " + self._first + " " + self._middle + "."
    
        # The name in normal order such as "John Q. Public"
        def __str__(self):
            return self.get_normal_order()
    

16. 类的属性设置器：Name

    class Name:
        ...
        
        # Sets the first name to the given value.
        @first_name.setter
        def first_name(self, value):
            self._first = value
    
        # Sets the middle initial to the given value.
        @middle_initial.setter
        def middle_initial(self, value):
            self._middle = value
    
        # Sets the last name to the given value.
        @last_name.setter
        def last_name(self, value):
            self._last = value
    

17. 封装允许您更改类的内部实现，而无需将其外部视图更改为客户端。当一个类被封装时，客户端不应该直接访问它的属性，所以只要外部视图（方法行为）是一致的，更改这些字段就不会干扰客户端行为。

18. 凝聚力是一个类的内容如何组合在一起的概念。当一个类的每个属性都存储与对象相关的重要状态并且每个方法以某种方式与该状态交互以产生有用的行为时，可以看出该类是内聚的。

19. 我们没有将控制台 I/O 代码放入我们的类中，因为这样做会强制客户端使用这些确切的 I/O 消息。通过将 I/O 代码保留在 之外，我们使其独立于其客户端。StockStock

20. 类的访问器方法：Stock

    # Returns this Stock's symbol value.
    def get_symbol(self):
        return self._symbol
    
    # Returns this Stock's total number of shares purchased.
    def get_total_shares(self):
        return self._total_shares
    
    # Returns this Stock's total cost for all shares.
    def get_total_cost(self):
        return self._total_cost
    

---

第 12 章

1. 由于函数式编程非常关注单个函数，因此经常使用函数式编程的程序员社区得出的结论是，应尽可能避免副作用。没有副作用的函数很容易推理、重用、组合和并行化。

2. 调用被视为副作用，因为它会产生明显的结果，即将输出输出打印到控制台。因此，您可以通过查找输出来检测是否调用了给定函数。这并不意味着打印输出是一件坏事，只是它是一种副作用。print

3. 该函数的副作用是它修改传入的列表。可以通过让它返回新的列表状态而不是更改现有列表来更改它以消除副作用。

   # Returns a new list whose values are twice as large as
   # the values of all elements in the given list.
   def double_all(lis):
       result = [0] * len(lis)
       for i in range(len(lis)):
           result[i] = 2 * lis[i]
       return result
   

4. lambda num: num * num
   

5. lambda a, b: max(a, b)
   

6. lambda first, last: last + ", " + first
   

7. [10, 28, 33, 28, 49, 56, 49]
   

8. list(filter(lambda num: num >= 0, numbers))
   

9. 绑定变量位于 lambda 内部，通常是其参数之一。自由变量是在 lambda 代码中引用的变量，在 lambda 外部声明并包含在其闭包中。

10. 自由变量为 ，绑定变量为 （第二个） 和 。abc

---