# 方式1：創(chuàng)建空列表
list1 = []

# 方式2：直接賦值（支持混合數據類型）
# 元素可以是數字、字符串、嵌套列表、布爾值等任意類型
list2 = [1, 2, "Python", [3, 4], True]

# 方式3：列表推導式（快速生成有規(guī)律的列表）
# 生成0-8的偶數列表：x從0到4，每個x乘2
list3 = [x * 2 for x in range(5)]  # 結果：[0, 2, 4, 6, 8]

# 方式4：類型轉換（其他可迭代對象轉列表）
list4 = list("abc")        # 字符串轉列表 → ['a', 'b', 'c']
list5 = list((1, 2, 3))    # 元組轉列表 → [1, 2, 3]
list6 = list({1, 2, 3})    # 集合轉列表 → [1, 2, 3]（集合無序，順序隨機）

# 定義示例列表
nums = [10, 20, 30, 40, 50]

# 1. 單個元素提?。ㄋ饕≈担?
print(nums[0])    # 正索引：取第1個元素 → 10
print(nums[-1])   # 負索引：取最后1個元素 → 50

# 2. 切片提取（語法：[起始索引:結束索引:步長]，左閉右開）
print(nums[1:3])  # 取索引1到2的元素 → [20, 30]
print(nums[:3])   # 省略起始：從頭取到索引2 → [10, 20, 30]
print(nums[::2])  # 步長2：隔一個取一個 → [10, 30, 50]
print(nums[::-1]) # 步長-1：反轉列表 → [50, 40, 30, 20, 10]

# 3. 遍歷提取元素
# 普通遍歷：逐個取元素
for num in nums:
    print(num)  # 依次輸出：10, 20, 30, 40, 50

# 帶索引遍歷：同時獲取索引和元素（enumerate函數）
for index, num in enumerate(nums):
    print(f"索引{index}對應的元素：{num}")  # 輸出：索引0：10 等

# 1. append() - 向列表末尾添加單個元素
nums = [10, 20]
nums.append(30)  # 僅能添加一個元素，不能傳多個
print(nums)      # 輸出：[10, 20, 30]
# 2. insert() - 向指定索引位置插入元素
nums = [10, 20]
# 索引1的位置插入15，原索引1的20及后續(xù)元素后移
nums.insert(1, 15)
print(nums)  # 輸出：[10, 15, 20]
# 3. extend() - 批量添加可迭代對象的元素（列表/元組/字符串等）
nums = [10, 20]
nums.extend([30, 40])  # 把列表[30,40]的元素逐個添加到nums
# 也可以傳其他可迭代對象：nums.extend((50,60)) / nums.extend("ab")
print(nums)  # 輸出：[10, 20, 30, 40]
# 4. 修改元素 - 通過索引直接賦值
nums = [10, 20]
nums[0] = 100  # 把索引0的元素改為100
print(nums)    # 輸出：[100, 20]
# 5. pop() - 按索引刪除元素，返回被刪除的元素
nums = [10, 20, 30]
removed_num = nums.pop(1)  # 刪除索引1的元素
print("被刪除的元素：", removed_num)  # 輸出：20
print("刪除后的列表：", nums)        # 輸出：[10, 30]
# 不傳索引時，默認刪除最后一個元素：nums.pop() → 刪除30
# 6. remove() - 按值刪除元素（僅刪除第一個匹配的值）
nums = [10, 20, 30, 20]
nums.remove(20)  # 只刪除第一個20
print(nums)      # 輸出：[10, 30, 20]
# 7. clear() - 清空列表所有元素（列表本身還存在）
nums = [10, 20]
nums.clear()
print(nums)  # 輸出：[]
# 8. del 切片 - 批量刪除指定范圍的元素
nums = [10, 20, 30, 40]
del nums[1:3]  # 刪除索引1到2的元素（左閉右開）
print(nums)    # 輸出：[10, 40]

# 1. len() - 統(tǒng)計列表元素個數
nums = [10, 20, 30]
print("列表長度：", len(nums))  # 輸出：3

# 2. count() - 統(tǒng)計指定元素出現的次數
nums = [1, 2, 2, 3, 2]
print("元素2出現的次數：", nums.count(2))  # 輸出：3

# 3. index() - 查找元素首次出現的索引（元素不存在會報錯）
nums = [10, 20, 30, 20]
print("元素20首次出現的索引：", nums.index(20))  # 輸出：1
# 可指定查找范圍：nums.index(20, 2) → 從索引2開始找20，返回3

# 4. sort() - 原地排序（修改原列表，無返回值）
nums = [30, 10, 20]
nums.sort()  # 默認升序排序
print("升序排序后：", nums)  # 輸出：[10, 20, 30]

nums.sort(reverse=True)  # 降序排序
print("降序排序后：", nums)  # 輸出：[30, 20, 10]

# 5. sorted() - 排序（返回新列表，原列表不變）
nums = [30, 10, 20]
new_nums = sorted(nums)  # 升序
print("原列表：", nums)     # 輸出：[30, 10, 20]（不變）
print("新列表：", new_nums) # 輸出：[10, 20, 30]

# 6. reverse() - 原地反轉列表（修改原列表）
nums = [10, 20, 30]
nums.reverse()
print("反轉后：", nums)  # 輸出：[30, 20, 10]

# 7. copy() - 淺拷貝（新列表和原列表互不影響）
nums = [10, 20]
nums2 = nums.copy()  # 拷貝nums到nums2
nums2[0] = 100       # 修改nums2的元素
print("原列表：", nums)   # 輸出：[10, 20]（不受影響）
print("拷貝列表：", nums2) # 輸出：[100, 20]

# 方式1：創(chuàng)建空元組
t1 = ()

# 方式2：直接賦值（多元素）
t2 = (1, 2, "Python")

# 方式3：單元素元組（必須加逗號，否則不是元組）
t3 = (10,)  # 正確：元組
# t3 = (10)  # 錯誤：只是數字10，不是元組

# 方式4：省略括號（元組打包）
t4 = 10, 20, 30  # 等價于 (10,20,30)

# 方式5：類型轉換
t5 = tuple([1, 2, 3])  # 列表轉元組 → (1, 2, 3)
t6 = tuple("abc")      # 字符串轉元組 → ('a', 'b', 'c')

# 定義示例元組
t = (10, 20, 30, 40)

# 1. 索引取值
print(t[0])    # 取第一個元素 → 10
print(t[-1])   # 取最后一個元素 → 40

# 2. 切片取值
print(t[1:3])  # 取索引1到2的元素 → (20, 30)
print(t[::2])  # 步長2 → (10, 30)

# 3. 遍歷元素
# 普通遍歷
for num in t:
    print(num)  # 依次輸出：10, 20, 30, 40

# 帶索引遍歷
for index, num in enumerate(t):
    print(f"索引{index}：{num}")

# 1. 強行修改元組元素 → 報錯
t = (10, 20, 30)
# t[0] = 100  # 執(zhí)行報錯：TypeError: 'tuple' object does not support item assignment

# 2. 例外：元組中的可變元素（如列表）可修改內部值
t = (1, [2, 3])  # 元組包含列表（可變）
t[1][0] = 20     # 修改列表的第一個元素
print(t)         # 輸出：(1, [20, 3])（元組本身結構未變）

# 1. len() - 統(tǒng)計元組長度
t = (10, 20, 30)
print("元組長度：", len(t))  # 輸出：3

# 2. count() - 統(tǒng)計元素出現次數
t = (1, 2, 2, 3, 2)
print("元素2出現次數：", t.count(2))  # 輸出：3

# 3. index() - 查找元素首次出現的索引
t = (10, 20, 30, 20)
print("元素20首次索引：", t.index(20))  # 輸出：1
# 指定查找范圍：t.index(20, 2) → 從索引2開始找，返回3

# 場景1：函數返回多值（本質是返回元組）
def get_user_info():
    # 函數返回多個值，自動打包成元組
    return "小明", 18, "北京"

# 解包元組到多個變量
name, age, city = get_user_info()
print(name, age, city)  # 輸出：小明 18 北京

# 場景2：作為字典的鍵（可哈希）
# 列表不可作為字典鍵，但元組可以
user_coords = {(100, 200): "用戶1", (300, 400): "用戶2"}
print(user_coords[(100, 200)])  # 輸出：用戶1

# 場景3：存儲固定配置（不可修改，更安全）
config = ("localhost", 8080, "utf-8")  # 數據庫配置等固定值
print("服務器地址：", config[0])  # 輸出：localhost

# 方式1：創(chuàng)建空集合（必須用set()）
s1 = set()

# 方式2：直接賦值（自動去重，元素需可哈希）
s2 = {1, 2, 3, 3, 4}  # 重復的3被自動去重 → {1, 2, 3, 4}

# 方式3：集合推導式（快速生成）
# 生成1-3的集合，自動去重
s3 = {x for x in [1, 2, 2, 3]}  # 結果：{1, 2, 3}

# 方式4：類型轉換（自動去重）
s4 = set([1, 2, 2, 3])  # 列表轉集合 → {1, 2, 3}
s5 = set("aabbcc")       # 字符串轉集合 → {'a', 'b', 'c'}

# 定義示例集合
s = {1, 2, 3}

# 1. 遍歷元素（順序隨機）
for num in s:
    print(num)  # 輸出順序可能是1,3,2 或 2,1,3等

# 2. pop() - 隨機刪除并返回一個元素（集合無序，無“第一個”元素）
s = {1, 2, 3}
removed_num = s.pop()
print("隨機刪除的元素：", removed_num)  # 隨機返回1/2/3
print("刪除后的集合：", s)            # 剩余2個元素

# 1. add() - 添加單個元素（已存在則不操作）
s = {1, 2, 3}
s.add(4)    # 添加新元素4
s.add(2)    # 元素2已存在，無操作
print(s)    # 輸出：{1, 2, 3, 4}

# 2. update() - 批量添加可迭代對象的元素
s = {1, 2, 3}
s.update([4, 5])  # 添加列表的元素
# 也可傳元組/字符串：s.update((6,7)) / s.update("ab")
print(s)          # 輸出：{1, 2, 3, 4, 5}

# 3. remove() - 按值刪除（元素不存在則報錯）
s = {1, 2, 3}
s.remove(2)       # 刪除元素2
print(s)          # 輸出：{1, 3}
# s.remove(10)    # 元素10不存在，報錯：KeyError

# 4. discard() - 按值刪除（元素不存在不報錯，推薦使用）
s = {1, 2, 3}
s.discard(10)     # 元素10不存在，無操作、無報錯
print(s)          # 輸出：{1, 2, 3}

# 5. pop() - 隨機刪除并返回一個元素
s = {1, 2, 3}
removed = s.pop()
print("刪除的元素：", removed)  # 隨機輸出1/2/3
print("剩余集合：", s)          # 剩余2個元素

# 6. clear() - 清空集合
s = {1, 2, 3}
s.clear()
print(s)  # 輸出：set()（空集合）

# 7. 修改元素 - 集合無直接修改方法，需先刪后加
s = {1, 2, 3}
s.discard(2)  # 刪除舊元素
s.add(20)     # 添加新元素
print(s)      # 輸出：{1, 3, 20}

# 定義兩個示例集合
s1 = {1, 2, 3}
s2 = {2, 3, 4}

# 1. 并集：包含s1和s2的所有元素（去重）
print("并集：", s1 | s2)          # 符號寫法 → {1,2,3,4}
print("并集：", s1.union(s2))     # 方法寫法 → {1,2,3,4}

# 2. 交集：s1和s2都有的元素
print("交集：", s1 & s2)              # 符號寫法 → {2,3}
print("交集：", s1.intersection(s2)) # 方法寫法 → {2,3}

# 3. 差集：s1有但s2沒有的元素
print("差集：", s1 - s2)             # 符號寫法 → {1}
print("差集：", s1.difference(s2))    # 方法寫法 → {1}

# 4. 對稱差集：s1和s2互不相同的元素
print("對稱差集：", s1 ^ s2)                      # 符號寫法 → {1,4}
print("對稱差集：", s1.symmetric_difference(s2))   # 方法寫法 → {1,4}

# 5. 子集判斷：判斷s2的子集是否包含于s1
s3 = {1, 2}
print("s3是否是s1的子集：", s3.issubset(s1))  # 輸出：True

# 6. 超集判斷：判斷s1是否包含s3的所有元素
print("s1是否是s3的超集：", s1.issuperset(s3))  # 輸出：True

# 方式1：創(chuàng)建空字典
d1 = {}

# 方式2：直接賦值（鍵值對形式）
# 鍵：可哈希（字符串/數字/元組）；值：任意類型（列表/字典等）
d2 = {"name": "小明", "age": 18, "hobby": ["籃球", "游戲"]}

# 方式3：dict()構造函數（鍵不加引號）
d3 = dict(name="小紅", age=20)  # 結果：{'name':'小紅', 'age':20}

# 方式4：列表轉字典（元素為鍵值對元組）
d4 = dict([("name", "小剛"), ("age", 19)])  # 結果：{'name':'小剛', 'age':19}

# 方式5：字典推導式（快速生成）
# 鍵為a/b，值為對應值的2倍
d5 = {k: v * 2 for k, v in {"a": 1, "b": 2}.items()}  # 結果：{'a':2, 'b':4}

# 方式6：zip()創(chuàng)建（鍵和值分別來自兩個可迭代對象）
keys = ["name", "age"]    # 鍵列表
values = ["小李", 21]     # 值列表
d6 = dict(zip(keys, values))  # 結果：{'name':'小李', 'age':21}

# 定義示例字典
d = {"name": "小明", "age": 18}

# 1. 按鍵取值（鍵不存在會報錯）
print(d["name"])  # 輸出：小明
# print(d["gender"])  # 鍵不存在，報錯：KeyError

# 2. get()安全取值（推薦使用，鍵不存在返回默認值/None）
print(d.get("gender"))        # 無默認值，返回None
print(d.get("gender", "男"))  # 有默認值，返回：男

# 3. 取所有鍵（返回dict_keys對象，可轉列表）
keys = d.keys()
print("所有鍵：", keys)          # 輸出：dict_keys(['name', 'age'])
print("鍵列表：", list(keys))    # 轉列表 → ['name', 'age']

# 4. 取所有值（返回dict_values對象，可轉列表）
values = d.values()
print("所有值：", values)        # 輸出：dict_values(['小明', 18])
print("值列表：", list(values))  # 轉列表 → ['小明', 18]

# 5. 取所有鍵值對（返回dict_items對象，可轉列表）
items = d.items()
print("所有鍵值對：", items)    # 輸出：dict_items([('name','小明'),('age',18)])
print("鍵值對列表：", list(items))  # 轉列表 → [('name','小明'),('age',18)]

# 6. 遍歷字典（默認遍歷鍵）
for k in d:
    print(f"鍵：{k}，值：{d[k]}")  # 輸出：鍵：name，值：小明；鍵：age，值：18

# 7. 遍歷鍵值對（更高效）
for k, v in d.items():
    print(f"鍵：{k}，值：{v}")  # 同上，但無需二次取值

# 定義示例字典
d = {"name": "小明", "age": 18}

# 1. 增加/修改鍵值對（鍵存在則改，不存在則增）
d["age"] = 19        # 鍵age存在 → 修改值為19
d["city"] = "北京"   # 鍵city不存在 → 新增鍵值對
print(d)             # 輸出：{'name':'小明', 'age':19, 'city':'北京'}

# 2. update() - 批量增加/修改
d.update({"age": 20, "gender": "男"})  # 修改age，新增gender
print(d)                               # 輸出：{'name':'小明', 'age':20, 'city':'北京', 'gender':'男'}

# 3. del - 按鍵刪除（鍵不存在報錯）
del d["city"]        # 刪除city鍵值對
print(d)             # 輸出：{'name':'小明', 'age':20, 'gender':'男'}
# del d["hobby"]     # 鍵不存在，報錯：KeyError

# 4. pop() - 按鍵刪除，返回被刪除的值（鍵不存在返回默認值）
removed_age = d.pop("age")  # 刪除age，返回20
print("被刪除的值：", removed_age)  # 輸出：20
print("刪除后字典：", d)            # 輸出：{'name':'小明', 'gender':'男'}

# 鍵不存在時返回默認值（無報錯）
removed_hobby = d.pop("hobby", "無")
print(removed_hobby)  # 輸出：無

# 5. popitem() - 刪除最后一個鍵值對（3.7+按插入順序）
d = {"name": "小明", "age": 18, "city": "北京"}
last_item = d.popitem()
print("刪除的鍵值對：", last_item)  # 輸出：('city', '北京')
print("刪除后字典：", d)            # 輸出：{'name':'小明', 'age':18}

# 6. clear() - 清空字典
d.clear()
print(d)  # 輸出：{}（空字典）

# 定義示例字典
d = {"name": "小明", "age": 18}

# 1. len() - 統(tǒng)計鍵值對數量
print("鍵值對數量：", len(d))  # 輸出：2

# 2. copy() - 淺拷貝（新字典和原字典互不影響）
d2 = d.copy()    # 拷貝d到d2
d2["name"] = "小紅"  # 修改d2的name
print("原字典：", d)   # 輸出：{'name':'小明', 'age':18}（不受影響）
print("拷貝字典：", d2) # 輸出：{'name':'小紅', 'age':18}

# 3. setdefault() - 查/增鍵值對
# 鍵age存在 → 返回對應值，不修改
age = d.setdefault("age", 20)
print("age的值：", age)  # 輸出：18
print(d)                # 輸出：{'name':'小明', 'age':18}

# 鍵gender不存在 → 新增鍵值對，返回默認值
gender = d.setdefault("gender", "男")
print("gender的值：", gender)  # 輸出：男
print(d)                      # 輸出：{'name':'小明', 'age':18, 'gender':'男'}

# 1. 列表 ? 元組
lst = [1, 2, 3]
tup = tuple(lst)  # 列表轉元組 → (1, 2, 3)
lst2 = list(tup)  # 元組轉列表 → [1, 2, 3]

# 2. 列表/元組 ? 集合（自動去重）
lst = [1, 2, 2, 3]
s = set(lst)      # 列表轉集合 → {1, 2, 3}（去重）
lst2 = list(s)    # 集合轉列表 → [1, 2, 3]（順序隨機）

# 3. 列表/元組 → 字典（zip()）
keys = ["name", "age"]   # 鍵列表
values = ["小明", 18]    # 值列表
d = dict(zip(keys, values))  # 轉字典 → {'name':'小明', 'age':18}

# 4. 字典 → 列表/元組
d = {"name": "小明", "age": 18}
key_lst = list(d.keys())    # 鍵轉列表 → ['name', 'age']
value_lst = list(d.values())# 值轉列表 → ['小明', 18]
item_lst = list(d.items())  # 鍵值對轉列表 → [('name','小明'), ('age',18)]