python 入門到實踐 ----筆記

阿新 • • 發佈：2018-06-07

python

第一部分基礎知識

第 1 章運行第一個程序打印消息 “Hello world!” 。
第 2 章變量中存儲信息以及如何使用文本和數字。
第 3 4 章列表使用列表能夠在一個變量中存儲任意數量的信息，從而高效地處理數據：只需幾行代碼，你就能夠處理數百、數千乃至數百萬個值。
第 5 章 if 條件判斷
第 6 章使用 Python 字典，將不同的信息關聯起來。與列表一樣，你也可以根據需要在字典中存儲任意數量的信息。
第 7 章交互式程序 while 循環
第 8 章函數。函數是執行特定任務的被命名的代碼塊
第 9 章類，它讓你能夠模擬實物，如小狗、小貓、人、汽車、火箭等，讓你的代碼能夠表示任何真實或抽象的東西。

第 10 章如何使用文件，以及如何處理錯誤以免程序意外地崩潰。你需要在程序關閉前保存數據，並在程序再次運行時讀取它們。你將學習 Python 異常，它們讓你能夠未雨綢繆，從而讓程序妥善地處理錯誤。
第 11 章為代碼編寫測試，以核實程序是否像你期望的那樣工作。這樣，擴展程序時，你就不用擔心引入新的 bug要想脫離初級程序員的陣容，躋身於中級程序員的行列，測試代碼是你必須掌握的基本技能之一。

第一章第一個python程序

[root@localhost ~/python]# python #進入python2.7交互式界面相關版本以及提示信息
Python 2.7.5 (default, Aug 4 2017, 00:39:18)

[GCC 4.8.5 20150623 (Red Hat 4.8.5-16)] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>> print("Hello Python World") #也可將代碼保存在文件中中使用python命令運行 .py文件
Hello Python World

第二章變量以及簡單數據類型：字符串數字

2.1變量命名規範

1.變量名只能包含字母、數字和下劃線。變量名可以字母或下劃線打頭，但不能以數字打頭，

例如，可將變量命名為 message_1 ，但不能將其命名為 1_message 。
2.變量名不能包含空格，但可使用下劃線來分隔其中的單詞。例如，變量名 greeting_message 可行，但變量名 greeting message 會引發錯誤。
3.不要將 Python 關鍵字和函數名用作變量名，即不要使用 Python 保留用於特殊用途的單詞，如 print （請參見附錄 A.4 ）。
4.變量名應既簡短又具有描述性。例如， name 比 n 好， student_name 比 s_n 好， name_length 比 length_of_persons_name 好。

慎用小寫字母 l 和大寫字母 O ，因為它們可能被人錯看成數字 1 和 0 。

    # vim hello_world.py
    message = "hello world"   #定義一個變量
    print(message)
    message = "hello python world"
    print(message)

    輸出信息：
    hello world
    hello python world
    python將記錄變量最新值

2.2字符串

pyhon 中，用引號括起的都是字符串，其中的引號可以是單引號，也可以是雙引號。例如：
print(‘I told my friend, "Python is my favorite language!"‘)
print("The language ‘Python‘ is named after Monty Python, not the snake.")
print("One of Python‘s strengths is its diverse and supportive community.")

調用一些簡單的方法進行處理格式: 實例名.方法名

    >>> name = "test_name"
    >>> print(name.title())
    Test_Name
    >>> print(name.upper())
    TEST_NAME
    >>> print(name.lower())
    test_name
    其他方法:
    rstrip()  刪除字符串右側空白
    lstrip()  刪除左側空白
    strip()   刪除兩端空白

字符串合並或拼接用+號
```
     制表符:"\t"   
     換行符:"\n"
    first_name = "ada"
    last_name = "lovelace"
    full_name = first_name + " " + last_name
    print("Hello, " + full_name.title() + "!")
    print("Languages:\nJavaScript\n\t Python")
```
註意:在 Python 2 中，無需將要打印的內容放在括號內。
從技術上說， Python 3 中的 print 是一個函數，因此括號必不可少。有些 Python 2 print 語句也包含括號，但其行為與 Python 3 中
稍有不同。簡單地說，在 Python 2 代碼中，有些 print 語句包含括號，有些不包含。
函數的使用方式 #函數名(參數名)
使用str()函數
age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)

2.3數字

整數 :+ - x / 取余:% 乘方:*
實例:(2 + 3) 4
浮點數 Python 將帶小數點的數字都稱為浮點數
從很大程度上說，使用浮點數時都無需考慮其行為。你只需輸入要使用的數字， Python 通常都會按你期望的方式處理它們

2.4添加註釋

註釋用井號（ # ）標識。井號後面的內容都會被 Python 解釋器忽略，如下所示：
#向大家問好
print("Hello Python people!")

2.5python 之禪 .指導原則

編程語言 Perl 曾在互聯網領域長期占據著統治地位，早期的大多數交互式網站使用的都是 Perl 腳本。彼時， “ 解決問題的辦法有多個 ” 被 Perl 社區奉為座右銘。這種理念一度深受大家的喜愛，因為這種語言固有的靈活性使得大多數問題都有很多不同的解決之道。在開發項目期間，這種靈活性是可以接受的，但大家最終認識到，過於強調靈活性會導致大型項目難以維護：要通過研究代碼搞清楚當時解決復雜問題的人是怎麽想的，既困難又麻煩，還會耗費大量的時間

        import this

    The Zen of Python, by Tim Peters
    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren‘t special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you‘re Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it‘s a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let‘s do more of those!
    蒂姆彼得斯的Python的禪宗
    美麗勝於醜陋。
    顯式比隱式更好。
    簡單勝於復雜。
    復雜比復雜更好。
    Flat比嵌套更好。
    稀疏比密集好。
    可讀性計數。
    特殊情況不足以打破規則。
    雖然實用性勝過純凈。
    錯誤不應該默默通過。
    除非明確沈默。
    面對歧義，拒絕猜測的誘惑。
    應該有一個 - 而且最好只有一個 - 明顯的做法。
    盡管這種方式一開始可能並不明顯，除非你是荷蘭人。
    現在比永遠好。
    雖然現在永遠不會比*正確*更好。
    如果實現很難解釋，這是一個壞主意。
    如果實現很容易解釋，這可能是一個好主意。
    命名空間是一個好主意 - 讓我們做更多的這些！

第三章列表( 索引元素的值組織列表)

3.1列表（索引元素增刪改查）

一系列按特定序列排列的元素組成。給列表啟一個表示復數的名稱是個不錯的選擇。在用方括號[ ] 來表示列表，並用逗號來分隔其中的元素。
下面是一個簡單的列表示例，這個列表包含幾種自行車：
bicycles = [‘trek‘, ‘cannondale‘, ‘redline‘, ‘specialized‘]
print(bicycles)

訪問列表元素需要指定元素的位置或索引
print(bicycles[0])
索引從0開始不是1
print(bicycles[3]) ##要訪問第四個列表元素，可使用索引 3
print(bicycles[-1].title()) ##對最後一個元素使用title()方法

元素的增刪改

    增：
        列表末尾添加元素 方法 append() 將元素 添加到了列表末尾，而不影響列表中的其他所有元素：
        motorcycles = []  ##定義空列表
        motorcycles.append(‘honda‘)  
        motorcycles.append(‘yamaha‘)
        motorcycles.append(‘suzuki‘)
        print(motorcycles)
    插入：
        使用方法insert()可以在列表的任意位置添加元素，但是需要指定索引以及值。
        motorcycles.insert(0, ‘ducati‘)  #指定索引以及值
        motorcycles = [‘honda‘, ‘yamaha‘, ‘suzuki‘]
        print(motorcycles)
        motorcycles[0] = ‘ducati‘
        print(motorcycles)
    刪：根據位置或值來刪除列表中的元素。
* del 語句  條件是知道其索引，刪除後，你就無法再訪問它     
          del motorcycles[1]
* pop() 方法：彈出列表末尾的元素 列表就像一個棧，而刪除列表末尾的元素相當於彈出棧頂元素。將元素從列表中刪除，並接著使用它的值將其保存在變量中
            popped_motorcycle = motorcycles.pop() 
            first_owned = motorcycles.pop(0) ##指定索引刪除特定的值
* remove()方法：   知道要刪除的元素的值，可使用方法 remove() 
            motorcycles = [‘honda‘, ‘yamaha‘, ‘suzuki‘, ‘ducati‘]
            print(motorcycles)
            tooexpensive = ‘ducati‘
            motorcycles.remove(tooexpensive)
            print(motorcycles)
            print("\nA " + tooexpensive.title() + " is too expensive for me.")  #變量中保存刪除的元素
            回顯信息：
            [‘honda‘, ‘yamaha‘, ‘suzuki‘, ‘ducati‘]
            [‘honda‘, ‘yamaha‘, ‘suzuki‘]
            A Ducati is too expensive for me.
註意：方法 remove() 只刪除第一個指定的值。如果要刪除的值可能在列表中出現多次，就需要使用循環來判斷是否刪除了所有這樣的值。
將在第七章使用循環處理上述問題

3.2 組織列表的常見方式：sort()、倒序打印列表、 sorted() 、確定列表的長度}

使用方法 sort() 對列表元素按字母排序 永久排序
cars = [‘bmw‘, ‘audi‘, ‘toyota‘, ‘subaru‘]
cars.sort() #字母順序
cars.sort(reverse=True) #字母倒序向 sort() 方法傳遞參數 reverse=True
使用方法 reverse() 反轉列表元素的排列順序 永久排序
cars = [‘bmw‘, ‘audi‘, ‘toyota‘, ‘subaru‘]
print(cars)
cars.reverse()
print(cars)
使用sorted()函數進行臨死性排序 格式：函數名（傳遞給函數的參數）
sorted(cars)
[‘audi‘, ‘bmw‘, ‘subaru‘, ‘toyota‘]
函數 len() 可快速獲悉列表的長度
len(cars)

第四章操作列表

遍歷列表切片遍歷切片復制切片元組(定義遍歷修改元組變量)

4.1 遍歷列表創建數字列表列表解析

使用for循環遍歷列表中的元素，縮進的代碼行都是循環體的一部分

    magicians = [‘alice‘, ‘david‘, ‘carolina‘]
    for magician in magicians:     ##註意冒號不要丟
            print(magician.title() + ", that was a great trick!")
            print("I can‘t wait to see your next trick, " + magician.title() + ".\n")
    print("Thank you, everyone. That was a great magic show!")  ##循環結束後的語句

使用range() 函數生成一系列數字 Python 從你指定的第一個值開始數，並在到達你指定的第二個值後停止，因此輸出不包含第二個值（這裏為 5）
```
  for value in range(1,5):
          print(value)
```
創建數字列表使用list()函數將range()的結果轉話為列表，將range()作為list()的參數，輸出一個數字列表。
numbers = list(range(1,6)) ##range(1,10,2) 可以指定步長（起始，結束，步長）
print(numbers)
創建列表實例:
```
        squares = [] 
        for value in range(1,11):
                square = value**2
                squares.append(square)
        print(squares)
        結果：
        [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
```
簡單統計計算函數（參數）
min(digits)
max(digits)
sum(digits)

列表解析

要使用這種語法，首先指定一個描述性的列表名，如 squares然後，指定一個左方括號，並定義一個表達式，用於生成你要存儲到列表中的值。
在這個示例中，表達式為 value**2 ，它計算平方值。
接下來，編寫一個 for 循環，用於給表達式提供值，再加上右方括號。在這個示例中， for 循環為 for value in range(1,11) ，它將值1~10 提供給表達式 value**2 。

註意：這裏的 for 語句末尾沒有冒號。
squares = [value**2 for value in range(1,11)]
print(squares)
結果與你在前面看到的平方數列表相同：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4.2 切片遍歷切片復制列表

切片：對列表的部分元素進行處理
players = [‘charles‘, ‘martina‘, ‘michael‘, ‘florence‘, ‘eli‘]
print(players[0:3])
print(players[1:4]) #提取列表的第 2~4 個元素
print(players[:4]) #不指定第一個索引默認為開頭
print(players[2:]) #到列表末尾
負數索引返回離列表末尾相應距離的元素，因此你可以輸出列表末尾的任何切片。例如，如果你要輸出名單上的最後三名隊員：
可使用切片 players[-3:]

遍歷切片在for循環中遍歷切片

    players = [‘charles‘, ‘martina‘, ‘michael‘, ‘florence‘, ‘eli‘]
    print("Here are the first three players on my team:")
    for player in players[:3]:
        print(player.title())

復制列表創建一個包含整個列表的切片，同時省略起始索引和終止索引[:]

----------------------------------------------------------------
my_foods = [‘pizza‘, ‘falafel‘, ‘carrot cake‘]
friend_foods = my_foods[:]     #起始末尾復制列表
----------------------------------------------------------------
my_foods = [‘pizza‘, ‘falafel‘, ‘carrot cake‘]
friend_foods = my_foods[:]     #復制列表
my_foods.append(‘cannoli‘)
friend_foods.append(‘ice cream‘)
print("My favorite foods are:")
print(my_foods)
print("\nMy friend‘s favorite foods are:")
print(friend_foods)
----------------------------------------------------------------
friend_foods = my_foods   #僅僅簡單賦值
my_foods.append(‘cannoli‘)
friend_foods.append(‘ice cream‘)
print("My favorite foods are:")
print(my_foods)
print("\nMy friend‘s favorite foods are:")
print(friend_foods)

註意：這裏將 my_foods 賦給 friend_foods ，而不是將 my_foods 的副本存儲到 friend_foods （見?）。這種語法實際上是讓 Python 將新變量 friend_foods 關聯到包含在 my_foods 中的列表，因此這兩個變量都指向同一個列表。鑒於此，當我們將 ‘cannoli‘ 添加到 my_foods 中時，它也將出現在 friend_foods 中；同樣，雖然 ‘icecream‘ 好像只被加入到了 friend_foods 中，但它也將出現在這兩個列表中。

4.3 元組（定義遍歷修改）

元組：
列表非常適合用於存儲在程序運行期間可能變化的數據集。列表是可以修改的，這對處理網站的用戶列表或遊戲中的角色列表至關重要然而，有時候你需要創建一系列不可修改的元素，元組可以滿足這種需求。 Python 將不能修改的值稱為不可變的，而不可變的列表被稱為元組。
dimensions = (200, 50) #（定義元組元素的值，號分割）
? dimensions[0] = 250 #不可給元組的元組的元素賦值
?處的代碼試圖修改第一個元素的值，導致 Python 返回類型錯誤消息。由於試圖修改元組的操作是被禁止的，因此 Python 指出不能給元組的元素賦值：
Traceback (most recent call last):
File "dimensions.py", line 3, in <module>
dimensions[0] = 250
TypeError: ‘tuple‘ object does not support item assignment

for遍歷元組

    dimensions = (200, 50)
    for dimension in dimensions:
        print(dimension)

修改元組變量
雖然不能修改元組的元素，但可以給存儲元組的變量賦值。因此，如果要修改前述矩形的尺寸，可重新定義整個元組：

    dimensions = (200, 50)
    print("Original dimensions:")
    for dimension in dimensions:
        print(dimension)
    dimensions = (400, 100)
    print("\nModified dimensions:")
    for dimension in dimensions:
        print(dimension)

第五章條件測試if語句

if 語句的核心都是一個值為 True 或 False 的表達式，這種表達式被稱為條件測試或者布爾表達式 ,結果要麽為 True ，要麽為 False 。Python 根據條件測試的值為 True 還是 False 來決定是否執行 if 語句中的代碼如果條件測試的值為 True ， Python 就執行緊跟在 if 語句後面的代碼；如果為 False ， Python 就忽略這些代碼。

5.1簡單示例:

        cars = [‘audi‘, ‘bmw‘, ‘subaru‘, ‘toyota‘]
        for car in cars:
                if car == ‘bmw‘:
                         print(car.upper())
                else:
                         print(car.title())

5.2 常用條件測試

字符串比較=或 !=

    car = ‘bmw‘ #定義變量的值   
    car == ‘bmw‘ #邏輯判斷是否相等 結果為True

    requested_topping = ‘mushrooms‘
    if requested_topping != ‘anchovies‘:       #if判斷是否不等註意必須：
            print("Hold the anchovies!")

    Python 中檢查是否相等時區分大小寫
    car.lower() == ‘audi‘ #先進行轉換然後比較

數值比較

>> age = 19
>> age < 21
True
>> age <= 21
True
>> age > 21
False
>> age >= 21
False
檢測多個條件關鍵字and or

>> age_0 = 22
>> age_1 = 18
age_0 >= 21 and age_1 >= 21 ##相當與bash中的&&
age_0 >= 21 or age_1 >= 21 ##相當與bash中的||

檢測特定的值是否在列表中 in 、not in

    banned_users = [‘andrew‘, ‘carolina‘, ‘david‘]
    user = ‘marie‘
    if user not in banned_users:
         print(user.title() + ", you can post a response if you wish.")

布爾表達式
布爾表達式，它不過是條件測試的別名。與條件表達式一樣，布爾表達式的結果要麽為 True ，要麽為 False 。可以作為條件。
game_active = True
can_edit = False
5.3 if語句
if語句

if-else

    age = 17
    if age >= 18:
            print("You are old enough to vote!")
    else:
            print("Sorry, you are too young to vote.")
            print("Please register to vote as soon as you turn 18!")

if-elif-else
Python 只執行 if-elif-else 結構中的一個代碼塊，它依次檢查每個條件測試，直到遇到通過了的條件測試。測試通過後， Python 將執行緊跟在它後面的代碼，並跳過余下的測試
```
    age = 12
    if age < 4:
            print("Your admission cost is $0.")
    elif age < 18:
            print("Your admission cost is $5.")
    else:
            print("Your admission cost is $10.")
```

多個elif 代碼塊

    age = 12
    if age < 4:
            price = 0
    elif age < 18:
            price = 5
    elif age < 65:
            price = 10
    else:
            price = 5
    print("Your admission cost is $" + str(price) + ".")

省略代碼塊
Python 並不要求 if-elif 結構後面必須有 else 代碼塊。在有些情況下， else 代碼塊很有用；而在其他一些情況下，使用一條 elif 語句來處理特定的情形更清晰
測試多個條件
if-elif-else 結構功能強大，但僅適合用於只有一個條件滿足的情況：遇到通過了的測試後， Python 就跳過余下的測試。這種行為很好，效率很高，讓你能夠測試一個特定的條件。然而，有時候必須檢查你關心的所有條件。在這種情況下，應使用一系列不包含 elif 和 else 代碼塊的簡單 if 語句。在可能有多個條件為 True ，且你需要在每個條件為 True時都采取相應措施時，適合使用這種方法。
```
 requested_toppings = [‘mushrooms‘, ‘extra cheese‘]
    if ‘mushrooms‘ in requested_toppings:
                print("Adding mushrooms.")
    if ‘pepperoni‘ in requested_toppings:
                print("Adding pepperoni.")
    if ‘extra cheese‘ in requested_toppings:
                print("Adding extra cheese.")
    print("\nFinished making your pizza!")
```
5.4 使用if處理列表

檢測特殊元素
如果比薩店的青椒用完了，該如何處理呢？為妥善地處理這種情況，可在 for 循環中包含一條 if 語句：

    requested_toppings = [‘mushrooms‘, ‘green peppers‘, ‘extra cheese‘]
    for requested_topping in requested_toppings:
                if requested_topping == ‘green peppers‘:
                  print("Sorry, we are out of green peppers right now.")
          else:
                  print("Adding " + requested_topping + ".")
    print("\nFinished making your pizza!")

確定列表是否為空
在 if 語句中將列表名用在條件表達式中時， Python 將在列表至少包含一個元素時返回 True ，並在列表為空時返回 False 。

    requested_toppings = []
    if requested_toppings:
        for requested_topping in requested_toppings:
                print("Adding " + requested_topping + ".")
                print("\nFinished making your pizza!")
    else:
        print("Are you sure you want a plain pizza?")

使用多個列表

    ? available_toppings = [‘mushrooms‘, ‘olives‘, ‘green peppers‘,
    ‘pepperoni‘, ‘pineapple‘, ‘extra cheese‘]
    ? requested_toppings = [‘mushrooms‘, ‘french fries‘, ‘extra cheese‘]
    ? for requested_topping in requested_toppings:
            ? if requested_topping in available_toppings:
                    print("Adding " + requested_topping + ".")
            ? else:
                    print("Sorry, we don‘t have " + requested_topping + ".")
      print("\nFinished making your pizza!")

在?處，我們定義了一個列表，其中包含比薩店供應的配料。請註意，如果比薩店供應的配料是固定的，也可使用一個元組來存儲它們。
在?處，我們又創建了一個列表，其中包含顧客點的配料，請註意那個不同尋常的配料 —— ‘french fries‘ 。
在?處，我們遍歷顧客點的配料列表。在這個循環中，對於顧客點的每種配料，我們都檢查它是否包含在供應的配料列表中（見?）；
如果答案是肯定的，就將其加入到比薩中，否則將運行 else 代碼塊（見?）：打印一條消息，告訴顧客不供應這種配料

5.5 小結

在本章中，你學習了如何編寫結果要麽為 Ture 要麽為 False 的條件測試。你學習了如何編寫簡單的 if 語句、 if-else 語句和 if-elif-else 結構。
在程序中，你使用了這些結構來測試特定的條件，以確定這些條件是否滿足。你學習了如何在利用高效的 for 循環的同時，以不同於其他元素的方式對特定的列表元素進行處理。
你還再次學習了Python 就代碼格式方面提出的建議，這可確保即便你編寫的程序越來越復雜，其代碼依然易於閱讀和理解。
在第 6 章，你將學習 Python 字典。字典類似於列表，但讓你能夠將不同的信息關聯起來。你將學習如何創建和遍歷字典，以及如何將字典同列表和 if 語句結合起來使用。
學習字典讓你能夠模擬更多現實世界的情形。

第六章字典 bash關聯屬組(創建添加鍵值對修改遍歷字典) 嵌套(列表-字典字典-列表字典-字典)

第七章用戶輸入和while循環

第八章函數(定義傳遞參數的不通方式返回值傳遞列表將函數存儲在模塊中)

第九章類(創建使用實例化繼承導入類 python標準庫)

第十章文件和異常

第十一章測試代碼

python 入門到實踐 ----筆記

python 入門到實踐 ----筆記

第一章 第一個python程序

第二章 變量以及簡單數據類型：字符串 數字

2.1變量命名規範

2.2字符串

2.3數字

2.4添加 註釋

2.5python 之禪 .指導原則

第三章 列表( 索引 元素的值 組織列表)

3.1列表 （索引 元素增刪改查）

3.2 組織列表的常見方式：sort()、 倒序打印列表 、 sorted() 、確定列表的長度}

第四章 操作列表

4.1 遍歷列表 創建數字列表 列表解析

4.2 切片 遍歷切片 復制列表

4.3 元組 （定義 遍歷 修改）

第五章 條件測試if語句

5.1簡單示例:

5.2 常用條件測試

5.3 if語句

5.4 使用if處理列表

5.5 小結

第六章 字典 bash關聯屬組(創建 添加鍵值對 修改 遍歷字典) 嵌套(列表-字典 字典-列表 字典-字典)

第七章 用戶輸入和while循環

第八章 函數(定義 傳遞參數的不通方式 返回值 傳遞列表 將函數存儲在模塊中)

第九章 類(創建使用 實例化 繼承 導入類 python標準庫)

第十章 文件和異常

第十一章 測試代碼

相關推薦

第一章第一個python程序

第二章變量以及簡單數據類型：字符串數字

2.4添加註釋

第三章列表( 索引元素的值組織列表)

3.1列表（索引元素增刪改查）

3.2 組織列表的常見方式：sort()、倒序打印列表、 sorted() 、確定列表的長度}

第四章操作列表

4.1 遍歷列表創建數字列表列表解析

4.2 切片遍歷切片復制列表

4.3 元組（定義遍歷修改）

第五章條件測試if語句

第六章字典 bash關聯屬組(創建添加鍵值對修改遍歷字典) 嵌套(列表-字典字典-列表字典-字典)

第七章用戶輸入和while循環

第八章函數(定義傳遞參數的不通方式返回值傳遞列表將函數存儲在模塊中)

第九章類(創建使用實例化繼承導入類 python標準庫)

第十章文件和異常

第十一章測試代碼