學習目標：

• 能夠說出常用 Python 容器型別的名字：串列、元組、字典、字串、集合
• 掌握容器型別的基本操作：定義和使用、增刪改查、遍歷等

01_串列

學習目標：

• 知道定義串列的基本格式
• 知道串列的常用操作：增刪改查
• 能夠使用 for 回圈實作對串列中所有元素的遍歷

1.1 串列的定義

• list（串列） 是 Python 中使用 最頻繁 的資料型別
• 專門用于存盤 一組資料，存盤的每個資料 稱為 元素
• 串列用 [] 定義，元素 之間使用 , 分隔
• 串列的 索引(下標) 從 0 開始
  • 索引(下標) 就是元素在 串列 中的位置編號

"""
串列定義的格式：
串列變數的名字 = [元素1, 元素2, ……]

使用格式：
    串列變數[下標]
"""

# 串列定義
name_list = ['mike', 'yoyo', 'rock', 'lily']
#              0       1        2       3
#             -4       -3      -2       -1

# 最后一個元素取出來
print(name_list[3])
print(name_list[-1])

# 訪問串列元素，不要超出范圍，不要越界
# IndexError: list index out of range
# print(name_list[4])

• 注意：從串列中取值時，如果 超出索引(下標)范圍，程式會報錯

1.2 串列嵌套

• 一個串列中的元素又是串列，那么這就是串列的嵌套

school_list = [['北京大學', '清華大學'], ['中山大學', '華南理工大學'], ['哈工大', '哈工程']]
#                  0                      1                         2

# 取出第 2 個元素，也就是下標為 1 的元素
print(school_list[1])  # ['中山大學', '華南理工大學']

# 先取出下標為 1 的元素，再繼續取下標為 1 的元素
# ['中山大學', '華南理工大學']
#   0            1
print(school_list[1][1])  # '華南理工大學'

1.3 串列常用操作

list1 = [13, 5]

# 在串列結尾追加8
list1.append(8)
print(list1)  # [13, 5, 8]

list1 = [13, 5, 8, 5]

# 洗掉第一個匹配到的5
list1.remove(5)
print(list1)  # [13, 8, 5]

list1 = [13, 5]

# 修改 索引1 對應的值
list1[1] = 2
print(list1)  # [13, 2]

list1[10] = 3  # 索引不存在,程式報錯

list1 = [13, 5, 8]

# 獲取索引1 對應的值
print(list1[1])  # 5

print(list1[10])  # 索引不存在,程式報錯

list1 = [13, 5, 8]

# 獲取串列中元素的個數
length = len(list1)
print(length)  # 3

list1 = [13, 5, 8]
# 判斷串列中是否包含資料5
if 5 in list1:  # 包含資料,回傳True; 不包含,回傳False
    print("串列中包含該資料")  
else:  
    print("串列中不包含該資料")
# 輸出:  串列中包含該資料

list1 = [13, 5, 8]
# 升序排列
list1.sort()
print(list1)  # [5, 8, 13]
# 降序排列
list1.sort(reverse=True)
print(list1)  # [13, 8, 5]

1.4 回圈遍歷

1.4.1 通過for回圈遍歷

• 遍歷 就是 從頭到尾 依次 從 串列 中取出 每一個元素
• Python中專門提供 for回圈 實作遍歷

# 遍歷，從頭開始找，直到結束
name_list = ['mike', 'yoyo', 'rock', 'lily']

# 通過while實作遍歷
# 1. 定義條件變數i = 0
i = 0

# 2. while i < 串列元素個數:
while i < len(name_list):
    # 3. 取出某個元素，列印
    name = name_list[i]
    print(name)

    # 4. 條件變數的修改
    i += 1

print('==========華麗分割線=============')

# for遍歷回圈，和上面的while效果等價
# 從頭到尾 依次從 串列 中取出 每一個元素
for name in name_list:
    print(name)

1.4.2 if…in 和 for…in 的區別

• if…in：判斷某個元素是否在串列中，如果在，if的條件為True
• for…in：從頭到尾 依次從 串列 中取出 每一個元素

name_list = ['mike', 'yoyo', 'rock', 'lily']

# if…in：判斷某個元素是否在串列中，如果在，if的條件為True
name = 'yoyo'

# name的內容'yoyo'是否在name_list串列中，如果在，name in name_list結果為True
if name in name_list:
    print('%s 在串列中' % name)

print('==========華麗分割線=============')

# for…in：從頭到尾 依次從 串列 中取出 每一個元素，這個元素給name賦值
for name in name_list:
    print(name)

運行結果：

yoyo 在串列中
==========華麗分割線=============
mike
yoyo
rock
lily

1.4.3 for…else的使用

• for回圈里面沒有遇到break陳述句，for執行完后，則會執行else的分支

name_list = ['mike', 'yoyo', 'rock', 'lily']

for name in name_list:
    print(name)

    # 測驗有break，和沒有break的else執行情況
    # if name == 'yoyo':
    #     break
else:
    print('for回圈里面沒有遇到break陳述句，for執行完后，則會執行else的分支')

運行結果：

mike
yoyo
rock
lily
for回圈里面沒有遇到break陳述句，for執行完后，則會執行else的分支

02_元組

學習目標：

• 知道定義元組的基本格式
• 知道元組和串列的區別

2.1 元組的定義

• 元組用 () 定義
• 也用于存盤 一組 資料，元素 之間使用 , 分隔
• 元組的 索引(下標) 從 0 開始

# 串列：串列變數 = [元素1, 元素2, ……]
# 元組：元組變數 = (元素1, 元素2, ……)
my_tuple = ('mike', 'yoyo', 'lily')
#             0       1        2

# 取出第0個元素
print(my_tuple[0])  # 輸出：'mike'

• 元組中 只包含一個元素 時，需要 在元素后面添加逗號

# 元組只有一個元素的時候，格式: (元素,)
my_tuple1 = (250,)
# 列印my_tuple1的型別
print(type(my_tuple1))

2.2 元組常用操作

• tuple（元組）與串列類似，不同之處在于元組的 元素不能修改

my_tuple = ('mike', 'yoyo', 'lily')
# 元組只讀不能改
# TypeError: 'tuple' object does not support item assignment
# my_tuple[0] = 'rock' # err

tuple1 = (13, 5, 8)
# 獲取索引1 對應的值
print(tuple1[1])  # 5
print(tuple1[10])  # 索引不存在,程式報錯

tuple1 = (13, 5, 8)
# 獲取元組中元素的個數
length = len(tuple1)
print(length)  # 3

tuple1 = (13, 5, 8)
# 判斷元組中是否包含資料5
if 5 in tuple1:  # 包含資料,回傳True; 不包含,回傳False
    print("元組中包含該資料")  
else:  
    print("元組中不包含該資料")
# 輸出:  元組中包含該資料

03_字典

學習目標：

• 知道定義字典的基本格式
• 知道字典的常用操作：增刪改查
• 能夠通過for回圈完成對字典的遍歷

3.1 字典的定義

• 字典同樣可以用來 存盤多個資料
  • 通常用于存盤 描述一個 物體 的相關資訊
• 字典用 {} 定義
• 字典使用 鍵值對 存盤資料，鍵值對之間使用 , 分隔
  • 鍵 key 是索引，值 value 是資料
  • 鍵 和 值 之間使用 : 分隔
  • 值 可以取任何資料型別，但 鍵 只能使用 字串、數字或 元組
  • 鍵必須是唯一的

"""
字典定義格式：
    字典變數 = {k1:v1, k2:v2,……}

取出元素的值：
    字典變數[鍵值]
"""
# 字典的定義
info = {'name': 'mike', 'age': 34, 'city': 'sz'}
print(info)  # {'name': 'mike', 'age': 34, 'city': 'sz'}

# 取出元素的值：字典變數[鍵值]
print(info['city'])

3.2 字典常用操作

dict1 = {"name": "張三"}

# 給字典添加鍵值對
dict1["age"] = 20
print(dict1)  # {"name": "張三", "age": 20}

dict1 = {"name": "張三", "age": 20}

# 洗掉鍵值對
value = dict1.pop("age")
print(dict1) # {"name": "張三"}
print(value) # 20

# 鍵不存在, 會報錯
dict1.pop("height")

dict1 = {"name": "張三"}
# 給字典添加鍵值對
dict1["name"] = "李四"
print(dict1)  # {"name": "李四"}

list1 = [13, 5]
dict1 = {"name": "張三"}
# 獲取鍵值對的值
print(dict1["name"])  # "張三"
# 鍵不存在, 會報錯
print(dict1["height"])

dict1 = {"name": "張三"}
# 獲取鍵值對的值
print(dict1["name"])  # "張三"
# 鍵不存在, 回傳None
print(dict1.get('height'))  # None

dict1 = {"name": "張三", "age": 20}
# 遍歷字典所有的鍵值對
for key, value in dict1.items():
    print(key, value)
# 輸出: 
#            "name", "張三"  
#            "age", 20

3.3 案例：登錄注冊系統

• 在開發中，字典的應用場景是：

  • 使用 多個鍵值對，存盤 描述一個 物體 的相關資訊 —— 描述更復雜的資料資訊

  • 將 多個字典 放在 一個串列 中，再進行遍歷，在回圈體內部針對每一個字典進行 相同的處理

    用戶1: {'name': 'mike', 'pwd': '123456'}
    用戶2: {'name': 'yoyo', 'pwd': '123456'}
    
    用戶管理串列：
    user_list = [{'name': 'mike', 'pwd': '123456'}, {'name': 'yoyo', 'pwd': '123456'}]
    

• 登錄注冊系統需求：完成用戶注冊、用戶登錄功能

"""
登錄注冊系統需求：1.用戶注冊/ 2.用戶登錄/ 3.退出程式

0. 定義一個串列，用于存盤用戶字典

1. 死回圈 while True:
    2. 輸入數字指令
    3. 判斷指令，選擇分支
    4. 用戶注冊功能
        4.1 輸入注冊的用戶名
        4.2 通過for遍歷串列，取出的每個元素是字典
            4.3 字典['name']和輸入注冊的用戶名比較是否相等
                4.4 如果相等，列印提示：名字在串列中，不允許注冊
                4.5 跳出回圈
        4.6 for回圈的else，回圈里面沒有執行到break，則會執行else
            4.7 輸入注冊的密碼
            4.8 創建一個字典
            4.9 字典追加到串列中
            4.10 列印：注冊成功
    5. 用戶登陸功能
        5.1 輸入登陸的用戶名和密碼
        5.2 通過for遍歷串列，取出的每個元素是字典
            5.3 字典['name']和登陸用戶名比較 and 字典['pwd']和登陸密碼比較
                5.4 如果都相等，列印提示：登陸成功
                5.5 跳出回圈
        5.6 for回圈的else，回圈里面沒有執行到break，則會執行else
            5.7 列印：用戶名或密碼錯誤，請重新登陸
"""
# 0. 定義一個串列，用于存盤用戶字典
user_list = [{'name': 'mike', 'pwd': '123456'}, {'name': 'yoyo', 'pwd': '123456'}]

# 1. 死回圈 while True:
while True:
    #  2. 輸入數字指令
    cmd_num = input('請輸入操作: 1.用戶注冊/ 2.用戶登錄/ 3.退出程式')

    # 3. 判斷指令，選擇分支
    # 4. 用戶注冊功能
    if cmd_num == '1':
        # print('用戶注冊')
        # 4.1 輸入注冊的用戶名
        reg_name = input('請輸入注冊的名字：')
        # 4.2 通過for遍歷串列，取出的每個元素是字典
        for user_dict in user_list:
            # 4.3 字典['name']和輸入注冊的用戶名比較是否相等
            if user_dict['name'] == reg_name:
                # 4.4 如果相等，列印提示：名字在串列中，不允許注冊
                print(reg_name, '名字在串列中，不允許注冊')
                # 4.5 跳出回圈
                break
        # 4.6 for回圈的else，回圈里面沒有執行到break，則會執行else
        else:
            # 4.7 輸入注冊的密碼
            reg_pwd = input('請輸入注冊的密碼：')
            # 4.8 創建一個字典
            user_dict = {'name': reg_name, 'pwd': reg_pwd}
            # 4.9 字典追加到串列中
            user_list.append(user_dict)
            # 4.10 列印：注冊成功
            print('注冊成功')
    # 5. 用戶登陸功能
    elif cmd_num == '2':
        # print('用戶登錄')
        # 5.1 輸入登陸的用戶名和密碼
        login_name = input('請輸入登錄用戶名:')
        login_pwd = input('請輸入登錄密碼:')
        # 5.2 通過for遍歷串列，取出的每個元素是字典
        for user_dict in user_list:
            # 5.3 字典['name']和登陸用戶名比較 and 字典['pwd']和登陸密碼比較
            if user_dict['name'] == login_name and user_dict['pwd'] == login_pwd:
                # 5.4 如果都相等，列印提示：登陸成功
                print('登陸成功')
                # 5.5 跳出回圈
                break
        # 5.6 for回圈的else，回圈里面沒有執行到break，則會執行else
        else:
            # 5.7 列印：用戶名或密碼錯誤，請重新登陸
            print('用戶名或密碼錯誤，請重新登陸')
    elif cmd_num == '3':
        print('退出程式')
        break
    else:
        print("輸入錯誤，重新輸入")

04_字串

學習目標：

• 能夠使用兩個單引號、雙引號、三引號定義字串
• 知道字串的常用操作：查找、替換等
• 能夠使用切片語法獲取字串指定區間內的子串

4.1 字串的定義

• 字串 就是 一串字符，是編程語言中用來存盤文本的資料型別

• 在 Python 中可以使用 一對雙引號 " 或者 一對單引號 ' 定義一個字串 或者 一對三引號 ''' 定義一個字串

• 可以使用 索引 獲取一個字串中 指定位置的字符，索引計數從 0 開始

• 也可以使用 for 回圈遍歷 字串中每一個字符

"""
字串變數 = '字串內容'
說明：可以是單引號、雙引號、三引號

"""
my_str = 'python'
#         012345

# 取某個元素，和串列一樣
print(my_str[0])

# 遍歷取所有元素
for c in my_str:
    print(c)

4.2 f-strings 字串格式化

• f-strings是Python 3.6之后的一種新的字串格式化方法，要使用f-strings，只需在字串前加上f、或F：

name = 'mike'
age = 34
sex = 'male'

# 傳統方式格式化
print('我叫%s, 年齡為%d, 性別為：%s' % (name, age, sex))

# 和上面列印效果一樣
print(f'我叫{name}, 年齡為{age}, 性別為：{sex}')
print(F'我叫{name}, 年齡為{age}, 性別為：{sex}')

4.3 字串的常用操作

str1 = "hello python"

# 查找"py"對應的索引(能找到的話, 回傳"p"對應的索引)
index = str1.find("py")
print(index)  # 6

# 查找"88"對應的索引, 不存在, 回傳-1
index = str1.find("88")
print(index)  # -1

str1 = "hello python"

# 對內容進行替換, 回傳新字串
new_str = str1.replace("py", "Py")
print(new_str)  # hello Python

str1 = "hello python hello world"

# 以空格分割字串,每段一個元素,回傳串列
str_list = str1.split(" ")
print(str_list)  # ["hello", "python", "hello", "world"]

str1 = "hello"

str2 = "python"

# 拼接字串
str3 = str1 + str2
print(str3)  # "hellopython"

str1 = ","

name_list = ["beijing", "shenzhen", "shanghai", "guangzhou"]

# 以字串為連接符拼接字串串列的元素,生成新的字串
str2 = str1.join(name_list)
print(str2)  # "beijing,shenzhen,shanghai,guangzhou"

4.4 字串的切片

4.4.1 切片介紹

• 切片 譯自英文單詞 slice，翻譯成另一個解釋更好理解: 一部分

• 切片 使用 索引值 來限定范圍，根據 步長 從原序列中 取出一部分 元素組成新序列

• 切片 方法適用于 字串、串列、元組

  字串[開始索引:結束索引:步長]

注意：

1. 指定的區間屬于 左閉右開 型 [開始索引, 結束索引) 對應 開始索引 <= 范圍 < 結束索引
   • 從 起始 位開始，到 結束位的前一位 結束（不包含結束位本身)
2. 從頭開始，開始索引 數字可以省略，冒號不能省略
3. 到末尾結束，結束索引 數字和冒號都可以省略
4. 步長：理解為走的步數，正數說明是從左往右，負數是從右往左，默認步長為+1
   • 步長默認為 1，如果元素連續，數字和冒號都可以省略

4.4.2 案例

演練需求

• 截取從 2 ~ 5 位置 的字串
• 截取從 2 ~ 末尾 的字串
• 截取從 開始 ~ 5 位置 的字串
• 從開始位置，每隔一個字符截取字串
• 截取字串末尾兩個字符
• 字串的逆序（面試題）

示例代碼：

"""
字串[開始索引:結束索引:步長]
0. 步長默認為1，步長理解為走幾步，正數從左往右，負數從右往左
1. 字串[開始索引:結束索引]   開始索引 ~（結束索引-1）
2. 字串[開始索引: ]       開始索引 ~ 結束索引，末尾索引不寫，默認能取到末尾那個索引
3. 字串[ :結束索引]       0 ~（結束索引-1），開始索引不寫，默認從第0個元素開始
"""
temp_str = '12345678'
#           01234567
#                -2-1

# 站在用戶角度，第1個元素才開始算第1個位置
# 截取從 2 ~ 5 位置 的字串
print(temp_str[1:5])

# 截取從 2 ~ 末尾 的字串
print(temp_str[1:]) # 沒有指定結尾索引，默認取到末尾

# 截取從 開始 ~ 5 位置 的字串
print(temp_str[:5]) # 沒有指定開頭索引，默認從0開始

# 從開始位置，每隔一個字符截取字串，也就是說走2步
print(temp_str[::2]) # 沒有指定開頭、結尾索引，默認從頭到尾

# 截取字串末尾兩個字符
print(temp_str[-2:])  # 沒有指定結尾索引，默認取到末尾

# 字串的逆序（面試題）
print(temp_str[::-1])

05_集合

學習目標：

• 能夠通過集合完成對串列中元素的去重功能
• 知道list、tuple、set之間可以進行型別轉換

5.1 通過集合完成對串列去重功能

• 集合用 {} 定義，元素 之間使用 , 分隔
• 可通過集合對串列中的元素完成去重功能

# 集合：元素不會重復，{元素1，元素2……}
# 定義集合
my_set = {1, 2, 1, 2, 1, 2}
print(my_set)  # {1, 2}
print(type(my_set))  # <class 'set'>

# 通過集合完成對串列去重功能
name_list = ['mike', 'yoyo', 'mike']
# set(name_list)：給串列轉換為set型別，即可完成去重功能
temp_set = set(name_list)
print(temp_set)  # {'mike', 'yoyo'}

5.2 list、tuple、set之間型別轉換

示例代碼：

# 串列轉元組、集合 型別
my_list = [1, 2, 3, 5, 3, 5]

# 串列轉換為元組型別
my_tuple = tuple(my_list)
print(my_tuple)  # (1, 2, 3, 5, 3, 5)

# 串列轉換為集合型別
my_set = set(my_list)
print(my_set)   # {1, 2, 3, 5}

print('============華麗分割線============')

# 元組轉串列、集合 型別
my_tuple = (1, 2, 3, 5, 3, 5)

# 元組轉換為串列 型別
my_list = list(my_tuple)
print(my_list)  # [1, 2, 3, 5, 3, 5]

# 元組轉換為集合 型別
my_set = set(my_tuple)
print(my_set)   # {1, 2, 3, 5}

print('============華麗分割線============')

# 集合轉元組、串列 型別
my_set = {1, 2, 3}

# 集合轉換為串列 型別
my_list = list(my_set)
print(my_list)  # [1, 2, 3]

# 集合轉換為元組 型別
my_tuple = tuple(my_set)
print(my_tuple)  # (1, 2, 3)

06_公共語法

學習目標：

• 知道公共語法為大部分容器型別的通用方法

6.1 Python 內置函式

Python 包含了以下內置函式：

6.2 切片

6.3 運算子

注意

• in 在對 字典 操作時，判斷的是 字典的鍵
• in 和 not in 被稱為 成員運算子

07_容器常用方法匯總

學習目標：

• 了解容器常用方法，現用現查，當做手冊用

7.1 串列操作

7.2 元祖操作

7.3 字典操作

7.4 字串操作

容器型別——附練習題

能力目標：

• 能夠說出定義串列的基本格式
• 能夠使用for回圈實作對串列中所有元素的遍歷
• 知道in/not in能夠判斷串列中是否存在某個元素
• 能夠說出定義元組的基本格式
• 能夠說出定義字典的基本格式
• 能夠通過鍵對字典進行添加/修改元素操作
• 能夠使用兩個單引號、雙引號、三引號定義字串
• 知道replace方法能夠實作替換指定子串

關卡一：基礎題

1. 寫出 for 回圈遍歷串列的完整格式，并簡單描述 for 回圈的執行程序

答案

格式如下:
    for 臨時變數 in 串列變數
        回圈執行的代碼
執行程序:
首先從被遍歷的資料里取出一個元素，并賦值給臨時變數
在回圈里可以直接使用臨時變數的值
當回圈里的代碼執行結束，會再次回到 for 回圈起始的位置，取出一個元素賦值給臨時變數，并開始回圈
直到回圈已經無法再次取出元素，才會結束回圈，然后開始執行回圈后的代碼

2. 簡述你對串列的理解（存什么樣的資料？什么是元素？串列如何定義？什么是索引？）

答案

list(串列) 是python中使用最頻繁的資料型別
專門用于存盤一串資料,存盤的資料稱為元素
串列用[]定義,元素之間用 , 分隔
串列的索引從 0 開始
索引就是元素在串列中的位置編號

3. 簡述你對元組的理解（存什么樣的資料？與串列的區別是什么？）

答案

元組用 () 定義
用于存盤一串資料,元素之間使用,分隔
元組的 索引 從 0 開始
Tuple（元組）與串列類似，不同之處在于元組的 元素不能修改

4. 簡述你對字典的理解（存什么樣的資料？字典如何定義？）

答案

字典同樣可以用來 存盤多個資料
通常用于存盤 描述一個 物體 的相關資訊
字典用 {} 定義
字典使用 鍵值對 存盤資料，鍵值對之間使用 , 分隔
  鍵 key 是索引
  值 value 是資料
  鍵 和 值 之間使用 : 分隔
  值 可以取任何資料型別，但 鍵 只能使用 字串、數字或 元組
  鍵必須是唯一的

5. 解釋什么是索引越界

答案

索引越界是指串列的下標超過了該串列的下標的最大值

6. 簡述你對字串的理解（存盤什么樣的資料？字串如何定義？如何獲取指定位置的字符？）

答案

字串 就是 一串字符，是編程語言中表示文本的資料型別
在 Python 中可以使用 一對雙引號 " 或者 一對單引號 ' 定義一個字串 或者 一對三引號 ''' 定義一個字串
可以使用 索引 獲取一個字串中 指定位置的字符，索引計數從 0 開始
也可以使用 for 回圈遍歷 字串中每一個字符

關卡二：綜合題

1. 設計一個程式

有一個串列 a = [11, 22, 33]

• 獲取串列的元素 22

• 向串列中添加（增）新元素 44

• 洗掉（刪）串列中的元素 33

• 修改（改）串列中的元素 22 為 55

• 查找（查）串列中的元素 55 的下標

提示: 增加和洗掉, 可以使用多種方式實作, 具體可以參考課件的其他語法

答案

ret = (a[1])
a.append(44)
a.remove(33)
a[1] = 55
index = a.index(55)

2. 設計一個程式

按下述步驟實作代碼:

• 創建一個空字典{}，變數名為 info

• 向字典 info 中添加新的鍵值對，保存如下資訊：姓名是張三

• 獲取字典中元素 name 的值

• 修改字典中的元素 'name' 的值為 '李四'

• 存在字典 info = {'name':'李四'}, 洗掉元素 name

答案

info = {}
info['name'] = '張三'
ret = (info['name'])
info['name'] = '李四'
info.pop('name')

3. 設計一個程式:

• 要求用戶輸入一個字串，遍歷當前字串并列印，如果遇見“q”,則跳出回圈，如果遇見“ ”（空格）則跳過當前輸出，

• 提示：for回圈可以遍歷字串

答案

input_str = input("請輸入一個字串：")
for i in input_str:
    if i == "q":
        break
    elif i == " ":
        continue
    print(i)

4. 設計一個程式

已知變數如下：

 a = "itheima"

• 從鍵盤上輸入一個字母，判斷此字母 是否在變數 a 中，如果在則輸出 找到了， 如果不在 則輸出 查無此字母

答案

a = 'itheima'
b = input('請從鍵盤上輸入一個字母:')
for i in a:
    if i == b:
        print('找到了')
        break
else:
    print('查無此字母')

5. 設計一個程式

現有字典dict1 = {'name':'chuanzhi','age':18} 要求：

• 1.使用回圈將字典中所有的鍵輸出到螢屏上

• 2.使用回圈將字典中所有的值輸出到螢屏上

• 3.使用回圈將字典中所有的鍵值對輸出到螢屏上 輸出方式： name：chuanzhi age:18

答案

dict1 = {'name':'chuanzhi','age':18}
for key in dict1.keys():
    print(key)
for value in dict1.values():
    print(value)
for key, value in dict1.items():
    print(key, value)

關卡三：擴展題

1. 設計一個程式

有這樣的一個串列

product_list = [
    {"name": "電腦", "price": 7000},
    {"name": "滑鼠", "price": 30},
    {"name": "usb電動小風扇", "price": 20},
    {"name": "遮陽傘", "price": 50},
]

然后小明一共有8000塊錢，那么他能不能買下這所有商品？ 如果能，請輸出“能”，否則輸出“不能”

提示: 可以使用回圈嵌套和非回圈嵌套2種方式

1. 回圈嵌套: 先遍歷串列, 再遍歷字典

2. 非嵌套: 遍歷串列, 直接取字典的值

使用回圈嵌套僅僅是為了熟悉語法, 正常開發中, 使用非嵌套即可.

答案

# 方式一: 使用for回圈嵌套, 遍歷串列取到字典時, 再遍歷字典的鍵值
product_list = [
    {"name": "電腦", "price": 7000},
    {"name": "滑鼠", "price": 30},
    {"name": "usb電動小風扇", "price": 20},
    {"name": "遮陽傘", "price": 50},
]
money = 8000
sum_num = 0  # sum_num初始化為0，是用來存放總價格
for product in product_list:
    for key, value in product.items():
        if key == "price":
            sum_num += value
if money >= sum_num:
    print("能")
else:
    print("不能")

    
# 方式二: 使用for, 根據字典key取值(推薦)
product_list = [
    {"name": "電腦", "price": 7000},
    {"name": "滑鼠", "price": 30},
    {"name": "usb電動小風扇", "price": 20},
    {"name": "遮陽傘", "price": 50},
]
money = 8000
sum_num = 0  # sum_num初始化為0，是用來存放總價格
for product in product_list:
    sum_num += product['price']
if money >= sum_num:
    print("能")
else:
    print("不能")