07. Python語言的核心編程 · 第七章 Python的元組&字典&集合

1. 元組簡介

 元組基本介紹：
  1) 元組表現形式是 tuple。
  2) Python的 元組 與 列表 類似，不同之處在於元組的元素不能修改。所以 元組是一個不可變序列(一般當我們希望數據不改變時，我們使用元組，其他情況下基本都用列表)

1.1 元組的 增

  3) 元組使用小括號既 () 創建元素。

# 創建一個 空元組
tuple = ()

  4) 元組創建很簡單，只需要在括號中添加元素，元素之間使用逗號隔開即可；當元組不是空元組時括號可以省略。

>>>tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括號也可以
>>> type(tup3)
<class 'tuple'>

  5) 元組中 只包含一個元素 時，需要在元素後面添加逗號，否則括號會被當作運算符使用：

>>>tup1 = (50)
>>> type(tup1)     # 不加逗號，類型爲整型
<class 'int'>
 
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗號，類型爲元組
<class 'tuple'>

  元組與字符串類似，下標索引從0開始，可以進行截取，組合等。

1.2 元組的 改

  6) 修改元組：元組中的元素值是不允許修改的，但我們可以對元組進行連接組合。

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元組元素操作是非法的。
# tup1[0] = 100
 
# 創建一個新的元組
tup3 = tup1 + tup2
print (tup3)
# (12, 34.56, 'abc', 'xyz')

1.3 元組的 刪

  7) 刪除元組：元組中的元素值是不允許刪除的，但我們可以使用 del語句 來刪除整個元組。

tup = ('Google', 'CSDN', 1997, 2000)
 
print (tup)

del tup
print ("刪除後的元組 tup : ")

print (tup)

# 刪除後的元組 tup : 
# Traceback (most recent call last):
#   File "test.py", line 8, in <module>
#     print (tup)
# NameError: name 'tup' is not defined

1.4 元組的 查

  8) 訪問元組：元組可以使用下標索引來訪問元組中的值。

tup1 = ('Google', 'CSDN', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
# tup1[0]:  Google
print ("tup2[1:5]: ", tup2[1:5])
# tup2[1:5]:  (2, 3, 4, 5)

  9) 元組解包 指將元組當中的每一個元素都賦值給一個變量。

my_tuple = 10,20,30,40  # 當元組不爲空時，括號是可以省略的

a,b,c,d = my_tuple  # 元組的解包     解包就是指將元組當中的每一個元素都賦值給變量

print('a =',a)
print('b =',b)
print('c =',c)
print('d =',d)
# a = 10
# b = 20
# c = 30
# d = 40

# 在元組解包時，變量的數量必須和元組中的數據一一對應；
# 如果出現的變量和元組中元素數量不一致時，在收納多餘元素的變量前加 * ；
# 變量數量不可多於元組中的元素數量

# a,b = my_tuple  # 值太多了，變量不夠。    # ValueError: too many values to unpack (expected 2)

a,b,*c = my_tuple   # * ：以 列表 的形式，把剩餘的元素打包賦值給 c

print('a =',a)
print('b =',b)
print('*c =',*c)
# a = 10
# b = 20
# *c = 30 40

# a,b,*c = [1,2,3,4,5,6,7,8,9]

a,b,*c = 'python and JAVA'

print('a =',a)
print('b =',b)
print('*c =',*c)
print('c =',c)
# a = p
# b = y
# *c = t h o n   a n d   J A V A
# c = ['t', 'h', 'o', 'n', ' ', 'a', 'n', 'd', ' ', 'J', 'A', 'V', 'A']

print(my_tuple,type(my_tuple))
# (10, 20, 30, 40) <class 'tuple'>

print(my_tuple[3])
# 40

  10) 元組索引，截取：因爲元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以 截取索引中的一段元素。

# 創建一個元組
L = ('Google', 'Taobao', 'Runoob')

  運行實例如下：

>>> L = ('Google', 'Taobao', 'Runoob')
>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')

1.5 元組的 運算符 和 操作函數

  11) 元組運算符：與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味着他們可以 組合和複製，運算後會生成一個 新的元組。

  12) 元組內置函數：Python元組包含了以下內置函數

  最後 簡單的解釋一下爲什麼“元組是不可變的”：所謂 元組的不可變 指的是元組所指向的內存中的內容不可變。

>>> tup = ('C', 'S', 'D', 'N')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看內存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 內存地址不一樣了

  從以上實例可以看出，重新賦值的元組 tup，綁定到新的對象了，不是修改了原來的對象。

  

2. 可變對象

  Python中 數值類型（int和float）、字符串str、元組tuple 都是 不可變類型 ；而 列表list、字典dict、集合set 是 可變類型 。
  可變對象中都保存了三個數據：
  id(標識)  type(類型)  value(值)
  在這裏，我們說的可變變量指的是我們可以對對象裏面的 value 進行改變。

2.1 第一個可變對象方法：修改列表

a = [1,2,3]
a[0] = 10 		# (改對象)

print(a)
# [10, 2, 3]

  這個操作是通過變量去修改對象的值；
  這種操作不會改變變量所指向的對象。

a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112

a = [1,2,3]
print('修改後：',a,id(a))
# 修改前： [1, 2, 3] 2048896731392

  這個操作在給變量 重複賦值；
  這種操作會改變變量所指向的存儲對象。

  如果不太理解上面這段話想傳遞給你的意思，我給你一個能讓你快速理解上面這段話的方法和思想實驗：多創建幾個 相同的變量 a ，創建好後 打印它們的id 看輸出的值後 你應該能理解。這個反饋的id的值就是這個 變量 a 在我們使用的硬盤裏的位置 。你有十幾個或幾百個和你的 長相長得 一模一樣的“兄弟” 或者是 和你的 名字 一模一樣人，雖然他們都和你 住在同一個地球上，但你們 不可能會 住在同一個國家、同一個城市、同一個小區、同一個房間。

2.2 第二個可變對象方法：修改索引

a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112

# 通過索引修改列表
a[0] = 30
print('修改後：',a,id(a))
# 修改後： [30, 2, 3] 2020252459904

2.3 第三個可變對象方法：修改變量

a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112

# 通過變量給列表重新賦值
a = [7,8,9]
print('修改後：',a,id(a))
# 修改後： [7, 8, 9] 2681969838464

2.4 接下來我們講第三個可變對象方法：修改對象

  修改對象裏的值會影響到所有指向該對象的 變量值，但不會改變該對象的 id。

a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112

# 修改對象裏的值會影響到所有指向該對象的變量值，但不會改變該對象的 id
b = a
b[0] = 30
print('修改後：',b,id(b))
# 修改後： [30, 2, 3] 2048896738112

  修改對象的列表 不僅會影響到所有指向該對象的 變量值，還會改變該對象的 id。

a = [1,2,3]
print('修改前：',a,id(a))
# 修改前： [1, 2, 3] 2048896738112

# 修改對象裏的列表 不僅會影響到所有指向該對象的變量值，還會改變該對象的 id 
b = a
b = [50,60,90]
print('修改後：',b,id(b))
# 修改後： [50, 60, 90] 2823356090688

  

3. 字典簡介

3.1 字典的基本介紹

  “字典”，我第一次聽到這個詞的時候給我的第一感覺還是怪瘮人的。 爲什麼？ 原因很簡單：因爲，學習了計算機這麼久，但是以前都沒聽過。現在我就給大家簡單且通俗易懂的解釋一下 什麼是Python語言裏的“字典”。
  Python語言 裏有種一種可變容器模型，且可存儲任意類型對象；它的特點是 能對數據快速進行檢索。我們對這類 數據存儲方式 ，叫“ 鍵(key)·值(value)對(key-value) ”，它的整體佈局和使用就像我們小時候使用的 《新華字典》 是一樣一樣的；所以，我們簡稱這種數據存儲格式爲 “字典”；通過 “鍵(key)” 來索引查找相對的“值(value)”。字典的 值(value) 可以是 任意對象，你沒有看錯；但字典的鍵(key) 可以是 任意的不可變對象 ；簡單的講，不同版本的 《新華字典》 內容還是大同小異的，但頁數是基本不變的(加量不加價的…)；內容是可以隨着版本不斷的更新而改變的，但那一頁對應的是什麼內容是不可更改的。字典的 鍵(key) 是不能重複的，就像一本字典裏不可能出現內容不同卻頁數相同的兩頁(邏輯不附)；如果出現重複的鍵(key)，後面的鍵(key)·值(value)對(key-value) 會替換 前面的鍵(key)·值(value)對(key-value)。
  OK，廢話了這麼多，接下來我來詳細且專業的給大家介紹一下字典的各項屬性、特點和使用。

  字典是另一種可變容器模型，且可存儲 任意類型對象。
  字典屬於一種新的數據結構稱爲 映射(mapping)；
  字典的作用和列表類似，都是用來存儲對象的容器；
  列表存儲數據的性能好，但是查詢數據的性能差，字典正好與之相反；
  在字典中每一個元素都有唯一的名字，通過這個唯一的名字可以找到指定的元素；
  這個 唯一的名字 我們稱之爲 鍵(key) 通過key可以快速查詢到對應的 value 也可以稱之爲 值；
  字典我們也稱之爲 鍵(key)·值(value)對(key-value) 結構
  每個字典中都 可以有多個 鍵值對(key-value)，而每一個 鍵值對(key-value) 我們稱其爲 一項(item)；
  字典的每個 鍵(key)與值(value) 之間用 冒號( : ) 分割 ，每個對之間用逗號(,)分割，整個字典 包括在 花括號({}) 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

  字典的 值(value) 可以是 任意對象，字典的 鍵(key) 可以是 任意的不可變對象(int str bool tuple…)；
  字典的 鍵(key) 是 不能重複 的，如果出現重複的後面的鍵(key)·值(value)對會替換前面的鍵(key)·值(value)對。
  一個簡單的字典實例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

  也可如此創建字典：

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

  

3.2 字典的使用

  我們根據 增·刪·改·查 思路來拆解字典的使用

3.2.1 字典的 查 – 遍歷字典

  我們主要可以通過下面 4種方式 對字典進行遍歷。
  keys() ：該方法返回字典所有的key；返回一個迭代器，可以使用 list() 來轉換爲列表。

>>> dict = {'Name': 'Jiang', 'Age': 27}
>>> dict.keys()
dict_keys(['Name', 'Age'])
>>> list(dict.keys())             # 轉換爲列表
['Name', 'Age']
>>> 

  values() ：該方法返回 一個序列 ，序列中保存有 字典所有的值；返回一個迭代器，可以使用 list() 來轉換爲列表。

dict = {'Name': 'Jiang', 'Age': 27, 'Class': 'Read'}

print("字典所有值爲 : ", list(dict.values()))
# 字典所有值爲 :  ['Jiang', 27, 'Read']

  items() ：該方法會返回字典中 所有的項，它返回一個 序列，序列中包含有 雙值子序列，雙值分別是字典中的 鍵(key)與值(value) 。

dict = {'Name': 'Jiang', 'Age': 27}

print("Value : %s" % dict.items())
# Value : dict_items([('Name', 'Jiang'), ('Age', 27)])

  訪問字典裏的值；把相應的鍵放入到方括號中就可以了；如下實例：

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

# 輸出結果：
# dict['Name']:  Runoob
# dict['Age']:  7

  如果用字典裏沒有的鍵訪問數據，會輸出錯誤如下：

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Alice']: ", dict['Alice'])

# 輸出結果：
# Traceback (most recent call last):
#   File "test.py", line 5, in <module>
#     print ("dict['Alice']: ", dict['Alice'])
# KeyError: 'Alice'

3.2.2 字典的 增 和 改

  向字典 添加 新內容的方法是 增加新的鍵/值對，修改 已有鍵/值對 如下實例：

dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}

print("沒修改的 dict: ", dict)
# 沒修改的 dict:  {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}

print("沒修改的 dict['Age']: ", dict['Age'])
# 沒修改的 dict['Age']:  7

dict['Age'] = 8  # 更新 Age
dict['Blog'] = "雲山·若水的博客"  # 添加信息

print("修改後的 dict: ", dict)
# 修改後的 dict:  {'Name': 'CSDN', 'Age': 8, 'Class': 'Read', 'Blog': '雲山·若水的博客'}

print("修改後的 dict['Age']: ", dict['Age'])
# 修改後的 dict['Age']:  8

print("修改後的 dict['Blog']: ", dict['Blog'])
# 修改後的 dict['Blog']:  雲山·若水的博客

3.2.3 字典的 刪

  刪除字典元素 能刪單一的元素也 能清空字典，清空只需一項操作。顯示刪除一個字典用 del 命令，如下實例：

dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
print("沒修改的 dict[]: ", dict)
# 還沒修改的 dict[]:  {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}

del dict['Name'] 		# 刪除鍵 'Name'
print("修改後的 dict[]: ", dict)
# 修改的後的 dict[]:  {'Age': 7, 'Class': 'Read'}

dict.clear()     # 清空字典
del dict         # 刪除字典
 
print ("修改後的 dict['Age']: ", dict['Age'])
print ("修改後的 dict['School']: ", dict['School'])
# Traceback (most recent call last):
#   File "test.py", line 9, in <module>
#     print ("dict['Age']: ", dict['Age'])
# TypeError: 'type' object is not subscriptable

3.2.4 字典鍵的特性

  字典值可以是任何的 Python 對象，既可以是標準的對象，也可以是用戶自定義的，但鍵不行。

  而且，下面的 兩個重要的點 需要記住：

  1) 不允許 同一個鍵出現兩次。這個注意點在開篇時就着重的多次提到過。創建時如果出現重複的鍵(key)，後面的鍵(key)·值(value)對(key-value) 會替換 前面的鍵(key)·值(value)對(key-value)。如下實例：

dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read', 'Name': '小菜鳥'}
 
print ("dict['Name']: ", dict['Name'])
# dict['Name']:  小菜鳥

  2) 鍵必須不可變！！！所以可以用 數字、字符串 或 元組 充當，但用列表就不行。如下實例：

dict = {['Name']: 'CSDN', 'Age': 7, 'Class': 'Read'}
 
print ("dict['Name']: ", dict['Name'])
# 輸出結果：
# Traceback (most recent call last):
#   File "test.py", line 3, in <module>
#     dict = {['Name']: 'Runoob', 'Age': 7}
# TypeError: unhashable type: 'list'

3.2.5 字典的內置函數&方法

  Python字典包含了以下內置函數：

  Python字典包含了以下內置方法：

   1) radiansdict.clear() ：刪除字典 內所有元素

dict = {'Name': 'CSDN', 'Age': 7, 'Class': 'Read'}
print ("字典長度 : %d" %len(dict))
# 字典長度 : 3

dict.clear()
print ("字典刪除後長度 : %d" %len(dict))
# 字典刪除後長度 : 0

  2) radiansdict.copy() ：返回一個字典的 淺複製

dict1 = {'user': 'Jiang', 'num': [1, 2, 3]}

dict2 = dict1  # 淺拷貝: 引用對象
dict3 = dict1.copy()  # 淺拷貝：深拷貝父對象（一級目錄），子對象（二級目錄）不拷貝，還是引用

# 修改 data 數據
dict1['user'] = 'root'
dict1['num'].remove(1)

# 輸出結果
print(dict1,id(dict1))
# {'user': 'root', 'num': [2, 3]} 2071738592064
print(dict2,id(dict2))
# {'user': 'root', 'num': [2, 3]} 2071738592064
print(dict3,id(dict3))
# {'user': 'Jiang', 'num': [2, 3]} 2071738592128

  3) radiansdict.fromkeys(seq[, value])：創建一個新字典，以序列seq中元素做字典的鍵，val爲字典所有鍵對應的初始值

seq = ('name', 'age', 'sex')
 
dict = dict.fromkeys(seq)
print ("新的字典爲 : %s" %str(dict))
# 新的字典爲 : {'age': None,'name': None,'sex': None}

dict = dict.fromkeys(seq, 10)
print ("新的字典爲 : %s" %str(dict))
# 新的字典爲 : {'age': 10, 'name': 10, 'sex': 10}

  4) radiansdict.get(key, default=None) ：返回指定鍵的值，如果值不在字典中返回default(默認)值

dict = {'Name': 'Jiang', 'Age': 27}

print ("Age 值爲 : %s" %dict.get('Age'))
# Age 值爲 : 27
print ("Sex 值爲 : %s" %dict.get('Sex', "NA"))
# Sex 值爲 : NA

  5) key in dict ：如果鍵在字典dict裏返回true，否則返回false

dict = {'Name': 'Jiang', 'Age': 27}

# 檢測鍵 Age 是否存在
if 'Age' in dict:
    print("鍵 Age 存在")
else:
    print("鍵 Age 不存在")
# 鍵 Age 存在

# 檢測鍵 Sex 是否存在
if 'Sex' in dict:
    print("鍵 Sex 存在")
else:
    print("鍵 Sex 不存在")
# 鍵 Sex 不存在

# not in
# 檢測鍵 Age 是否存在
if 'Age' not in dict:
    print("鍵 Age 不存在")
else:
    print("鍵 Age 存在")
# 鍵 Age 存在

  6) radiansdict.items() ：以 列表返回 可遍歷的(鍵, 值) 元組數組

dict = {'Name': 'Jiang', 'Age': 27}

print("Value : %s" % dict.items())
# Value : dict_items([('Name', 'Jiang'), ('Age', 27)])

  7) radiansdict.keys() ：返回一個迭代器，可以使用 list() 來轉換爲列表

>>> dict = {'Name': 'Jiang', 'Age': 27}
>>> dict.keys()
dict_keys(['Name', 'Age'])
>>> list(dict.keys())             # 轉換爲列表
['Name', 'Age']
>>> 

  8) radiansdict.setdefault(key, default=None) ：和get()類似, 但如果鍵不存在於字典中，將會添加鍵並將值設爲default

dict = {'Name': 'Jiang', 'Age': 27}

print("Age 鍵的值爲 : %s" % dict.setdefault('Age', None))
# Age 鍵的值爲 : 27

print("Sex 鍵的值爲 : %s" % dict.setdefault('Sex', None))
# Sex 鍵的值爲 : None

print("新字典爲：", dict)
# 新字典爲： {'Name': 'Jiang', 'Age': 27, 'Sex': None}

  9) radiansdict.update(dict2) ：把 字典dict2 的 鍵/值對 更新到 dict 裏。

dict = {'Name': 'Jiang', 'Age': 27}
dict2 = {'Class': 'Read'}
dict.update(dict2)

print("更新字典 dict : ", dict)
# 更新字典 dict :  {'Name': 'Jiang', 'Age': 27, 'Class': 'Read'}

  10) radiansdict.values() ：返回一個迭代器，可以使用 list() 來轉換爲列表

dict = {'Name': 'Jiang', 'Age': 27, 'Class': 'Read'}

print("字典所有值爲 : ", list(dict.values()))
# 字典所有值爲 :  ['Jiang', 27, 'Read']

  11) pop(key[,default]) ：刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。 否則，返回 default值。

site= {'name': 'CSDN', 'alexa': 10000, 'url': 'https://www.csdn.net'}
pop_obj=site.pop('name')

print(pop_obj)
# CSDN

  12) popitem() ：刪除並返回字典中的最後一對鍵(key) 和 值(value。

site= {'name': 'CSDN', 'alexa': 10000, 'url': 'https://www.csdn.net'}
pop_obj=site.popitem()

print(pop_obj)
# ('url', 'https://www.csdn.net')

print(site)
# {'name': 'CSDN', 'alexa': 10000}

  

4. 集合

4.1 集合簡介

  集合表現形式：set 集合；和 列表 非常相似。

  不同點：
  1) 集合 只能存儲 不可變對象；
  2) 集合中存儲的對象是 無序 的；
  3) 集合 不能出現 重複元素。

  使用大括號 { } 來創建集合；
  可以通過 set() 函數創建集合，或者將序列和字典 轉換成 集合。

  注意：創建一個 空集合 必須用 set() ，而不是 { }。因爲 { } 是用來創建一個 空字典 的。

parame = {value01,value02,...}

# 或者

set(value)

  參考實例：

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 這裏演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判斷元素是否在集合內
True
>>> 'crabgrass' in basket
False
 
>>> # 下面展示兩個集合間的運算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同時包含於a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

  類似列表推導式，同樣集合支持集合推導式(Set comprehension):

>>>a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

4.2 集合的基本操作

  我們根據 增·刪·改·查 思路來拆解字典的使用

4.2.1 集合的查

  使用 len() 來獲取集合中元素的數量。語法格式如下：

len(s)

  計算集合 s 元素個數。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

print(len(thisset))
# 4

  判斷元素 是否在集合中 存在。語法格式如下：

x in s

  判斷元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

print("Runoob" in thisset)
# False

print("Facebook" in thisset)
# True

print("Runoob" not in thisset)
# True

print("Facebook" not in thisset)
# False

4.2.2 集合的增 · 向集合裏添加元素

  add() 向集合中 添加元素。語法格式如下：

s.add( x )

  將元素 x 添加到集合 s 中，如果元素已存在，則不進行任何操作。

thisset = set(("CSDN", "Google", "Taobao"))

thisset.add("Facebook")
print(thisset)
# {'Taobao', 'Facebook', 'Google', 'CSDN'}

  也可以添加元素，update() 將一個集合中的元素添加到另一個集合當中且參數可以是列表，元組，字典等。語法格式如下：

s.update( x )

  x 可以有多個，用逗號分開。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

thisset.update({1,3})
print(thisset)
# {1, 3, 'Facebook', 'CSDN', 'Google', 'Taobao'}

thisset.update([1,4],[5,6])
print(thisset)
# {1, 3, 4, 5, 6, 'CSDN', 'Google', 'Taobao', 'Facebook'}

4.2.3 集合的刪 · 移除元素

  remove() 刪除集合中指定的元素，語法格式如下：

s.remove( x )

  將元素 x 從集合 s 中移除，如果元素不存在，則會發生錯誤。

thisset = set(("CSDN", "Google", "Taobao"))

thisset.remove("Taobao")
print(thisset)
# {'Google', 'CSDN'}

thisset.remove("Facebook")   				# 不存在會發生錯誤

# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# KeyError: 'Facebook'

  此外還有一個方法也是移除集合中的元素，且如果元素不存在，不會發生錯誤。格式如下所示：

s.discard( x )

  參考實例：

thisset = set(("Google", "CSDN", "Taobao"))

thisset.discard("Facebook")  # 不存在不會發生錯誤
print(thisset)
# {'Google', 'CSDN', 'Taobao'}

  pop() 隨機刪除集合中的一個元素一般是刪除最後一個元素。語法格式如下：

s.pop() 

  參考實例：

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))

x = thisset.pop()
print(x)
# Google

  clear() 清空集合，語法如下：

s.clear()

  參考案例：清空集合 s。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

thisset.clear()
print(thisset)
# set()

4.2.4 集合內置方法完整列表

  len() 來獲取集合中元素的數量。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

print(len(thisset))
# 4

  add() 向集合中添加元素。

thisset = set(("CSDN", "Google", "Taobao"))

thisset.add("Facebook")
print(thisset)
# {'Taobao', 'Facebook', 'Google', 'CSDN'}

  in / not in 判斷 元素是否在集合中存在。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

print("Runoob" in thisset)
# False

print("Facebook" in thisset)
# True

print("Runoob" not in thisset)
# True

print("Facebook" not in thisset)
# False

  update() 將一個集合中的元素添加到另一個集合當中且參數可以是列表，元組，字典等。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

thisset.update({1,3})
print(thisset)
# {1, 3, 'Facebook', 'CSDN', 'Google', 'Taobao'}

thisset.update([1,4],[5,6])
print(thisset)
# {1, 3, 4, 5, 6, 'CSDN', 'Google', 'Taobao', 'Facebook'}

  remove() 刪除集合中指定的元素。

thisset = set(("CSDN", "Google", "Taobao"))

thisset.remove("Taobao")
print(thisset)
# {'Google', 'CSDN'}

thisset.remove("Facebook")   				# 不存在會發生錯誤

# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# KeyError: 'Facebook'

  discard( x ) 移除集合中的元素，且如果元素不存在，不會發生錯誤。

thisset = set(("Google", "CSDN", "Taobao"))

thisset.discard("Facebook")  		# 不存在不會發生錯誤
print(thisset)
# {'Taobao', 'Google', 'CSDN'}

  pop() 隨機刪除集合中的一個元素一般是刪除最後一個元素。

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))

x = thisset.pop()
print(x)
# Google

  clear() 清空集合。

thisset = set(("CSDN", "Google", "Taobao", "Facebook"))

thisset.clear()
print(thisset)
# set()

  除了以上這些之前在文章中出現過的內置方法外， Python語言 的集合還有以下這些內置方法：

  copy() 拷貝一個集合

fruits = {"apple", "banana", "cherry"}
x = fruits.copy()

print(fruits,id(fruits))
# {'banana', 'cherry', 'apple'} 1796909613792
print(x,id(x))
# {'banana', 'cherry', 'apple'} 1796909613568

x.add("CSDN")

print(fruits,id(fruits))
# {'banana', 'cherry', 'apple'} 1796909613792

print(x,id(x))
# {'CSDN', 'banana', 'cherry', 'apple'} 1796909613568

  difference() 返回多個集合的差集

# 返回一個集合，元素包含在集合 x ，但不在集合 y ：

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
 
z = x.difference(y) 
 
print(z)
# {'cherry', 'banana'}

  difference_update() 移除集合中的元素，該元素在指定的集合也存在。

# 返回一個移除的集合，元素包含在集合 x ，但不在集合 y ：

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
 
x.difference_update(y) 
 
print(x)
# {'banana', 'cherry'}

  intersection() 返回集合的交集

# 返回一個新集合，該集合的元素既包含在集合 x 又包含在集合 y 中：
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.intersection(y) 
 
print(z)
# {'apple'}

  intersection_update() 返回集合的交集。

# 返回一個新集合，該集合的元素既包含在集合 x 又包含在集合 y 中：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.intersection_update(y) 
 
print(x)
# {'apple'}

  isdisjoint() 判斷兩個集合是否包含相同的元素，如果沒有返回 True，否則返回 False。

# 判斷集合 y 中是否有包含 集合 x 的元素：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
 
z = x.isdisjoint(y) 
 
print(z)
# True

#-----------------------------------------------------------------

# 如果包含返回 False：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.isdisjoint(y) 
 
print(z)
# False

  issubset() 判斷指定集合是否爲該方法參數集合的子集。

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
 
z = x.issubset(y) 
 
print(z)
# True

#-----------------------------------------------------------------

# 如果沒有全部包含返回 False：
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b"}
 
z = x.issubset(y) 
 
print(z)
# False

  issuperset() 判斷該方法的參數集合是否爲指定集合的子集

# 判斷集合 y 的所有元素是否都包含在集合 x 中：

x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
 
z = x.issuperset(y) 
 
print(z)
# True

#-----------------------------------------------------------------

# 如果沒有全部包含返回 False：

x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
 
z = x.issuperset(y) 
 
print(z)
# False

  symmetric_difference() 返回兩個集合中不重複的元素集合。

# 返回兩個集合組成的新集合，但會移除兩個集合的重複元素：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.symmetric_difference(y) 
 
print(z)
# {'google', 'cherry', 'banana', 'runoob'}

  symmetric_difference_update() 移除當前集合中在另外一個指定集合相同的元素，並將另外一個指定集合中不同的元素插入到當前集合中。

# 在原始集合 x 中移除與 y 集合中的重複元素，並將不重複的元素插入到集合 x 中：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.symmetric_difference_update(y) 
 
print(x)
# {'google', 'cherry', 'banana', 'runoob'}

  union() 返回兩個集合的並集

# 合併兩個集合，重複元素只會出現一次：

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.union(y) 
 
print(z)
# {'cherry', 'runoob', 'google', 'banana', 'apple'}

#-----------------------------------------------------------------

# 合併多個集合：

x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}
 
result = x.union(y, z) 
 
print(result)
# {'c', 'd', 'f', 'e', 'b', 'a'}

  

4.3 集合的運算

   & 交集運算

s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}

result = s1 & s2
print(s1,s2,result)
# {1, 2, 3, 4, 5, 6} {3, 4, 5, 6, 7, 8} {3, 4, 5, 6}

   | 並集運算

s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}

result = s1 | s2
print(result)
# {1, 2, 3, 4, 5, 6, 7, 8}

   - 差集運算

s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}
-
result = s1 - s2
print(result)
# {1, 2}

   ^ 亦或集

# 兩個集合不相交的部分

s1 = {1,2,3,4,5,6}
s2 = {3,4,5,6,7,8}

result = s1 ^ s2
print(result)
# {1, 2, 7, 8}

   <= 檢查一個集合是否是另一個集合的子集
   < 檢查一個集合是否是另一個集合的真子集

a = {1,2,3}
b = {1,2,3,4,5,6}

result = a < b    # a集合是b集合的子集
print(result)
# True

result = a <= b   # b集合是a集合的超集
print(result)
# True

   >=檢查一個集合是否是另一個集合的超集
   >檢查一個集合是否是另一個集合的真超集

a = {1,2,3}
b = {1,2,3,4,5,6}

result = a > b    # a集合是b集合的子集
print(result)
# False

result = a >= b   # b集合是a集合的超集
print(result)
# False

  

總結小便條

本篇文章主要講了以下幾點內容：

1. 元組 的表現形式是 tuple。
   1.1 Python的 元組 與 列表 類似，不同之處在於元組的元素不能修改。所以 元組是一個不可變序列(一般當我們希望數據不改變時，我們使用元組，其他情況下基本都用列表)
   1.2 元組 增·刪·改·查 的操作以及Python語言自帶的內置方法 這個只能靠自己 多看、多寫、多體會 了。

2. Python中 數值類型（int和float）、字符串str、元組tuple 都是 不可變類型 ；而 列表list、字典dict、集合set 是 可變類型 。
   2.1 可變對象中都保存了三個數據：
     id(標識)  type(類型)  value(值)
     在這裏，我們說的可變變量指的是我們可以對對象裏面的 value 進行改變。
   2.2 對 可變對象 的四種操作方法 這個只能靠自己 多看、多寫、多體會 了。

3. 字典 就是 鍵(key)·值(value)對(key-value)
   3.1 字典的語法表現形式： d = {key1 : value1, key2 : value2 }
   3.2 字典 增·刪·改·查 的操作以及Python語言自帶的內置方法 這個只能靠自己 多看、多寫、多體會 了。

4. 集合表現形式：set 集合；和 列表 非常相似。
   4.1 它與 列表 不同點：
     1) 集合 只能存儲 不可變對象；
     2) 集合中存儲的對象是 無序 的；
     3) 集合 不能出現 重複元素。
   4.2 使用大括號 { } 來創建集合；可以通過 set() 函數創建集合，或者將序列和字典 轉換成 集合。
   注意：創建一個 空集合 必須用 set() ，而不是 { }。因爲 { } 是用來創建一個 空字典 的。
   4.3 集合 增·刪·改·查 的操作以及Python語言自帶的內置方法 這個只能靠自己 多看、多寫、多體會 了。

 本章回顧暫時就到這了，如果還有點暈，那就去完成作業吧。拜拜~

  
    
  

作業

  1. 上文中講到的函數以及代碼再練習幾遍；
  2. 從 a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}}  找到  python1/python2/python3
  3. 有如下集合{11, 22, 33, 44, 55, 66, 77, 88, 99}，將所有 大於66的值 保存至字典的第一個key中，將所有 小於66的值 保存至字典的第二個key中；
  4. 將字符串中的空格替換成“%20”

  
  
  

參考答案

# 作業 2
a = {"name":"qwe","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}

# 提取 python1 , python2 , python3

# data ---> {"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}
# result ---> [{"src":"python1"},{"src":"python2"},{"src":"python3"}]

# 方法 1

b = a['data']
c = b['result']

for i in c:
    print(i['src'])
# python1
# python2
# python3

# 方法 2

b = a['data']['result']

for x in b:
    print(x['src'])
# python1
# python2
# python3

#-----------------------------------------------------------------------------------

# 作業 3			# 原理我懂，但最初我就是沒有有做出想要的結果。爲什麼呢。因爲我忘記了  append 和 update  這兩個內置函數。

i = {11, 22, 33, 44, 55, 66, 77, 88, 99}

dic = {}
m = []
n = []

for x in i:
    if x > 66:
        m.append(x)
    else:
        n.append(x)

dic.update(k1 = m, k2 = n)
print(dic)

#-----------------------------------------------------------------------------------

# 作業 4

# 將字符串中的空格替換成“%20”

# 方法一：
strs = 'hello my baby'

def rep(a):
    li = []
    for i in a:
        li.append(i)
    for i in range(len(li)):
        if li[i] == ' ':
            li[i] = '%20'
    return ''.join(li)

sa = rep(strs)
print(sa)


# 方法二：
def rep(a):
    li = []
    for i in a:
        li.append(i)
    for i in li:
        if i == ' ':
            li[li.index(i)] = '%20'
    return ''.join(li)
sb = rep(strs)
print(sb)