《Python程式設計（第3版）》[美] 約翰·策勒（John Zelle） 第 3 章 答案

答案僅供參考，若有錯誤歡迎指正

判斷對錯

1．由計算機儲存和操作的資訊稱為資料。
2．由於浮點數是非常準確的，所以通常應該使用它們，而不是int。
3．像加法和減法這樣的操作在math庫中定義。
4．n 項的可能排列的數目等於 n！。
5．sqrt函式計算數字的噴射（squirt）。
6．float資料型別與實數的數學概念相同。
7．計算機使用二進位制表示數字。
8．硬體float可以表示比硬體int更大範圍的值。
9．在獲取數字作為使用者輸入時，型別轉換函式（如float）是eval的安全替代。
10．在 Python 中，4 + 5 產生與 4.0 + 5.0 相同的結果型別。
解答

1. T
2. F（p.36 “由於浮點值不精確，而 int 總是精確的，所以一般的經驗 法則應該是：如果不需要小數值，就用 int”）
3. F（見 p.37 “表 3.1 Python 內建的數值操作”）
4. T
5. F（p.41 “該程式使用了 math 庫模組的平方根函式 sqrt”）
6. F（p.36 “int 和 float 之間的另一個區別是，float 型別只能表示對實數的近似”）
7. T
8. T
9. T
10. F（p.38 “結果的資料型別取決於運算元的型別”）

多項選擇

1．下列________________項不是內建的 Python 資料型別。
a．int
b．float
c．rational
d．string
2．以下________________項不是內建操作。
a．+
b．%
c．abs()
d．sqrt()
3．為了使用 math 庫中的函式，程式必須包括________________。
a．註釋
b ．迴圈
c．操作符
d ．import 語句
4．4！的值是________________。
a．9
b．24
c．41
d．120
5．用於儲存π的值，合適的資料型別是________________。
a．int
b．float
c．irrational
d．string
6．可以使用 5 位位元表示的不同值的數量是________________。
a．5
b．10
c．32
d．50
7．在包含 int 和 float 的混合型別表示式中，Python 會進行的轉換是________________。
a．浮點數到整數
b．整數到字串
c．浮點數和整數到字串
d．整數到浮點數
8．下列________________項不是 Python 型別轉換函式。
a．float
b．round
c．int
d．abs
9．用於計算階乘的模式是________________。
a．累積器
b．輸入、處理、輸出
c．計數迴圈
d．格子
10． ________________。
a．導致溢位
b．轉換為 float
c．打破計算機
d．使用更多的記憶體
解答

1. C（Python 使用 fractions 庫中的 Fraction 函式來表示有理數，其實就是用分數來表示有理數?）
2. D（sqrt() 函式是 math 庫中的函式）
3. D
4. B（4！= 4 × 3 × 2 × 1 = 24）
5. B
6. C（1 位位元可以表示兩個不同的值，5 位位元可以表示 2^5 = 32 個不同的值）
7. D（p.38 “在“混合型別表示式”中，Python 會自動將int 轉換為浮點數，並執行浮點運算以產生浮點數結果。”）
8. D（abs() 函式返回實數的絕對值或負數的模）
9. A
10. D

討論

1．顯示每個表示式求值的結果。確保該值以正確的形式表示其型別（int 或float）。如果表示式是非法的，請解釋為什麼。

a. 7.4
b. 5.0
c. 8
d. 表示式非法（p.42 “sqrt 函式無法計算負數的平方根。Python 列印“math domain error”。這告訴我們，負數不在sqrt 函式的定義域中”。若要計算負數的平方根，請使用 cmath.sqrt ）
e. 11
f. 27（3 ** 3 相當於 pow(3, 3)，見 pow 。注意與 math.pow 的不同之處）

2．將以下每個數學表示式轉換為等效的Python 表示式。你可以假定math 庫已匯入（通過import math）。

a. (3 + 4) * 5
b. n * (n - 1) / 2
c. 4 * math.pi * r ** 2
d. math.sqrt(r * (math.cos(a)) ** 2 + r * (math.sin(b)) ** 2)
e. (y2 - y1) / (x2 - x1)

3．顯示將由以下每個 range 表示式生成的數字序列。
a．range(5)
b．range(3, 10)
c．range(4, 13, 3)
d．range(15, 5, -2)
e．range(5, 3)

Tips: range 型別表示一個不可變的數字序列，在 range(start, stop[, step]) 中，如果省略了 step 引數，則其預設為 1；如果省略 start 引數，則其預設為 0；如果 step 引數為 0，則會引發 ValueError

a. [0, 1, 2, 3, 4]
b. [3, 4, 5, 6, 7, 8, 9]
c. [3, 6, 9, 12]
d. [15, 13, 11, 9, 7]
e. []（省略了 step 引數，且 start 小於 stop，生成一個空的數字序列）

4．顯示以下每個程式片段產生的輸出。

a. 1
   4
   9
   16
   25
   36
   49
   64
   81
   100
b. 1 : 1
   3 : 27
   5 : 125
   7 : 343
   9 : 729
   9
c. 012
   212
   412
   612
   812
   done
d. 1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   385

5．如果使用負數作為 round 函式中的第二個引數，你認為會發生什麼？例如，round(314.159265, -1) 的結果應該是什麼？請解釋答案的理由。在你寫下答案後，請參閱 Python 文件或嘗試一些例子，看看Python 在這種情況下實際上做了什麼。

Python 環境：Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32

310.0（參閱 round() 函式）

n = 314.159265
s = str(n)
l = s.split('.')
for i in range(-len(l[0]), len(l[1]) + 1):
    print('round({0}, {1}) = {2}'.format(n, i, round(n, i)))
# Output:
# round(314.159265, -3) = 0.0
# round(314.159265, -2) = 300.0
# round(314.159265, -1) = 310.0
# round(314.159265, 0) = 314.0
# round(314.159265, 1) = 314.2	①
# round(314.159265, 2) = 314.16
# round(314.159265, 3) = 314.159
# round(314.159265, 4) = 314.1593
# round(314.159265, 5) = 314.15927	③
# round(314.159265, 6) = 314.159265

for i in range(-2, 3):
    print('round(0.5, {0}) = {1}'.format(i, round(0.5, i)))
# Output:
# round(0.5, -2) = 0.0
# round(0.5, -1) = 0.0
# round(0.5, 0) = 0.0	②
# round(0.5, 1) = 0.5
# round(0.5, 2) = 0.5

Tips: 根據 Python 3.5 的文件，round() 函式並不是簡單地四捨五入取整，“For the built-in types supporting round(), values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done toward the even choice (so, for example, both round(0.5) and round(-0.5) are 0, and round(1.5) is 2”，即如果值距離兩邊的整數的距離相等，則向相鄰的偶數取整（具體見結論 6）。.

結論：

1. round 函式用於對浮點數進行四捨五入求值，具體保留幾位小數，由傳入的 ndigits 引數來控制
2. ndigits 是可選引數，當不傳入時，即以預設保留 0 位小數進行取整，返回的是整數
3. ndigits 傳入 0 時，與不傳入時一樣以保留 0 位小數進行取整，但返回的是浮點數
4. ndigits 傳入正數時，取整到 ndigits 位小數，整數部分不變，返回的是浮點數。如果傳入的浮點數的小數部分的位數小於 ndigits 位，則返回原來的數
5. ndigits 傳入負數時，對整數部分的後 abs(ndigits) 位進行取整（ 例如：ndigits 為 -3，則對整數部分的後 3 位進行取整），小數部分清 0，返回的是浮點數。如果 ndigits 的絕對值大於傳入的浮點數的整數部分的位數，則返回 0.0
6. 當值距離兩邊的整數的距離相等時的取整方法，根據官方文件，Python 2.x 與 Python 3.x 的具體實現是不同的，這裡只討論 Python 3.x 的情況。這裡需要提到一種取整方法，Banker’s rounding 演算法（銀行家舍入法）。簡單地說就是，如果捨棄部分左邊的數字為奇數，則向上取整（如 ①）；如果捨棄部分左邊的數字為偶數，則向下取整（如 ②）（參考連結）
7. （浮點運算的一個問題）檢視 ③ 的結果，按照上面的規則，round(314.159265, 5) 應該等於 314.15926 才對，可是答案卻不符合我們的預期。這不是一個 Bug，這跟浮點數的精度有關。在計算機中浮點數不一定能精確表達，導致在計算機中儲存的 314.15926 比其真實值要大一點點，因此取整時就近似為了 314.15927（參考連結）

6．當整數除法或餘數運算的運算元為負數時，你認為會發生什麼？考慮以下每種情況並嘗試預測結果。然後在 Python 中試試。（提示：回顧一下神奇的公式 a = (a // b)(b) + (a % b)。）
a．−10 // 3
b．−10 % 3
c．10 // −3
d．10 % −3
e．−10 // −3

Python 環境：Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32

>>> -10 // 3
-4
>>> -10 % 3
2
>>> 10 // -3
-4
>>> 10 % -3
-2
>>> -10 // -3
3

1. 首先要知道一點，取餘結果的符號與 % 第二運算元的符號相同，且 0 <= abs(a % b) < abs(b)。a % b 實質上是 a 加上或者減去整數個 b，使得結果落在區間 [0, b - 1](b > 0) 或 [b + 1, 0](b < 0)，那麼得到的結果就是 a % b
2. 先求 b. ，在表示式 -10 % 3 中，3 大於 0，所以結果的範圍是 [0, 2]，由 -10 + 4 * (3) = 2 得 -10 % 3 = 2；再求 a. ，根據神奇的公式 a = (a // b)(b) + (a % b)，可以得出 -10 // 3 = -4
3. 先求 d. ，在表示式 10 % -3 中，-3 小於 0，所以結果的範圍是 [-2, 0]，由 10 + 4 * (-3) = -2 得 10 % -3 = -2；再求 c. ，可得 10 // -3 = -4
4. 對於 e. 也是一樣，代入神奇的公式 a = (a // b)(b) + (a % b) 有 -10 = (-10 // -3)(-3) + (-10 % -3)，由於 (-10 % -3) 的值為負且在區間 [-2, 0] 內，-10 // -3 只能為 3

程式設計練習

1．編寫一個程式，利用球體的半徑作為輸入，計算體積和表面積。以下是一些可能有用的公式：
$V = 4/3πr^3$
$A = 4πr^2$

#	A program to calculate the volume and 
# 	surface area of a sphere from its radius, given as input
import math
def main():
	radius = float(input("radius: "))
	volume = 4 / 3 * math.pi * radius ** 3
	area = 4 * math.pi * radius ** 2
	print("volume: {0}\nsurface area: {1}".format(volume, area))

main()

2．給定圓形比薩餅的直徑和價格，編寫一個程式，計算每平方英寸的成本。面積公式為$A = πr^2$。

#   A program to calculate the cost per square inch of 
#   a circular pizze, given its diameter and price
import math
def main():
    diameter = float(input("diameter(in inches): "))
    price = float(input("price (in cents): "))
    area = math.pi * (diameter / 2) ** 2
    cost = price / area
    print("The cost is", cost, "cents per square inch.")

main()

3．編寫一個程式，該程式基於分子中的氫、碳和氧原子的數量計算碳水化合物的分子量（以克/摩爾計）。程式應提示使用者輸入氫原子的數量、碳原子的數量和氧原子的數量。然後程式基於這些單獨的原子量列印所有原子的總組合分子量。

原子	摩爾質量（克/摩爾）
H	1.00794
C	12.0107
O	15.9994

例如，水（H₂O）的分子量為2（1.00794）+ 15.9994 = 18.01528。

#   A program to compute the molecular weight of a hydrocarbon
import math
def main():
    hydrogen_atoms = float(input("Please enter the number of hydrogen atomes: "))
    carbon_atoms = float(input("Please enter the number of carbon atomes: "))
    oxygen_atoms = float(input("Please enter the number of oxygen atomes: "))
    
    molar_mass = dict({"H": 1.00794, "C": 12.0107, "O": 15.9994})
    molecular_weight = hydrogen_atoms * molar_mass["H"] + carbon_atoms * molar_mass["C"] \
    + oxygen_atoms * molar_mass["O"]
    print("The molecular weight of all the atoms is",   molecular_weight)

main()

4．編寫一個程式，根據閃光和雷聲之間的時間差來確定雷擊的距離。聲速約為1100 英尺/秒，1 英里為 5280 英尺。

#   A program to calculate the distance to a lightning strike 
def main():
    seconds = float(input("Enter number of seconds between flash and crash: "))
    feet = 1100 * seconds
    miles = feet / 5280.0
    print("The lightning is approximately", miles, "miles away.")

main()

5．Konditorei 咖啡店售賣咖啡，每磅 10.50 美元加上運費。每份訂單的運費為每磅 0.86 美元 + 固定成本 1.50 美元。編寫計算訂單費用的程式。

#   A program that calculates the cost of an order
def main():
    account = float(input("How many pounds of coffee do you want? "))
    coffee_cost = pounds * 10.5
    shipping = pounds * 0.86 + 1.50
    print("Cost of coffee:", coffee_cost)
    print("Shipping:      ", shipping)
    print("-------------------------------")
    print("Total due:     ", coffee_cost + shipping)

main()

6．使用座標（x1，y1）和（x2，y2）指定平面中的兩個點。編寫一個程式，計算通過使用者輸入的兩個（非垂直）點的直線的斜率。
$斜率 = \frac{y2-y1}{x2-x1}$

#   A program to calculate the slope of a line through
#   two (non-vertical) points entered by the user
def main():
    x1 = float(input("Enter the x for the first point: "))
    y1 = float(input("Enter the y for the first point: "))
    x2 = float(input("Enter the x for the second point: "))
    y2 = float(input("Enter the y for the second point: "))
    slope = (y2 - y1) / (x2 - x1)
    print("The slope of the line is", slope)
    
main()

7．編寫一個程式，接受兩點（見上一個問題），並確定它們之間的距離。
$距離=\sqrt{(x2-x1)^2+(y2-y1)^2}$

#   A program to calculate the distance between
#   two points entered by the user
import math
def main():
    x1 = float(input("Enter the x for the first point: "))
    y1 = float(input("Enter the y for the first point: "))
    x2 = float(input("Enter the x for the second point: "))
    y2 = float(input("Enter the y for the second point: "))
    distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
    print("The distance between the points is", distance)

main()

8．格里高利閏餘是從 1 月1 日到前一個新月的天數。此值用於確定復活節的日期。它由下列公式計算（使用整型算術）：
$C = year//100$
$epact = (8 + (C//4) - C + ((8C + 13)//25) + 11(year\%19))\%30$
編寫程式，提示使用者輸入4 位數年份，然後輸出閏餘的值。

#   A program to figure out the Gregorian epact value of year
import math
def main():
    year = int(input("Enter the year (e.g. 2020): "))
    C = year // 100
    epact = (8 + (C//4) - C + ((8 * C + 13) // 25) + 11 * (year % 19)) % 30
    print("The epact value is", epact, "days.")

main()

關於如何確定復活節的日期的參考連結：
http://www.madore.org/~david/misc/calendar.html)
https://www.dateofeaster.com/

9．使用以下公式編寫程式以計算三角形的面積，其三邊的長度為 a、b 和 c：
$s=\frac{a+b+c}{2}$
$A=\sqrt{s(s-a)(s-b)(s-c)}$

#   A program to calcualte the area of a triangle given 
#   the length of its three sides--a, b, and c
import math
def main():
    a= float(input("Please enter the length of side a: "))
    b= float(input("Please enter the length of side b: "))
    c= float(input("Please enter the length of side c: "))
    s = (a + b + c) / 2
    A = math.sqrt(s * (s - a) * (s - b) * (s - c))
    print("The area of the triangle is", A)
    
main()

10．編寫程式，確定梯子斜靠在房子上時，達到給定高度所需的長度。梯子的高度和角度作為輸入。計算長度使用公式為：
$length=\frac{height}{sin\ angle}$
注意：角度必須以弧度表示。提示輸入以度為單位的角度，並使用以下公式進行轉換：
$radians=\frac{\pi}{180}degrees$

#   A program to determine the length of a ladder required 
#   to reach a given height when leaned against a house
import math
def main():
    height = float(input("height: "))
    degrees = float(input("angle(in degrees): "))
    radians = math.pi / 180 * angle
    length = height / math.sin(radians)
    print("length:", length)
    
main()

angle 是梯子與地面的夾角

11．程式設計計算前 n 個自然數的和，其中 n 的值由使用者提供。

#   A program to find the sum of the first n natural numbers
def main():
    n = int(input("Please enter the value of n: "))
    s = 0
    for i in range(1, n + 1):
        s += i
    # s = n * (n + 1) // 2
    print("The sum from i to", n, "is", s)

main()

12．程式設計計算前 n 個自然數的立方和，其中 n 的值由使用者提供。

#   A program to find the sum of the cubes of the first n natural numbers
def main():
    n = int(input("Please enter the value of n: "))
    s = 0
    for i in range(1, n + 1):
        s += i ** 3
    # s = (n * (n + 1) // 2) ** 2
    print("The sum of cubes of 1 through", n, "is", s)

main()

13．程式設計對使用者輸入的一系列數字求和。 程式應該首先提示使用者有多少數字要求和，然後依次提示使用者輸入每個數字，並在輸入所有數字後列印出總和。（提示：在迴圈體中使用輸入語句。）

#   A program to sum a series of numbers entered by the user
def main():
    n = int(input("How many numbers are to be summed? "))
    s = 0
    for i in range(1, n + 1):
        each = float(input("Please enter a number: "))
        s += each
    print("The sum of the numbers is", s)

main()

14．程式設計計算使用者輸入的一系列數字的平均值。與前面的問題一樣，程式會首先詢問使用者有多少個數字。注意：平均值應該始終為 float，即使使用者輸入都是 int。

#   A program to find the average of a series of numbers entered by the user
def main():
    n = int(input("How many numbers are to be calculated? "))
    s = 0
    for i in range(1, n + 1):
        each = float(input("Please enter a number"))
        s += each
    avg = s / n
    print("The average is", avg)

main()

15．編寫程式，通過對這個級數的項進行求和來求近似的 π 值：4/1 – 4/3 + 4/5 – 4/7 + 4/9 − 4/11 + …… 程式應該提示使用者輸入 n，要求和的項數，然後輸出該級數的前n 個項的和。讓你的程式從math.pi 的值中減去近似值，看看它的準確性。

#   A program to approximate the value of pi by summing the terms 
#   of this series: 4/1 - 4/3 + 4/5 = 4/7 + 4/9 - 4/11 + ...
import math
def main():
    estimate = 0
    n = int(input("Please enter the number of terms to sum: "))
    for k in range(1, n + 1):
        estimate += (-1) ** (k + 1) * 4 / (2 * k - 1)
    error = abs(math.pi - estimate)
    print("""The approximation of pi is {0}, which is {1} 
    away from the value of math.pi({2})""".format(estimate, error, math.pi))

main()
# Output:
# Please enter the number of terms to sum: 10000000
# The approximation of pi is 3.1415925535897915, which is 1.0000000161269895e-07
#     away from the value of math.pi(3.141592653589793)

萊布尼茲恆等式：
$\sum_{k=1}^{\infty}\frac{(-1)^n}{2n+1}=4\pi$
看起來很帥，但是，該級數收斂起來非常慢?

16．斐波那契序列是數字序列，其中每個連續數字是前兩個數字的和。經典的斐波那契序列開始於 1，1，2，3，5，8，13，……。編寫計算第n 個斐波納契數的程式，其中 n 是使用者輸入的值。例如，如果 n = 6，則結果為 8。

#   A program to compute the nth Fibonacci number where n is a value input by the user
def fibonacci(n):
    if n <= 0:
        raise ValueError("n must be positive") 
    elif n < 2:
        return n
    fib_n_minus_one = 1
    fib_n_minus_two = 0
    fib_n = 0
    for _ in range(2, n + 1):
        fib_n = fib_n_minus_one + fib_n_minus_two
        fib_n_minus_two = fib_n_minus_one
        fib_n_minus_one = fib_n
    return fib_n

def main():
    n = int(input("n = "))
    fib_n = fibonacci(n)
    print("The {0}th Fibonacci number is {1}".format(n, fib_n))

main()

17．你已經看到 math 庫包含了一個計算數字平方根的函式。在本練習中，你將編寫自己的演算法來計算平方根。解決這個問題的一種方法是使用猜測和檢查。你首先猜測平方根可能是什麼，然後看看你的猜測是多麼接近。你可以使用此資訊進行另一個猜測，並繼續猜測，直到找到平方根（或其近似）。一個特別好的猜測方法是使用牛頓法。假設 x 是我們希望的根，guess 是當前猜測的答案。猜測可以通過使用計算下一個猜測來改進：
$\frac{guess+\frac{x}{guess}}{2}$
程式設計實現牛頓方法。程式應提示使用者找到值的平方根（x）和改進猜測的次數。從猜測值 x / 2 開始，你的程式應該迴圈指定的次數，應用牛頓的方法，並報告猜測的最終值。你還應該從 math.sqrt(x) 的值中減去你的估計值，以顯示它的接近程度。

#   A program to implement Newton's method
import math
def main():
    x = float(input("Please enter the number we want the root of: "))
    times = int(input("Please enter the number of times to loop: "))
    guess = x / 2
    for _ in range(times):
        guess = (guess + x / guess) / 2
    root = math.sqrt(x)
    error = abs(root - guess)
    print("The final value of guess is {0}, which is {1} away from {2}".format(\
    guess, error, root))

main()