原文：Learn Python the Hard Way, 5th Edition (Early Release)

譯者：飛龍

協議：CC BY-NC-SA 4.0

模塊 1：Python 入門

練習 0：準備工作

這個練習沒有代碼。這只是你完成的練習，讓你的計算機運行 Python。你應該盡可能準確地遵循這些說明。如果你在遵循書面說明時遇到問題，請觀看包含的適用于你平臺的視頻。

通用說明

你的一般任務是獲得一個“編程環境”，其中包含你可以用來編寫代碼的工具。幾乎每個程序員都有自己專門的環境，但起初你會想要一些簡單的東西，可以幫助你完成這門課程。課程結束后，你將了解足夠的編程知識，然后可以浪費余生嘗試你能想象到的每種工具。這是非常有趣的。

你需要的是以下內容：

• Jupyter，將在書的第一部分中用于輕松入門。Jupyter 是一個使用多種語言的編程和數據分析環境，但我們將使用 Python。

• Python。你安裝的 Python 版本基本上不重要，只要它比版本 3.6 舊。Python（和其他軟件）的版本使用數字表示它們的年齡，數字的位置決定了版本之間的變化程度。一般規則是第一個數字表示“主要變化”，第二個數字表示“次要變化”，第三個數字表示僅有錯誤或安全修復。這意味著如果你有版本 3.8 和版本 3.10，那么沒有主要變化，但有次要變化。如果你有版本 3.10.1 和 3.10.2，那么只有錯誤修復。

• 一個基本的程序員編輯器。程序員使用非常復雜的文本編輯器，但你應該從一些簡單但仍然作為程序員編輯器的東西開始。

• 終端模擬器。這是一個基于文本的命令界面，用于與計算機交互。如果你看過有關黑客和編程的電影，你會看到人們在黑屏上瘋狂輸入綠色文本，以便使用他們的“unix exe 32 pipe attack”摧毀整個外星種族。起初你不需要這個，但以后你會“畢業”使用終端，因為它非常強大且學習起來并不太難。

你的計算機上應該已經有大部分你需要的其他東西，所以讓我們為你的操作系統（OS）安裝這些要求中的每一項。

極簡啟動

本練習中的說明旨在安裝你在課程中所需的大部分工具，但如果你想盡快開始并付出最少的努力，那么請安裝：

1. Anaconda 來獲取你的 Python。

2. Jupyter 用于編寫和運行一些代碼。

a. 在 Windows 上運行 Jupyter 的最佳方法是按下 Windows 鍵（開始菜單）并鍵入 jupyter-lab。這將以合理的方式啟動它。

b. 在 Linux 上，你應該在終端中輸入相同的命令。

c. 在 macOS 上，你可以在終端中輸入該命令，或者像平常一樣啟動應用程序。

這將為您提供足夠的信息來開始學習，但最終您會遇到需要使用“命令行”中的終端和 Python 的練習。當您在課程中達到這一點時，請回到這個練習。

完整說明

最終，您將需要安裝更多軟件來完成課程。書中的安裝說明存在的問題是它們很快就會過時。為了解決這個問題，我有一個網頁，您需要訪問該網頁，其中包含所有適用于您的操作系統的安裝說明，并附有視頻展示安裝過程。這些說明會在事物發生變化時進行更新，并且網頁包含您書中所需的任何勘誤。

要查看這些說明，請訪問以下鏈接：

• learncodethehardway.com/setup/python/

如果由于某種原因無法訪問此鏈接，則以下是您需要安裝的內容：

1. Anaconda 以獲取您的 Python。

2. Jupyter 用于編寫和運行一些代碼。

3. Geany 用于以后編輯文本。

4. 在 Windows 上使用完整安裝的Cmder作為您的 shell。

5. 在 macOS 上您有終端，Linux 上有您想要的任何東西。

測試您的設置

安裝完所有內容后，請按照以下步驟確認一切正常：

1. 啟動您的終端并精確輸入以下命令，包括空格：mkdir lpthw。

2. 一旦安裝成功，您將擁有一個名為lpthw的目錄，您可以在其中放置您的工作。

3. 使用命令cd lpthw進入該目錄。此命令將您的終端“移動”到該目錄，以便您的工作保存在那里。

4. “目錄”在 Windows 和 macOS 上也稱為“文件夾”。您可以通過在 Windows 上鍵入start.或在 macOS 上鍵入open.來在終端中的“目錄”和您通常看到的“文件夾”之間建立聯系。這將打開當前目錄到您通常看到的圖形文件夾窗口。如果您迷失了，請鍵入該命令。

5. start命令（macOS 上為open）的作用類似于用鼠標雙擊那個東西。如果您在終端中想要“打開”某個東西，只需使用此命令。假設有一個名為test.txt的文本文件，您想在編輯器中打開它。在 Windows 上鍵入start test.txt，在 macOS 上鍵入open test.txt。

6. 現在您可以打開終端并在終端中打開文件，您將需要啟動您的編輯器。如果您一直在按照說明操作，這個編輯器就是 Geany。啟動它并創建一個名為test.txt的文件，然后將其保存在您創建的lpthw目錄中。如果找不到它，請記住您可以在終端中使用start（macOS 上為open）打開它，然后使用該文件夾窗口找到它。

7. 一旦你把文件保存在lpthw目錄中，你應該能夠在終端中輸入ls test.txt來查看它是否存在。如果出現錯誤，那么要么你不在lpthw目錄中，需要輸入cd ~/lpthw 或者 你把它保存在了錯誤的地方。請重試直到你能夠做到這一點。

8. 最后，在終端中輸入jupyter-lab來啟動 Jupyter 并確保它正常工作。它應該會打開你的網頁瀏覽器，然后你會在瀏覽器中看到 Jupyter 應用程序。這有點像你個人電腦上的一個小網站。

把這些任務看作是一種需要解決的謎題。如果遇到困難，你應該觀看我展示如何完成所有操作的適用于你的操作系統的視頻。我認為學習這個最好的方法是首先自己嘗試；然后當遇到困難時，觀看視頻看我是如何做的。

學習命令行

現在不需要立即做這個，但如果你在之前的任務中遇到困難，你可能需要通過命令行快速入門課程來學習終端（也稱為“命令行”）的基礎知識。你暫時不需要這些技能，但命令行是一個非常好的用文字控制計算機的入門，它也會幫助你以后在編程中完成許多其他任務，所以現在學習它只會有好處。

下一步

一旦你把所有東西都搞定了，你就可以繼續進行課程的其余部分。如果你遇到問題，可以發郵件給我，郵箱是 help@learncodethehardway.com，我會幫助你。當你給我發郵件求助時，請花時間盡可能詳細地描述你的問題，并包含截圖。

練習 1：一個好的第一個程序

警告！

如果你跳過了 Exercise 0，那么你就沒有正確地進行這本書的學習。你是在嘗試使用 IDLE 還是 IDE 嗎？我在 Exercise 0 中說不要使用其中的任何一個，所以你也不應該使用。如果你跳過了 Exercise 0，請返回并閱讀它。

你應該在 Exercise 0 中花費了相當多的時間學習如何安裝 Jupyter，運行 Jupyter，運行終端，并且同時使用它們。如果你還沒有這樣做，那么請不要繼續。你將度過不愉快的時光。這是我唯一一次在開始練習時警告你不要跳過或超前的時間。

在 Jupyter 單元格中輸入以下文本：

列表 1.1: ex1.py

1   print("Hello World!")
2   print("Hello Again")
3   print("I like typing this.")
4   print("This is fun.")
5   print('Yay! Printing.')
6   print("I'd much rather you 'not'.")
7   print('I "said" do not touch this.')

你的 Jupyter 單元格應該看起來像這樣：

不要擔心如果你的 Jupyter 窗口看起來不完全相同；它應該是接近的。你的窗口標題可能略有不同，也許顏色略有不同，而你的 Jupyter 窗口的左側不會相同，而是會顯示你用于保存文件的目錄。所有這些差異都是可以接受的。

當你創建這個單元格時，請記住這些要點：

1. 我沒有在左側輸入行號。這些行號是在書中打印出來的，這樣我就可以通過說“看第 5 行…”來談論特定的行。你不需要在 Python 腳本中輸入行號。

2. 我在行首有print，它看起來與我在單元格中的完全相同。完全意味著完全，不是有點類似。每個字符都必須匹配才能正常工作。顏色無關緊要，只有你輸入的字符。

一旦它完全相同，你可以按下SHIFT-ENTER來運行代碼。如果你做對了，那么你應該看到與我在本練習的你應該看到的內容部分相同的輸出。如果沒有，那么你做錯了。不，計算機沒有錯。

你應該看到的內容

在你按住SHIFT并按下ENTER后，Jupyter 的輸出將如下所示（我會寫成SHIFT-ENTER）：

你可能會看到不同的窗口外觀和布局，但重要的是你輸入命令并查看輸出與我的相同。

如果出現錯誤，它會看起來像這樣：

1   Cell In[1], line 3
2     print("I like typing this.
3           ^
4   SyntaxError: unterminated string literal (detected at line 1)

重要的是你能夠閱讀這些錯誤消息，因為你將犯許多這樣的錯誤。即使我也會犯許多這樣的錯誤。讓我們逐行查看這個。

1. 我們使用SHIFT-ENTER在 Jupyter 單元格中運行了我們的命令。

2. Python 告訴我們該單元格在第 3 行有一個錯誤。

3. 它為我們打印出這行代碼以供查看。

4. 然后它放置一個^（插入符）字符指向問題所在的地方。注意結尾缺少"（雙引號）字符了嗎？

5. 最后，它會打印出一個“SyntaxError”并告訴我們可能的錯誤。通常這些錯誤非常難以理解，但如果你將該文本復制到搜索引擎中，你會找到其他遇到過這個錯誤的人，并且你可能會弄清楚如何修復它。

學習練習

學習練習包含你應該嘗試做的事情。如果你做不到，跳過它，稍后再回來。

對于這個練習，請嘗試這些事情：

1. 讓你的腳本打印另一行。

2. 讓你的腳本只打印一行。

3. 在一行的開頭放一個#（井號）字符。它有什么作用？試著找出這個字符的作用。

從現在開始，除非練習有所不同，否則我不會解釋每個練習的工作原理。

信息

“井號”也被稱為“磅”，“井號”，“網格”或任何一種名稱。選擇讓你放松的那個。

常見學生問題

這些是真實學生在做這個練習時提出的實際問題：

我可以使用 IDLE 嗎？ 不，現在只使用 Jupyter，稍后我們將使用常規文本編輯器獲得額外的超能力。

在 Jupyter 中編輯代碼很煩人。我可以使用文本編輯器嗎？ 完全可以，你也可以在 Jupyter 中創建一個python文件并獲得一個“足夠好”的編輯器。在左側面板中看到所有文件的地方，點擊左上角的+（加號）圖標。這將帶你到你開始 Jupyter 時看到的第一個屏幕。在底部的$_ Other下，你會看到一個帶有 Python 標志的Python File按鈕。點擊它，你將獲得一個編輯器來處理你的文件。

我的代碼無法運行；我只是得到一個沒有輸出的提示符。你很可能字面上采用了我的單元格中的代碼，并認為print("Hello World!")意味著只在單元格中輸入"Hello World!"，而不包括print。你的單元格必須完全像我的一樣。

練習 2：注釋和井號字符

在你的程序中，注釋非常重要。它們用于用英語告訴你某件事情的作用，并且用于暫時禁用程序的某些部分。以下是如何在 Python 中使用注釋：

列表 2.1：ex2.py

1   # A comment, this is so you can read your program later.
2   # Anything after the # is ignored by python.
3
4   print("I could have code like this.") # and the comment after is ignored
5
6   # You can also use a comment to "disable" or comment out code:
7   # print*(*"This won't run."*)*
8
9   print("This will run.")

從現在開始，我會這樣寫代碼。你需要明白并不是所有東西都必須字面意思。如果我的 Jupyter 看起來與你的有些不同，或者我在使用文本編輯器，結果都是一樣的。更多關注文本輸出，少關注視覺顯示，比如字體和顏色。

你應該看到什么

1   I could have code like this.
2   This will run.

再次強調，我不會展示所有可能的終端的截圖。你應該明白上述內容并不是你的輸出在視覺上應該看起來的字面翻譯，而是你應該關注的文本內容。

學習練習

1. 查明你對#字符的理解是否正確，并確保你知道它的名稱（井號或磅字符）。

2. 拿起你的代碼，倒著檢查每一行。從最后一行開始，逆向檢查每個單詞是否與你應該輸入的相符。

3. 你找到更多錯誤了嗎？修正它們。

4. 大聲朗讀你輸入的內容，包括按名稱說出每個字符。你找到更多錯誤了嗎？修正它們。

常見學生問題

你確定 # 被稱為井號字符嗎？ 我稱其為八角符號，因為這是唯一一個沒有一個國家使用并且在每個國家都有效的名稱。每個國家都認為對于這個字符的命名方式是最重要的，也是唯一的方式。對我來說，這只是傲慢，實際上，大家應該冷靜下來，更專注于更重要的事情，比如學習編程。

為什么 print("Hi # there.") 中的 # 不會被忽略？ 該代碼中的#在一個字符串內，因此它會一直被放入字符串，直到結束的"字符出現。字符串中的井號字符只被視為字符，而不是注釋。

如何注釋掉多行？ 在每一行前面加上#。

我不知道如何在我國的鍵盤上輸入 # 字符。我該怎么做？ 一些國家使用 ALT 鍵和其他鍵的組合來打印與其語言不同的字符。你需要上網搜索如何輸入它。

為什么我要倒著讀代碼？ 這是一個技巧，讓你的大腦不會將代碼的每個部分賦予意義，這樣做可以讓你精確處理每個部分。這可以捕捉錯誤，并且是一個方便的錯誤檢查技術。

練習 3：數字和數學

每種編程語言都有一種處理數字和數學的方式。不要擔心：程序員經常謊稱自己是數學天才，當他們實際上并不是。如果他們是數學天才，他們會做數學，而不是編寫有 bug 的網絡框架，以便他們可以開賽車。

這個練習涉及很多數學符號。讓我們立即給它們命名，這樣你就知道它們叫什么。當你輸入時，說出名稱。當說起它們感到無聊時，你可以停止說。這里是名稱：

• + 加號

• - 減號

• / 斜杠

• * 星號

• % 百分號

• < 小于

• > 大于

• <= 小于等于

• >= 大于等于

注意運算符缺失了嗎？在輸入這個練習的代碼后，回頭去弄清楚每個運算符的作用，并完成表格。例如，+表示加法。

列表 3.1：ex3.py

 1   print("I will now count my chickens:")23   print("Hens", 25 + 30 / 6)4   print("Roosters", 100 - 25 * 3 % 4)56   print("Now I will count the eggs:")78   print(3 + 2 + 1 - 5 + 4 % 2 - 1 / 4 + 6)9
10   print("Is it true that 3 + 2 < 5 - 7?")
11
12   print(3 + 2 < 5 - 7)
13
14   print("What is 3 + 2?", 3 + 2)
15   print("What is 5 - 7?", 5 - 7)
16
17   print("Oh, that's why it's False.")
18
19   print("How about some more.")
20
21   print("Is it greater?", 5 > -2)
22   print("Is it greater or equal?", 5 >= -2)
23   print("Is it less or equal?", 5 <= -2)

在運行之前確保你準確地輸入了這個。將你的文件的每一行與我的文件進行比較。

你應該看到什么

 1   I will now count my chickens:2   Hens 30.03   Roosters 974   Now I will count the eggs:5   6.756   Is it true that 3 + 2 < 5 - 7?7   False8   What is 3 + 2? 59   What is 5 - 7? -2
10   Oh, that's why it's False.
11   How about some more.
12   Is it greater? True
13   Is it greater or equal? True
14   Is it less or equal? False

學習練習

1. 在每一行上面，使用#寫一個注釋給自己解釋這行代碼的作用。

2. 你可以直接在 Jupyter 單元格中輸入大多數數學運算并獲得結果。嘗試使用它進行一些基本計算，比如1+2，然后按下SHIFT-ENTER。

3. 找到需要計算的內容，并編寫一個新的.py文件來完成。

4. 重寫這個練習，使用浮點數使其更準確。20.0 是浮點數。

常見學生問題

為什么 % 字符是“模數”而不是“百分比”？ 主要是設計者選擇使用這個符號的方式。在正常的寫作中，你正確地將其讀作“百分比”。在編程中，這個計算通常使用簡單的除法和/運算符來完成。%模數是一個不同的操作，只是碰巧使用了%符號。

%是如何工作的？ 另一種說法是，“X 除以 Y，余數為 J。” 例如，“100 除以 16，余數為 4。” %的結果是 J 部分，或者剩余部分。

運算的順序是什么？ 在美國，我們使用一個叫做 PEMDAS 的縮寫，代表括號 指數 乘法 除法 加法 減法。這也是 Python 遵循的順序。人們在處理PEMDAS時常犯的錯誤是認為這是一個嚴格的順序，就像“先做 P，然后 E，然后 M，然后 D，然后 A，然后 S。” 實際的順序是你先進行乘法 和 除法（M&D）一步完成，從左到右，然后進行加法和減法一步完成，從左到右。因此，你可以將PEMDAS重寫為PE(M&D)(A&S)。

練習 4：變量和名稱

現在你可以用print打印東西，還可以進行數學運算。下一步是學習關于變量的知識。在編程中，變量只不過是某物的名稱，類似于我的名字“Zed”是“寫這本書的人類”的名稱。程序員使用這些變量名稱使他們的代碼更像英語，并且因為他們的記憶力不好。如果他們在軟件中不使用良好的名稱，當他們再次閱讀代碼時就會迷失方向。

如果你在這個練習中遇到困難，記住你到目前為止學到的找出差異和專注細節的技巧：

1. 在每一行上面寫一個注釋，用英語解釋它的作用。

2. 反向閱讀你的 Python 代碼。

3. 大聲朗讀你的 Python 代碼，甚至說出字符。

列表 4.1: ex4.py

 1   cars = 1002   space_in_a_car = 4.03   drivers = 304   passengers = 905   cars_not_driven = cars - drivers6   cars_driven = drivers7   carpool_capacity = cars_driven * space_in_a_car8   average_passengers_per_car = passengers / cars_driven9
10
11   print("There are", cars, "cars available.")
12   print("There are only", drivers, "drivers available.")
13   print("There will be", cars_not_driven, "empty cars today.")
14   print("We can transport", carpool_capacity, "people today.")
15   print("We have", passengers, "to carpool today.")
16   print("We need to put about", average_passengers_per_car,
17         "in each car.")

信息

space_in_a_car中的_被稱為下劃線字符。如果你還不知道如何輸入它，請找出如何輸入。我們經常使用這個字符在變量名中的單詞之間放置一個虛擬空格。

你應該看到的結果

1   There are 100 cars available.
2   There are only 30 drivers available.
3   There will be 70 empty cars today.
4   We can transport 120.0 people today.
5   We have 90 to carpool today.
6   We need to put about 3.0 in each car.

練習

當我第一次編寫這個程序時，我犯了一個錯誤，Python 像這樣告訴我：

1   Traceback (most recent call last):
2     Cell In[1], line 8, in <module>
3       average_passengers_per_car = car_pool_capacity / passenger
4   NameError: name 'car_pool_capacity' is not defined

用你自己的話解釋這個錯誤。確保使用行號并解釋原因。

這里有更多練習：

1. 我用 4.0 代表space_in_a_car，但這是必要的嗎？如果只是 4 會發生什么？

2. 記住 4.0 是一個浮點數。它只是一個帶有小數點的數字，你需要用 4.0 而不是只有 4，這樣它就是浮點數了。

3. 在每個變量賦值上面寫注釋。

4. 確保你知道=被稱為什么（等于號），它的目的是給數據（數字、字符串等）命名（cars_driven、passengers）。

5. 記住_是一個下劃線字符。

6. 嘗試像之前一樣從終端運行python3作為計算器，并使用變量名進行計算。常用的變量名還有i、x和j。

常見學生問題

=（單等號）和 == （雙等號）之間有什么區別？ =（單等號）將右側的值賦給左側的變量。==（雙等號）測試兩個值是否相同。你以后會學到這個。

我們可以寫 x=100 而不是 x = 100嗎？ 可以，但這是不好的形式。你應該在操作符周圍添加空格，這樣更容易閱讀。

“反向閱讀文件（代碼）”是什么意思？ 非常簡單。想象你有一個有 16 行代碼的文件。從第 16 行開始，將其與我在第 16 行的代碼進行比較。然后再對第 15 行進行同樣的操作，依此類推，直到你將所有代碼都反向閱讀完。

為什么你在 space_in_a_car 中使用 4.0？ 主要是為了讓你了解什么是浮點數，并提出這個問題。參見練習部分。

練習 5：更多變量和打印

現在我們將更多地輸入變量并將它們打印出來。這次我們將使用一種稱為“格式化字符串”的東西。每當你在文本周圍加上"（雙引號）時，你就在制作一個字符串。字符串是你如何制作程序可能提供給人類的東西。你打印字符串，將字符串保存到文件中，將字符串發送到 Web 服務器等等。

字符串非常方便，所以在這個練習中，你將學習如何制作包含嵌入變量的字符串。你通過使用特殊的{}序列將變量嵌入字符串中，然后將你想要的變量放在{}字符中。你還必須以字母f開頭，表示“格式”，就像f"Hello {somevar}"一樣。在"（雙引號）和{}字符之前加上這個小f告訴 Python 3，“嘿，這個字符串需要格式化。把這些變量放進去。”

和往常一樣，即使你不理解也要輸入這些內容，并確保完全一樣。

列表 5.1：ex5.py

 1   my_name = 'Zed A. Shaw'2   my_age = 35 # not a lie3   my_height = 74 # inches4   my_weight = 180 # lbs5   my_eyes = 'Blue'6   my_teeth = 'White'7   my_hair = 'Brown'89   print(f"Let's talk about {my_name}.")
10   print(f"He's {my_height} inches tall.")
11   print(f"He's {my_weight} pounds heavy.")
12   print("Actually that's not too heavy.")
13   print(f"He's got {my_eyes} eyes and {my_hair} hair.")
14   print(f"His teeth are usually {my_teeth} depending on the coffee.")
15
16   # this line is tricky, try to get it exactly right
17   total = my_age + my_height + my_weight
18   print(f"If I add {my_age}, {my_height}, and {my_weight} I get {total}.")

你應該看到的內容

1   Let's talk about Zed A. Shaw.
2   He's 74 inches tall.
3   He's 180 pounds heavy.
4   Actually that's not too heavy.
5   He's got Blue eyes and Brown hair.
6   His teeth are usually White depending on the coffee.
7   If I add 35, 74, and 180 I get 289.

學習擴展

1. 將所有變量中的my_都去掉。確保你在所有地方都修改了名稱，不僅僅是在使用=設置它們的地方。

2. 嘗試編寫一些變量，將英寸和磅轉換為厘米和千克。不要只是輸入測量值。在 Python 中進行數學計算。

常見學生問題

我可以像這樣定義一個變量嗎： 1 = 'Zed Shaw'？ 不可以，1不是一個有效的變量名。變量名需要以字符開頭，所以a1是可以的，但1是不行的。

如何將浮點數四舍五入？ 你可以像這樣使用round()函數：round(1.7333)。

為什么我看不懂這個？ 嘗試將腳本中的數字改為你的測量值。這有點奇怪，但談論自己會讓它看起來更真實。而且，你剛剛開始，所以不會太有意義。繼續前進，更多的練習會讓你更好地理解。

練習 6：字符串和文本

雖然你一直在寫字符串，但你仍然不知道它們是做什么的。在這個練習中，我們創建了一堆帶有復雜字符串的變量，這樣你就可以看到它們的用途。首先解釋一下字符串。

一個字符串通常是你想要向某人顯示或從你正在編寫的程序“導出”的一小段文本。當你在文本周圍放置"（雙引號）或'（單引號）時，Python 知道你想要的是一個字符串。當你在print中放置你想要放入字符串中的文本時，你會看到這種情況發生了很多次，放在print后面的"或'中打印字符串。

字符串可以包含在你的 Python 腳本中的任意數量的變量。記住，變量是你設置一個名字=（等于）一個值的任何代碼行。在這個練習的代碼中，types_of_people = 10創建了一個名為types_of_people的變量，并將其設置為=（等于）10。你可以將它放在任何帶有{types_of_people}的字符串中。你還會看到我必須使用一種特殊類型的字符串來“格式化”；它被稱為“f-string”，看起來像這樣：

f"some stuff here {avariable}"
f"some other stuff {anothervar}"

Python 還有另一種使用.format()語法的格式化方式，你可以在第 17 行看到。有時候當我想對已經創建的字符串應用格式時，你會看到我使用它。我們稍后會更詳細地討論這個。

現在我們將輸入一大堆字符串、變量和格式，并打印它們。你還將練習使用簡短的縮寫變量名。程序員喜歡通過使用令人討厭的短小和神秘的變量名來節省時間，所以讓我們從早期開始閱讀和編寫它們。

清單 6.1：ex6.py

 1   types_of_people = 102   x = f"There are {types_of_people} types of people."34   binary = "binary"5   do_not = "don't"6   y = f"Those who know {binary} and those who {do_not}."78   print(x)9   print(y)
10
11   print(f"I said: {x}")
12   print(f"I also said: '{y}'")
13
14   hilarious = False
15   joke_evaluation = "Isn't that joke so funny?! {}"
16
17   print(joke_evaluation.format(hilarious))
18
19   w = "This is the left side of..."
20   e = "a string with a right side."
21
22   print(w + e)

你應該看到的內容

1   There are 10 types of people.
2   Those who know binary and those who don't.
3   I said: There are 10 types of people.
4   I also said: 'Those who know binary and those who don't.'
5   Isn't that joke so funny?! False
6   This is the left side of...a string with a right side.

學習擴展

1. 瀏覽這個程序，并在每行上面寫一個注釋，解釋它。

2. 找出所有將字符串放在另一個字符串中的地方。

3. 你確定只有四個地方嗎？你怎么知道？也許我喜歡說謊。

4. 解釋為什么使用+將兩個字符串w和e相加會得到一個更長的字符串。

破解它

現在你已經到了一個可以嘗試破壞你的代碼以查看結果的階段。把這看作是一個游戲，想出最聰明的方法來破壞代碼。你也可以找到最簡單的方法來破壞它。一旦你破壞了代碼，你就需要修復它。如果你有一個朋友，那么你們兩個可以嘗試破壞對方的代碼并修復它。把你的代碼給你的朋友，保存在一個名為ex6.py的文件中，這樣他們就可以破壞一些東西。然后你嘗試找到他們的錯誤并修復它。玩得開心，并記住，如果你寫過這段代碼一次，你可以再次做到。如果你把損壞搞得太嚴重，你總是可以再次輸入以進行額外練習。

常見學生問題

為什么你會在一些字符串周圍加上'（單引號），而在另一些字符串周圍不加呢？大多數情況下是出于風格考慮，但我會在雙引號內部使用單引號。看看第 6 行和第 15 行，看看我是如何做到這一點的。

如果你覺得這個笑話很有趣，你能寫下 hilarious = True嗎？ 是的，你以后會更多地了解這些布爾值。

練習 7：合并字符串

現在我們將做一系列練習，你只需輸入代碼并運行它。我不會解釋這個練習，因為它和之前的差不多。目的是提高你的技能。在幾個練習后見，不要跳過！ 不要粘貼！

列表 7.1: ex7.py

 1   print("Mary had a little lamb.")2   print("Its fleece was white as {}.".format('snow'))3   print("And everywhere that Mary went.")4   print("." * 10) # what'd that do?56   end1 = "C"7   end2 = "h"8   end3 = "e"9   end4 = "e"
10   end5 = "s"
11   end6 = "e"
12   end7 = "B"
13   end8 = "u"
14   end9 = "r"
15   end10 = "g"
16   end11 = "e"
17   end12 = "r"
18
19   # watch end = ' ' at the end. try removing it to see what happens
20   print(end1 + end2 + end3 + end4 + end5 + end6, end=' ')
21   print(end7 + end8 + end9 + end10 + end11 + end12)

你應該看到的內容

1   Mary had a little lamb.
2   Its fleece was white as snow.
3   And everywhere that Mary went.
4   ..........
5   Cheese Burger

練習

在接下來的幾個練習中，你將有完全相同的練習。

1. 回顧并對每一行寫下注釋。

2. 反向閱讀或大聲朗讀每一行，找出你的錯誤。

3. 從現在開始，當你犯錯時，記下你犯了什么樣的錯誤。

4. 當你進行下一個練習時，看看你犯過的錯誤，并盡量不在新的練習中犯同樣的錯誤。

5. 記住每個人都會犯錯。程序員就像魔術師一樣，讓每個人都以為他們是完美的，從不犯錯，但這都是表演。他們經常犯錯。

拆分它

你是否在練習 6 中玩得開心？從現在開始，你將打破你寫的所有代碼或朋友的代碼。我不會在每個練習中明確列出拆分它部分，但我幾乎會在每個視頻中這樣做。你的目標是找到盡可能多的不同方法來破壞你的代碼，直到你累了或耗盡所有可能性。在一些練習中，我可能會指出人們常犯的某種特定方式來破壞該練習的代碼，但除此之外，請始終將其視為一個命令來始終打破它。

常見學生問題

為什么你使用名為’snow’的變量？ 實際上那不是一個變量：它只是一個包含單詞snow的字符串。一個變量不會在單引號中。

像你在練習 1 中說的那樣，為每一行代碼寫一個英文注釋是正常的嗎？ 不，你只需要為難以理解的代碼或者為什么要這樣做寫注釋。為什么通常更重要，然后你嘗試編寫代碼以解釋某個操作是如何完成的。然而，有時你必須編寫一些糟糕的代碼來解決問題，這時確實需要在每一行上寫注釋。在這種情況下，這僅僅是為了讓你練習將代碼翻譯成英文。

我可以使用單引號或雙引號來創建一個字符串嗎？它們有不同的作用嗎？ 在 Python 中，用任何一種方式創建字符串都是可以接受的，盡管通常你會在像'a'或'snow'這樣的短字符串中使用單引號。

練習 8：手動格式化字符串

現在我們將看到如何對字符串進行更復雜的格式化。這段代碼看起來復雜，但如果你在每一行上面做好注釋，并將每個部分分解開來，你就會理解它。

代碼清單 8.1: ex8.py

 1   formatter = "{} {} {} {}"23   print(formatter.format(1, 2, 3, 4))4   print(formatter.format("one", "two", "three", "four"))5   print(formatter.format(True, False, False, True))6   print(formatter.format(formatter, formatter, formatter, formatter))7   print(formatter.format(8       "Try your",9       "Own text here",
10       "Maybe a poem",
11       "Or a song about fear"
12   ))

你應該看到的內容

1   1 2 3 4
2   one two three four
3   True False False True
4   {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}
5   Try your Own text here Maybe a poem Or a song about fear

在這個練習中，我使用了一個叫做“函數”的東西，將 formatter 變量轉換為其他字符串。

當你看到我寫 formatter.format(...) 時，我是在告訴 Python 執行以下操作：

1. 取出第 1 行定義的 formatter 字符串。

2. 調用它的 format 函數，類似于告訴它執行一個名為 format 的命令行命令。

3. 傳遞給 format 四個參數，這些參數與 formatter 變量中的四個 {} 匹配。這就像向命令行命令 format 傳遞參數一樣。

4. 在 formatter 上調用 format 的結果是一個新字符串，其中的 {} 被這四個變量替換。這就是 print 現在打印出來的內容。

這對于第八個練習來說有點多，所以我希望你把它當作一個腦筋急轉彎。如果你不是真的理解發生了什么，也沒關系，因為本書的其余部分會慢慢澄清這一點。此時，請嘗試研究一下這個，并看看發生了什么，然后繼續下一個練習。

學習任務

重復 練習 7 中的學習任務。

常見學生問題

為什么我必須在“one”周圍加引號，但不需要在 True 或 False 周圍加引號？ Python 將 True 和 False 視為代表真和假概念的關鍵字。如果你在它們周圍加上引號，那么它們就會變成字符串，無法正常工作。你將在后面學到更多關于它們如何工作的知識。

我可以使用 IDLE 運行嗎？ 不可以，如果你知道的話，應該使用 Jupyter 或命令行。學習編程是必不可少的，如果你想學習編程，這是一個很好的起點。Jupyter 比 IDLE 是一個更優秀的工具。

練習 9：多行字符串

現在你應該意識到這本書的模式是使用多個練習來教授你新知識。我從你可能不理解的代碼開始，然后更多的練習來解釋概念。如果你現在不理解某些內容，隨著完成更多練習，你以后會理解的。記下你不理解的內容，然后繼續。

代碼清單 9.1: ex9.py

 1   # Here's some new strange stuff, remember type it exactly.23   days = "Mon Tue Wed Thu Fri Sat Sun"4   months = "Jan\nFeb\nMar\nApr\nMay\nJun\nJul\nAug"56   print("Here are the days: ", days)7   print("Here are the months: ", months)89   print("""
10   There's something going on here.
11   With the three double-quotes.
12   We'll be able to type as much as we like.
13   Even 4 lines if we want, or 5, or 6.
14   """)

你應該看到的內容

 1   Here are the days: Mon Tue Wed Thu Fri Sat Sun2   Here are the months: Jan3   Feb4   Mar5   Apr6   May7   Jun8   Jul9   Aug
10
11   There's something going on here.
12   With the three double-quotes.
13   We'll be able to type as much as we like.
14   Even 4 lines if we want, or 5, or 6.

學習擴展

重復來自練習 7 的學習擴展。

常見學生問題

為什么我在三個雙引號之間放空格時會出錯？ 你必須像這樣輸入"""而不是" " ", 意思是每個之間都沒有空格。

如果我想要在新的一行開始月份怎么辦？ 你只需像這樣以\n開頭的字符串："\nJan\nFeb\nMar\nApr\nMay\nJun\nJul\nAug"。

我的錯誤總是拼寫錯誤，這是不好的嗎？ 大多數編程錯誤在開始階段（甚至后來）都是簡單的拼寫錯誤、打字錯誤或者簡單事情的順序錯了。

第 10 題. 字符串中的轉義代碼

在第 9 題中，我給你一些新東西，只是為了讓你保持警惕。我向你展示了兩種跨越多行的字符串的方法。在第一種方法中，我在月份名稱之間放置了字符\n（反斜杠n）。這兩個字符在該點將一個換行字符放入字符串中。

這個\（反斜杠）字符將難以輸入的字符編碼到字符串中。有各種不同的“轉義序列”可用于你可能想要使用的不同字符。我們將嘗試一些這些序列，這樣你就能明白我的意思。

一個重要的轉義序列是轉義單引號'或雙引號"。想象一下，你有一個使用雙引號的字符串，而你想在字符串中放一個雙引號。如果你寫"我 "理解" 喬。"，那么 Python 會感到困惑，因為它會認為"在"理解"周圍實際上結束了字符串。你需要一種方法告訴 Python，字符串中的"不是真正的雙引號。

要解決這個問題，你需要轉義雙引號和單引號，這樣 Python 才知道將它們包含在字符串中。這里有一個例子：

"I am 6'2\" tall." # escape double-quote inside string
'I am 6\'2" tall.' # escape single-quote inside string

解決這個問題的第二種方法是使用三引號，即"""，它的工作方式類似于字符串，但你也可以放置任意行的文本，直到再次鍵入"""。我們也會玩一下這些。

代碼清單 10.1: ex10.py

 1   tabby_cat = "\tI'm tabbed in."2   persian_cat = "I'm split\non a line."3   backslash_cat = "I'm \\ a \\ cat."45   fat_cat = """6   I'll do a list:7   \t* Cat food8   \t* Fishies9   \t* Catnip\n\t* Grass
10   """
11
12   print(tabby_cat)
13   print(persian_cat)
14   print(backslash_cat)
15   print(fat_cat)

你應該看到的內容

尋找你制作的制表符。在這個練習中，正確的間距很重要。

 1           I'm tabbed in.2   I'm split3   on a line.4   I'm \ a \ cat.56   I'll do a list:7           * Cat food8           * Fishies9           * Catnip
10           * Grass

轉義序列

這是 Python 支持的所有轉義序列。你可能不會使用其中許多，但無論如何要記住它們的格式和功能。嘗試在一些字符串中使用它們，看看能否讓它們起作用。

學習練習

1. 通過將它們放在閃存卡上來記憶所有的轉義序列。

2. 使用'''（三個單引號）代替。你能看出為什么你可能會使用它而不是"""嗎？

3. 結合轉義序列和格式字符串創建更復雜的格式。

常見學生問題

我還沒有完全弄清楚最后一個練習。我應該繼續嗎？ 是的，繼續。不要停下來，記下你對每個練習不理解的事情。定期查看你的筆記，看看在完成更多練習后是否能弄清楚這些事情。有時候，你可能需要回頭做幾個練習。

是什么讓 // 與其他的不同？ 這只是你會寫出一個反斜杠（\）字符的方式。想想為什么你會需要這個。

當我寫 // 或 /n 時它不起作用。那是因為你使用的是正斜杠/而不是反斜杠\。它們是不同的字符，做著非常不同的事情。

我不明白練習 3。你說的“結合”轉義序列和格式是什么意思？ 我需要你理解的一個概念是，這些練習可以結合起來解決問題。利用你對格式化字符串的了解，編寫一些新代碼，使用格式化字符串和這個練習中的轉義序列。

哪個更好， ''' 還是 """？ 這完全取決于風格。現在選擇'''（三個單引號）風格，但要準備根據感覺或其他人的做法選擇其中之一。

練習 11：向人們提問

現在是加快節奏的時候了。你一直在打印以便熟悉輸入簡單的東西，但那些簡單的東西相當無聊。我們現在想要做的是將數據輸入到你的程序中。這有點棘手，因為你必須學會做兩件可能一開始不太明白的事情，但相信我，無論如何都要做。在幾個練習后，它們會變得清晰起來。

軟件大部分的功能是以下內容：

1. 從一個人那里獲取某種輸入。

2. 改變它。

3. 打印出一些內容以展示它是如何改變的。

到目前為止，你一直在打印字符串，但還沒有能夠從一個人那里獲取任何輸入。你可能甚至不知道“輸入”是什么意思，但無論如何都要輸入這段代碼，并確保完全相同。在下一個練習中，我們將做更多的解釋輸入的內容。

清單 11.1：ex11.py

1   print("How old are you?", end=' ')
2   age = input()
3   print("How tall are you?", end=' ')
4   height = input()
5   print("How much do you weigh?", end=' ')
6   weight = input()
7
8   print(f"So, you're {age} old, {height} tall and {weight} heavy.")

信息

我們在每個打印行的末尾加上了end=' '。這告訴print不要以換行符結束該行并轉到下一行。

你應該看到的內容

1   How old are you? 38
2   How tall are you? 6'2"
3   How much do you weigh? 180lbs
4   So, you're 38 old, 6'2" tall and 180lbs heavy.

學習練習

1. 上網查找 Python 的input是做什么的。

2. 你能找到其他使用它的方法嗎？嘗試一些你找到的示例。

3. 寫另一個像這樣的“表格”來詢問其他問題。

常見學生問題

我如何從某人那里獲取一個數字以便進行數學計算？ 這有點高級，但嘗試x = int(input())，它從input()獲取數字作為字符串，然后使用int()將其轉換為整數。

我使用 input("6'2") 將我的身高輸入到原始輸入中，但它不起作用。你不需要在那里輸入你的身高；你直接在終端中輸入。首先，回去把代碼完全改成和我的一樣。接下來，運行腳本，當它暫停時，在鍵盤上輸入你的身高。就是這么簡單。

練習 12：更簡單的提示方式

當你輸入input()時，你實際上輸入了(和)字符，這些是括號字符。對于input，你也可以輸入一個提示，讓人知道該輸入什么。在()內放入你想要的提示字符串，看起來像這樣：

y = input("Name? ")

這提示用戶輸入“姓名？”，并將結果放入變量y中。這就是你向某人提問并得到答案的方式。

這意味著我們可以完全重寫我們之前的練習，只需使用input來進行所有提示。

列表 12.1: ex12.py

1   age = input("How old are you? ")
2   height = input("How tall are you? ")
3   weight = input("How much do you weigh? ")
4
5   print(f"So, you're {age} old, {height} tall and {weight} heavy.")

你應該看到什么

1   How old are you? 38
2   How tall are you? 6'2"
3   How much do you weigh? 180lbs
4   So, you're 38 old, 6'2" tall and 180lbs heavy.

學習練習

1. 在你的 Jupyter 單元格中右鍵點擊任何print，然后選擇顯示上下文幫助。這將為print提供快速文檔。

2. 如果你這樣做，面板上會顯示“點擊函數查看文檔。”，那么你需要用SHIFT-ENTER運行代碼，然后再次點擊print函數。

3. 接下來，去Google搜索python print site:python.org以獲取 Python print函數的官方文檔。

常見學生問題

為什么上下文幫助會消失？ 我不確定，但我懷疑它無法在你編輯代碼時找到你想要文檔的函數。運行代碼，然后突然它就會起作用。你也可以點擊你工作的任何其他單元格中的任何其他函數。

這些文檔是從哪里來的？ 這些是添加到代碼本身的文檔注釋，這就是為什么它可能與在線文檔不同的原因。養成在可能的情況下同時學習兩者的習慣。

練習 13：參數、解包、變量

現在我們將快速進入終端（又稱PowerShell）版本的python世界。如果你正確完成了First Steps，你應該已經學會了如何啟動終端并運行一個簡單的 Python 腳本。在本課程的后面，你將學習如何更廣泛地使用終端，但在這個練習中，我們只是做一個小小的測試。

首先，我希望你使用 Jupyter 的新 Python 文件創建一個名為ex13.py的文件：

1. 左側有一個列出你目錄中文件的列表。

2. 在那個列表的上方有一個藍色的[+]按鈕。

3. 點擊那個按鈕，滾動到底部，那里應該有一個帶有 Python“藍色和黃色蛇”標志的Python File按鈕。

4. 點擊那個按鈕打開一個新的面板，你可以在其中輸入代碼。

5. 立即使用鼠標選擇File > Save Python File或按住CTRL鍵并按下s鍵（通常顯示為Ctrl-S，但你不需要按住 Shift 鍵來輸入S）。

6. 這將打開一個模態提示，上面寫著“重命名文件”。輸入“ex13”，它應該保留.py，但確保這個輸入顯示為ex13.py。

7. 點擊藍色的[Rename]按鈕將文件保存在那個目錄中。

保存了那個文件之后，你可以將以下代碼輸入到文件中：

列表 13.1: ex13.py

1   from sys import argv
2   # read the What You Should See section for how to run this
3   script, first, second, third = argv
4
5   print("The script is called:", script)
6   print("Your first variable is:", first)
7   print("Your second variable is:", second)
8   print("Your third variable is:", third)

我建議你只輸入一兩行代碼，然后執行以下操作：

1. 再次保存你的文件。按下CTRL-s是最簡單的方法，但如果你記不住，可以使用菜單。這次它不應該要求你“重命名”文件，而應該直接保存。

2. 你的文件現在保存在你的項目目錄中。如果你還記得*First Steps*部分，你創建了一個目錄在~/Projects/lpythw，當你運行jupyter-lab時，你首先cd ~/Projects/lpythw。

3. 現在打開一個新的終端（在 Windows 上是 PowerShell），再次輸入cd ~/Projects/lpythw/以進入該終端。

4. 最后，輸入python ex13.py first 2nd 3rd。（在終端中輸入時不要加句號。）當你這樣做時，你應該看到絕對什么都沒有！是的，這點非常重要。你只輸入了一兩行代碼，所以在你的代碼中沒有print語句。這意味著它不會打印任何內容，但這是好事。如果出現錯誤，那么停下來弄清楚你做錯了什么。你是不是打錯了那行代碼？你運行了python ex13.py嗎？那也是錯誤的。你必須運行python ex13.py first 2nd 3rd。（再次強調，不要在終端中加句號。）

如果你迷路了

如果你對自己所在位置感到困惑，可以在 macOS 上使用open命令，在 Windows 上使用start命令。如果你輸入以下內容：

1   open .

在 macOS 電腦上，它會打開一個窗口，顯示當前終端所在位置的內容。當你輸入以下內容時，同樣的情況也會發生：

1   start .

在 Windows 中在 PowerShell 中。這樣做將幫助你將“文件在窗口中的文件夾中”這個概念連接到“文件在終端（PowerShell）中的目錄中”。

如果這是你第一次看到這個建議，那么回到*First Steps*部分，重新查看它，因為你似乎錯過了這個重要概念。

代碼描述

在第1行，我們有一個稱為“import”的東西。這是你從 Python 功能集中添加功能到你的腳本的方式。Python 不會一次性給你所有功能，而是要求你說出你打算使用的功能。這樣可以使你的程序保持簡潔，同時也作為其他程序員閱讀你代碼時的文檔。

argv是“參數變量”，在編程中是一個非常標準的名稱，你會發現它在許多其他語言中被使用。這個變量保存你在運行 Python 腳本時傳遞的參數。在練習中，你將有機會更多地玩弄它，并看看會發生什么。

第 3 行“unpacks” argv，這樣，它不再保存所有參數，而是被分配給四個你可以使用的變量：script、first、second和third。這可能看起來很奇怪，但“unpack”可能是最好的描述它的詞。它只是說，“取出argv中的任何內容，解包它，并按順序分配給左邊的所有這些變量。”

之后我們就像平常一樣打印它們出來。

等一下！features 還有另一個名字

我在這里稱它們為“features”（你import來使你的 Python 程序做更多事情的小東西），但沒有人稱它們為 features。我只是用這個名字是因為我需要欺騙你學習它們是什么，而不帶有行話。在繼續之前，你需要學習它們的真實名稱：modules。

從現在開始，我們將稱這些為“features”，我們importmodules。我會說像，“你想要導入sys模塊。”其他程序員也稱它們為“庫”，但讓我們堅持使用模塊。

你應該看到的內容

警告！

注意！你一直在沒有命令行參數運行 Python 腳本。如果你只輸入python3 ex13.py，那么你做錯了！請仔細看我是如何運行的。每當看到使用 argv 時都適用。

當你輸入完所有代碼后，它應該像這樣最終運行（而且你必須傳遞三個命令行參數）：

1   $ python ex13.py first 2nd 3rd
2   The script is called: ex13.py
3   Your first variable is: first
4   Your second variable is: 2nd
5   Your third variable is: 3rd

這是你使用不同參數進行幾次運行時應該看到的內容：

1   $ python ex13.py stuff things that
2   The script is called: ex13.py
3   Your first variable is: stuff
4   Your second variable is: things
5   Your third variable is: that

這里有一個更多的例子，顯示它可以是任何東西：

1   $ python ex13.py apple orange grapefruit
2   The script is called: ex13.py
3   Your first variable is: apple
4   Your second variable is: orange
5   Your third variable is: grapefruit

你實際上可以用任何三個你想要的東西替換first、2nd和3rd。

如果你沒有正確運行它，那么你會得到這樣的錯誤：

命令失敗：python ex13.py first 2nd Traceback (most recent call last): File “/Users/zedshaw/Project s/learncodethehardway.com/private/db/modules/learn-python-the-hard-way-5e-section-1/code/ex13.py”，第 3 行，在腳本、第一個、第二個、第三個 = argv ValueError: not enough values to unpack (expected 4, got 3)

當你在運行時沒有在命令中放足夠的參數時會發生這種情況（在這種情況下只有first 2nd）。注意，當我運行它時，我給了它first 2nd，這導致它出現了一個關于“需要超過 3 個值來解包”的錯誤，告訴你沒有給足夠的參數。

學習練習

1. 嘗試給你的腳本提供少于三個參數。看看你會得到什么錯誤？看看你能否解釋清楚。

2. 編寫一個參數較少的腳本和一個參數較多的腳本。確保給解包的變量起一個好名字。

3. 結合input和argv編寫一個腳本，從用戶那里獲取更多輸入。不要想得太多。只需使用argv獲取一些內容，然后使用input從用戶那里獲取其他內容。

4. 記住模塊給你提供了功能。模塊。模塊。記住這一點，因為我們以后會用到它。

常見學生問題

當我運行它時，我得到 ValueError: need more than 1 value to unpack。記住一個重要的技能是注意細節。如果你看一下你應該看到的內容部分，你會看到我是如何在命令行上運行腳本的。你應該完全復制我運行它的方式。那里還有一個巨大的警告解釋了你剛剛犯的錯誤，所以請再次注意。

argv和 input() 之間有什么區別？ 區別在于用戶需要在哪里提供輸入。如果他們在命令行上給你的腳本輸入，那么使用argv。如果你希望他們在腳本運行時使用鍵盤輸入，那么使用input()。

命令行參數是字符串嗎？ 是的，它們作為字符串傳入，即使你在命令行上輸入了數字。使用int()來轉換它們，就像使用int(input())一樣。

你如何使用命令行？ 你應該已經學會如何快速流利地使用它了，但如果你在這個階段需要學習，那么請閱讀附錄 A，“命令行速成課程”。

我無法將 argv 與 input() 結合起來。不要想得太多。只需在腳本末尾加上兩行，使用input()獲取一些內容然后打印出來。從那里開始嘗試更多同時使用兩者的方法。

為什么我不能這樣做 input('? ') = x？ 因為這是反向的工作方式。按照我的方式去做，它就會起作用。

為什么你要讓我一次只輸入一行？ 初學者和專業人士最常犯的錯誤就是他們輸入一大塊代碼，運行一次，然后因為所有的錯誤而哭泣。編程語言中的錯誤令人沮喪，并經常指向源代碼中錯誤的位置。如果你一次只輸入幾行代碼，你會更頻繁地運行代碼，當出現錯誤時，你知道這可能是你剛剛輸入的那幾行代碼有問題。當你輸入 100 行代碼時，你將花費接下來的 5 天來尋找所有的錯誤，最終放棄。省點麻煩，一次只輸入一點點。這就是我和大多數有能力的程序員在現實生活中所做的。

練習 14：提示和傳遞

讓我們做一個練習，結合使用argv和input來詢問用戶特定的事情。你將在下一個練習中需要這個，那里你將學習如何讀寫文件。在這個練習中，我們將稍微不同地使用input，讓它打印一個簡單的>提示。

列表 14.1: ex14.py

 1   from sys import argv23   script, user_name = argv4   prompt = '> '56   print(f"Hi {user_name}, I'm the {script} script.")7   print("I'd like to ask you a few questions.")8   print(f"Do you like me {user_name}?")9   likes = input(prompt)
10
11   print(f"Where do you live {user_name}?")
12   lives = input(prompt)
13
14   print("What kind of computer do you have?")
15   computer = input(prompt)
16
17   print(f"""
18   Alright, so you said {likes} about liking me.
19   You live in {lives}. Not sure where that is.
20   And you have a {computer} computer. Nice.
21   """)

我們創建一個名為prompt的變量，設置為我們想要的提示，并將其提供給input，而不是一遍又一遍地輸入。現在，如果我們想要將提示更改為其他內容，我們只需在這一個地方更改它，然后重新運行腳本。非常方便。

警告！

記住，你必須像在 Exercise 13 中那樣做，并使用終端使其工作。這將是一段時間內的最后一次，但重要的是要知道如何從終端運行代碼，因為這是運行 Python 代碼的一種常見方式。

你應該看到的內容

運行此代碼時，請記住必須為argv參數提供你的名字。

 1   $ python ex14.py zed2   Hi zed, I'm the ex14.py script.3   I'd like to ask you a few questions.4   Do you like me zed?5   > Yes6   Where do you live zed?7   > San Francisco8   What kind of computer do you have?9   > Tandy 1000
10
11   Alright, so you said Yes about liking me.
12   You live in San Francisco. Not sure where that is.
13   And you have a Tandy 1000 computer. Nice.

學習練習

1. 找出 Zork 和 Adventure 是什么游戲。嘗試找到一份副本并玩一玩。

2. 將prompt變量完全更改為其他內容。

3. 添加另一個參數，并在你的腳本中使用它，就像在上一個練習中使用first, second = ARGV一樣。

4. 確保你理解我是如何將"""樣式的多行字符串與{}格式激活器結合在一起作為最后一個打印的。

5. 嘗試找到在 Jupyter 中運行此代碼的方法。你可能需要用其他東西替換使用argv的代碼，比如一些變量。

常見學生問題

當我運行這個腳本時，我收到 SyntaxError: invalid syntax。再次強調，你必須在命令行上正確運行它，而不是在 Python 內部。如果你輸入python3然后嘗試輸入python3 ex14.py Zed，它將失敗，因為你是在Python 內部運行 Python。關閉窗口，然后只需輸入python3 ex14.py Zed。

我不明白你所說的改變提示是什么意思。看看變量prompt = '> '。將其更改為其他值。你知道這個；這只是一個字符串，你已經做了 13 個練習來創建它，所以花點時間弄清楚。

我收到錯誤 ValueError: need more than 1 value to unpack。記得我說過你需要查看你應該看到的內容（WYSS）部分并復制我做的嗎？你需要在這里做同樣的事情，關注我如何輸入命令以及為什么要有命令行參數。

我如何從 IDLE 運行這個？ 不要使用 IDLE。它很糟糕。

我可以為 prompt 變量使用雙引號嗎？ 完全可以。試試看吧。

你有一臺 Tandy 電腦嗎？ 我小時候有過。

當我運行它時，我收到 NameError: name 'prompt' is not defined。你要么拼錯了prompt變量的名稱，要么忘記了那一行。回去逐行比較我的代碼和你的代碼，從腳本底部到頂部。每當你看到這個錯誤時，意味著你拼寫錯了或忘記創建變量。

練習 15：讀取文件

你知道如何使用input或argv從用戶那里獲取輸入。現在你將學習如何從文件中讀取。你可能需要仔細研究這個練習，以理解發生了什么，所以仔細做練習并記住你的檢查。如果不小心處理文件，這是一種擦除你的工作的簡單方法。

這個練習涉及編寫兩個文件。一個是你將運行的通常的ex15.py文件，但另一個名為ex15_sample.txt。這第二個文件不是一個腳本，而是一個我們將在我們的腳本中讀取的純文本文件。以下是該文件的內容：

1   This is stuff I typed into a file.
2   It is really cool stuff.
3   Lots and lots of fun to have in here.

我們想要在我們的腳本中“打開”那個文件并將其打印出來。然而，我們不想將名為ex15_sample.txt的文件名直接“硬編碼”到我們的腳本中。所謂“硬編碼”是指將應該來自用戶的一些信息作為字符串直接放在我們的源代碼中。這是不好的，因為我們希望以后加載其他文件。解決方案是使用argv或input詢問用戶要打開哪個文件，而不是將文件名“硬編碼”到腳本中。

列表 15.1：ex15.py

 1   from sys import argv23   script, filename = argv45   txt = open(filename)67   print(f"Here's your file {filename}:")8   print(txt.read())9
10   print("Type the filename again:")
11   file_again = input("> ")
12
13   txt_again = open(file_again)
14
15   print(txt_again.read())

這個文件中有一些花哨的東西，所以讓我們快速地分解一下。

第 1-3 行使用argv獲取文件名。接下來是第 5 行，我們使用一個新命令：open。現在運行pydoc open并閱讀說明。注意，就像你自己的腳本和input一樣，它接受一個參數并返回一個可以設置為你自己變量的值。你剛剛打開了一個文件。

第 7 行打印了一條小消息，但在第 8 行，我們有一些非常新穎和令人興奮的東西。我們在txt上調用了一個名為read的函數。你從open得到的是一個file，它也有你可以給它的命令。你可以使用.（點）命令一個文件，命令的名稱和參數，就像open和input一樣。不同之處在于txt.read()表示，“嘿txt！執行你的讀取命令，不帶參數！”

文件的其余部分基本相同，但我們將在學習練習部分留給你來分析。

你應該看到什么

警告！

注意！我說了要注意！你之前只是用腳本的名稱運行腳本，但現在你正在使用argv，你必須添加參數。看看以下示例的第一行，你會看到我執行python ex15.py ex15_sample.txt來運行它。在ex15.py腳本名稱后面看到額外的參數ex15_sample.txt。如果你不輸入，你會得到一個錯誤，所以要注意！

我創建了一個名為ex15_sample.txt的文件并運行了我的腳本。

 1   Here's your file ex15_sample.txt:2   This is stuff I typed into a file.3   It is really cool stuff.4   Lots and lots of fun to have in here.567   Type the filename again:8   > ex15_sample.txt9   This is stuff I typed into a file.
10   It is really cool stuff.
11   Lots and lots of fun to have in here.

學習練習

這是一個很大的飛躍，所以在繼續之前，請確保你盡力完成這些學習練習。

1. 在每一行上面，用英語寫出那行代碼的作用。

2. 如果你不確定，向別人尋求幫助或在網上搜索。很多時候搜索“python3 THING”會找到關于 Python 中那個 THING 做什么的答案。嘗試搜索“python3 open”。

3. 我在這里使用了“命令”這個詞，但命令也被稱為“函數”和“方法”。你將在本書后面學習有關函數和方法的知識。

4. 刪除使用input并再次運行腳本的 10-15 行。

5. 只使用input，嘗試以這種方式運行腳本。為什么有一種獲取文件名的方式比另一種更好？

6. 啟動python3以啟動python3 shell，并從提示符中像在這個程序中一樣使用open。注意你如何可以在python3中打開文件并運行read？

7. 讓你的腳本也在txt和txt_again變量上調用close()。在完成文件操作后關閉文件是很重要的。

常見學生問題

txt = open(filename)是否返回文件的內容？ 不，它不會。它實際上創建了一個叫做“文件對象”的東西。你可以把文件想象成 50 年代大型計算機上看到的舊磁帶驅動器，甚至像今天的 DVD 播放器。你可以在其中移動，然后“讀取”它們，但 DVD 播放器不是 DVD，就像文件對象不是文件內容一樣。

我無法像你在第 7 個學習任務中說的那樣在終端/PowerShell 中輸入代碼。首先，從命令行中只需輸入python3并按 Enter。現在你在python3中，就像我們之前做過幾次一樣。然后你可以輸入代碼，Python 會逐段運行它。嘗試一下。要退出，請輸入quit()并按 Enter。

為什么我們打開文件兩次時沒有錯誤？ Python 不會限制你多次打開文件，有時這是必要的。

from sys import argv是什么意思？ 現在只需理解sys是一個包，這個短語只是說從那個包中獲取argv功能。你以后會學到更多。

我將文件名放在 script, ex15_sample.txt = argv 中，但它不起作用。不，這不是你應該做的。確保代碼與我的完全一樣，然后像我一樣從命令行運行它。你不需要放文件名進去；讓 Python 放進去。

練習 16：讀寫文件

如果你做了上一個練習的學習練習，你應該看到各種可以給文件的命令（方法/函數）。這是我希望你記住的命令列表：

• close – 關閉文件。就像文本編輯器或文字處理器中的文件->保存..一樣。

• read – 讀取文件的內容。你可以將結果賦值給一個變量。

• readline – 讀取文本文件的一行。

• truncate – 清空文件。如果你關心文件的話要小心。

• write('stuff') – 將“stuff”寫入文件。

• seek(0) – 將讀/寫位置移動到文件的開頭。

記住每個命令的一種方法是想象一下黑膠唱片、磁帶、VHS 磁帶、DVD 或 CD 播放器。在計算機的早期，數據存儲在這些媒體上，所以許多文件操作仍然類似于一個線性存儲系統。磁帶和 DVD 驅動器需要“尋找”到一個特定的位置，然后你可以在那個位置讀取或寫入。今天我們有操作系統和存儲介質模糊了隨機存取內存和磁盤驅動器之間的界限，但我們仍然使用一個必須移動的線性磁帶的讀/寫頭的舊概念。

目前，這些是你需要知道的重要命令。其中一些需要參數，但我們并不真的關心。你只需要記住write需要一個你想寫入文件的字符串參數。

讓我們利用其中的一些內容制作一個簡單的文本編輯器：

列表 16.1: ex16.py

 1   filename = "test.txt"23   print(f"We're going to erase {filename}.")4   print("If you don't want that, hit CTRL-C *(*^C*)*.")5   print("If you do want that, hit RETURN.")67   input("?")89   print("Opening the file...")
10   target = open(filename, 'w')
11
12   print("Truncating the file. Goodbye!")
13   target.truncate()
14
15   print("Now I'm going to ask you for three lines.")
16
17   line1 = input("line 1: ")
18   line2 = input("line 2: ")
19   line3 = input("line 3: ")
20
21   print("I'm going to write these to the file.")
22
23   target.write(line1)
24   target.write("\n")
25   target.write(line2)
26   target.write("\n")
27   target.write(line3)
28   target.write("\n")
29
30   print("And finally, we close it.")
31   target.close()

那是一個很大的文件，可能是你輸入的最大的文件。所以慢慢來，檢查一下，經常運行，慢慢來。一個技巧是一次運行一部分。先運行 1-2 行，然后再運行兩行，再運行幾行，直到全部完成并運行。

你應該看到的內容

實際上你會看到兩件事。首先是你新腳本的輸出：

 1   We're going to erase test.txt.2   If you don't want that, hit CTRL-C (^C).3   If you do want that, hit RETURN.4   ?5   Opening the file...6   Truncating the file. Goodbye!7   Now I'm going to ask you for three lines.8   line 1:  Mary had a little lamb9   line 2:  Its fleece was white as snow
10   line 3:  It was also tasty
11   I'm going to write these to the file.
12   And finally, we close it.

現在，打開你創建的文件（在我的案例中是test.txt），使用 Jupyter 的左側面板查看一下。整潔，對吧？

學習練習

1. 如果你不理解這個，回過頭來，使用注釋技巧來弄清楚。在每一行上加一個簡單的英文注釋將幫助你理解，或者至少讓你知道你需要更多地研究。

2. 編寫一個類似于上一個練習 14 的.py腳本，使用read（練習 15）和argv（練習 13）來讀取你剛剛創建的文件。確保你在終端/PowerShell 中運行而不是在 Jupyter 中。

3. 這個文件中有太多的重復。使用字符串、格式和轉義來用一個target.write()命令打印出line1、line2和line3，而不是六個命令。

4. 找出為什么我們需要將'w'作為open的額外參數傳遞。提示：open試圖通過讓你明確表示你要寫入一個文件來保持安全。

5. 如果以**'w’模式打開文件，那么你真的需要target.truncate()嗎？閱讀 Python 的open**函數的文檔，看看這是否屬實。

常見學生問題

在使用 ‘w’ 參數時， truncate() 是必需的嗎？ 參見學習任務 5。

‘w’ 代表什么？ 實際上，它只是一個包含文件模式字符的字符串。如果使用**‘w’，那么你是在說“以‘寫’模式打開此文件”，這就是’w’** 字符的原因。還有**'r’代表“讀取”，‘a’**代表追加，以及這些的修飾符。

我可以使用哪些文件模式的修飾符？ 現在最重要的是要知道**+修飾符，這樣你就可以使用’w+'，'r+‘和’a+’**。這將以讀取和寫入模式打開文件，并根據使用的字符，以不同的方式定位文件。

只需執行 open(filename) 就會以 ‘r’ （讀取）模式打開文件嗎？ 是的，這是**open()**函數的默認設置。

練習 17：更多文件

現在讓我們做更多關于文件的事情。我們將編寫一個 Python 腳本將一個文件復制到另一個文件。這將非常簡短，但會給你關于文件的其他操作想法。

列表 17.1：ex17.py

 1   from sys import argv2   from os.path import exists34   from_file = "test.txt"5   to_file = "new_test.txt"67   print(f"Copying from {from_file} to {to_file}")89   # we could do these two on one line, how?
10   in_file = open(from_file)
11   indata = in_file.read()
12
13   print(f"The input file is {len*(*indata*)*} bytes long")
14
15   print(f"Does the output file exist? {exists*(*to_file*)*}")
16   print("Ready, hit RETURN to continue, CTRL-C to abort.")
17   input()
18
19   out_file = open(to_file, 'w')
20   out_file.write(indata)
21
22   print("Alright, all done.")
23
24   out_file.close()
25   in_file.close()

你應該立即注意到我們import了另一個方便的命令叫做exists。如果文件存在，它會返回True，基于它的名稱作為字符串參數。如果不存在，則返回False。我們將在本書的后半部分使用這個函數來做很多事情，但現在你應該看看如何導入它。

使用import是一種獲取其他更好（通常是）程序員編寫的大量免費代碼的方法，這樣你就不必自己編寫它。

你應該看到的內容

就像你的其他腳本一樣，用兩個參數運行這個腳本：要復制的文件和要復制到的文件。我將使用一個名為test.txt的簡單測試文件：

1   Copying from test.txt to new_test.txt
2   The input file is 70 bytes long
3   Does the output file exist? True
4   Ready, hit RETURN to continue, CTRL-C to abort.
5
6   Alright, all done.

它應該適用于任何文件。嘗試更多文件并看看會發生什么。只是要小心不要破壞重要文件。

警告！

你看到我用echo制作文件和cat顯示文件的技巧了嗎？你可以在附錄 A“命令行速成課程”中學習如何做到這一點。

學習練習

1. 這個腳本真的很煩人。在復制之前沒有必要詢問你，而且在屏幕上打印出太多內容。嘗試通過刪除功能使腳本更加友好易用。

2. 看看你能把腳本做得多短。我可以讓這一行很長。

3. 注意在“你應該看到的內容”末尾我使用了一個叫做cat的東西？這是一個“連接”文件的舊命令，但主要是一個將文件打印到屏幕的簡單方法。輸入man cat來了解它。

4. 找出為什么你需要在代碼中寫out_file.close()。

5. 去了解一下 Python 的import語句，并開始使用python3嘗試一下。嘗試導入一些東西，看看你是否能做對。如果做不對也沒關系。

6. 嘗試將這段代碼轉換為一個ex17.py腳本，你可以再次從終端/PowerShell 運行。如果你已經厭倦了 Jupyter 的文本編輯器，那么可以查看*First Steps*部分提到的編輯器。

常見學生問題

為什么 'w' 要加引號？ 那是一個字符串。你已經使用字符串一段時間了。確保你知道什么是字符串。

不可能讓這一行變成一行！ 那個；取決于；你；如何；定義；一行；代碼。

感覺這個練習很難是正常的嗎？ 是的，這是完全正常的。直到 Exercise 36，甚至可能在你完成這本書并用 Python 做一些東西之后，編程可能才會“點亮”。每個人都不同，所以繼續前進，繼續復習你遇到困難的練習，直到理解為止。要有耐心。

len()函數是做什么的？ 它獲取你傳遞給它的字符串的長度，然后將其作為一個數字返回。試著玩一下。

當我試圖縮短這個腳本時，在結尾關閉文件時出現錯誤。你可能做了類似這樣的事情，indata = open(from_file).read()，這意味著當你到達腳本結尾時就不需要再執行in_file.close()。一旦那一行運行，Python 應該已經關閉了它。

我收到一個 Syntax:EOL while scanning string literal 錯誤。你忘記用引號正確結束一個字符串。再去看看那一行。

模塊 2：編程基礎

練習 18：名稱、變量、代碼、函數

大標題，對吧？我將要向你介紹函數！Dum dum dah！每個程序員都會滔滔不絕地談論函數以及它們如何工作和做什么，但我會給你一個你現在可以使用的最簡單的解釋。

函數有三個作用：

1. 它們命名代碼片段的方式就像變量命名字符串和數字一樣

2. 它們接受參數的方式就像 Python 腳本在練習 13 中接受argv

3. 使用 1 和 2，它們讓你制作自己的“迷你腳本”或“微型命令”

你可以像這樣在 Python 中使用def來創建一個空函數：

列表 18.1: ex18_demo.py

1   def do_nothing():
2       pass

這創建了函數，但pass關鍵字告訴 Python 這個函數是空的。要使函數執行某些操作，你需要在def行下添加函數的代碼，但要縮進四個空格：

列表 18.2: ex18_demo.py

1   def do_something():
2       print("I did something!")

這實際上將代碼print("I did something!")分配給名稱do_something，這樣你以后可以再次在代碼中使用它，類似于其他變量。使用你定義的函數是如何“運行”它或“調用”它的：

列表 18.3: ex18_demo.py

1   def do_something():
2       print("I did something!")
3
4   # now we can call it by its name
5   do_something()

當底部的do_something()運行時，Python 執行以下操作：

1. 在 Python 的內存中找到do_something函數

2. 看到你用()調用它

3. 跳轉到def do_something()行的位置

4. 運行def下的代碼行，這里是一行：print("I did

5. [rcurvearrowse] something!" 當def下的代碼完成時，Python 退出函數并跳回到你調用它的位置

6. 然后它繼續，這在這種情況下是代碼的結尾

對于這個練習，你只需要了解一個概念，那就是函數的“參數”：

列表 18.4: ex18_demo.py

1   def do_more_things(a, b):
2       print("A IS", a, "B IS", b)
3
4   do_more_things("hello", 1)

在這種情況下，我有兩個參數（也稱為“參數”）傳遞給do_more_things函數：a和b。當我使用do_more_things("hello", 1)調用這個函數時，Python 臨時賦值a="hello"和b=1，然后調用函數。這意味著，在函數內部a和b將具有這些值，并且當函數退出時它們將消失。這有點像這樣：

列表 18.5: ex18_demo.py

1   def do_more_things(a, b):
2       a = "hello"
3       b = 1
4       print("A IS", a, "B IS", b)

請記住這并不完全準確，因為如果你用不同的參數調用do_more_things，a和b會不同。這只是一個例子，一次你用do_more_things ("hello", 1)調用它。

練習代碼

現在花點時間在 Jupyter 中玩耍，創建自己的函數并在嘗試這段代碼之前調用它們。確保你理解代碼如何跳轉到函數，然后再跳回來。然后我會讓你創建四個不同的函數，然后我會展示它們之間的關系：

列表 18.6: ex18.py

1   # this one is like your scripts with argv
2   def print_two(*args):
3       arg1, arg2 = args
4       print(f"arg1: {arg1}, arg2: {arg2}")
5
6   # ok, that *args is actually pointless, we can just do this
7   def print_two_again(arg1, arg2):
8       print(f"arg1: {arg1}, arg2: {arg2}")
9
10   # this just takes one argument
11   def print_one(arg1):
12       print(f"arg1: {arg1}")
13
14   # this one takes no arguments
15   def print_none():
16       print("I got nothin'.")
17
18
19   print_two("Zed","Shaw")
20   print_two_again("Zed","Shaw")
21   print_one("First!")
22   print_none()

讓我們分解第一個函數print_two，這與你從制作腳本中已經了解的內容最相似：

1. 首先，我們告訴 Python 我們要使用def來制作一個函數，其中def代表“定義”。

2. 在與def相同的行上，我們給函數命名。在這種情況下，我們只是稱之為“print_two”，但也可以是“peanuts”。這不重要，除非你的函數應該有一個簡短的名稱，說明它的作用。

3. 然后我們告訴它我們想要*args（星號參數），這很像你的argv參數，但用于函數。這必須放在()括號內才能起作用。

4. 然后我們以:（冒號）結束這一行并開始縮進。

5. 冒號之后，所有縮進四個空格的行都將與此名稱print_two相關聯。我們的第一個縮進行是一個解壓參數的行，與您的腳本相同。

6. 為了演示它的工作原理，我們打印出這些參數，就像在腳本中一樣。

print_two的問題在于這不是制作函數的最簡單方法。在 Python 中，我們可以跳過整個解壓參數的過程，直接在()內部使用我們想要的名稱。這就是print_two_again的作用。

在那之后，你有一個在print_one中接受一個參數的函數示例。

最后，你有一個沒有參數的函數print_none。

警告！

這非常重要。如果現在這還不太明白，不要灰心。我們將做一些練習，將函數與你的腳本鏈接起來，并向你展示如何制作更多函數。現在，當我說“函數”時，只需繼續思考“小型腳本”，并繼續嘗試。

你應該看到的內容

如果你運行ex18.py，你應該看到：

1   arg1: Zed, arg2: Shaw
2   arg1: Zed, arg2: Shaw
3   arg1: First!
4   I got nothin'.

立即你就能看到函數是如何工作的。注意你使用函數的方式就像你使用exists、open和其他“命令”一樣。事實上，我一直在欺騙你，因為在 Python 中，這些“命令”只是函數。這意味著你可以制作自己的命令并在腳本中使用它們。

學習練習

為后續練習創建一個函數清單。將這些檢查寫在一張索引卡上，并在完成其余練習時或直到你覺得不再需要索引卡時保留在身邊：

1. 你是否以def開始函數定義？

2. 你的函數名稱只包含字符和_（下劃線）字符嗎？

3. 你是否在函數名稱后面放置了(（開括號）？

4. 你是否在(（開括號）后面用逗號分隔放置了參數？

5. 你是否使每個參數都是唯一的（即沒有重復的名稱）？

6. 你是否在參數后面放置了):（一個閉括號和一個冒號）？

7. 你是否將所有想要放在函數中的代碼都縮進了四個空格？不多也不少。

8. 你是否通過取消縮進（我們稱之為“去縮進”）來“結束”函數？

當你運行（“使用”或“調用”）一個函數時，請檢查以下事項：

1. 你是否通過鍵入函數名稱來調用/使用/運行此函數？

2. 你是否在名稱后面放置了(字符以運行它？

3. 你是否將想要的值放在括號內，用逗號分隔？

4. 你是否以）字符結束了函數調用？

在剩下的課程中使用這兩個檢查表，直到你不再需要它們為止。

最后，對自己重復幾次：

1   "To 'run,' 'call,' or 'use' a function all mean the same thing."

常見學生問題

函數名允許使用什么？ 與變量名相同。任何不以數字開頭且由字母、數字和下劃線組成的內容都可以。

在 *args 中的 * 是做什么的？ 這告訴 Python 獲取函數的所有參數，然后將它們作為列表放入args中。就像你一直在使用的argv，但用于函數。除非特別需要，通常不會經常使用。

這感覺真的很無聊和單調。這是好事。這意味著你開始擅長輸入代碼并理解它的作用。為了讓它不那么無聊，把我告訴你要輸入的所有內容都故意打破。