Python基礎筆記_Day05_列表、元組、字典、集合、生成器、迭代器
Day05_列表、元組、字典、集合、生成器、迭代器
05.01_Python語言基礎(列表List)(掌握)
05.02_Python語言基礎(建立列表)(掌握)
05.03_Python語言基礎(執行輸出列表)(掌握)
05.04_Python語言基礎(列表常用操作)(掌握)
05.05_Python語言基礎(元組概述)(熟練)
05.06_Python語言基礎(訪問元組)(熟練)
05.07_Python語言基礎(元組常用操作)(掌握)
05.08_Python語言基礎(字典概述)(掌握)
05.09_Python語言基礎(字典常用操作)(掌握)
05.10_Python語言基礎(字典常用函式)(掌握)
05.11_Python語言基礎(字典和列表優缺點比較)(掌握)
05.12_Python語言基礎(集合概述)(掌握)
05.13_Python語言基礎(集合的格式和建立)(掌握)
05.14_Python語言基礎(集合的常用操作)(掌握)
05.15_Python語言基礎(生成器)(熟練)
05.16_Python語言基礎(函式實現生成器)(熟悉)
05.17_Python語言基礎(生成器--yield)(熟悉)
05.18_Python語言基礎(迭代器概述)(掌握)
05.19_Python語言基礎(可迭代物件)(掌握)
05.20_Python語言基礎(迭代器)(掌握)
05.21_Python語言基礎(Iter()函式)(掌握)
05.22_Python語言基礎(迭代器總結)(掌握)
## 05.01_Python語言基礎(列表List)(掌握)
>想一想：
前面學習的字串可以用來儲存一串資訊，那麼想一想，怎樣儲存咱們班所有同學的名字呢？
定義100個變數，每個變數存放一個學生的姓名可行嗎？有更好的辦法嗎？
>答曰
列表
* 列表介紹
>
序列是Python中最基本的資料結構。
序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
列表是常用的Python資料型別，它可以作為一個方括號內的逗號分隔值出現。
列表可以進行的操作包括索引，切片，加，乘，檢查成員。
此外，Python已經內建確定列表的長度以及確定最大和最小的元素的方法。
列表的資料項不需要具有相同的型別
##05.02_Python語言基礎(建立列表)(掌握)
* 列表格式： 列表名 = [列表選項1,列表選項2,....,列表選項n]，示例如下：
#
# 建立列表
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c", "d"]
list3 = [True, False]
list4 = ["a", 1, True, None]
list5 = []
# 控制檯執行輸出列表
print(list1)
print(list2)
print(list3)
print(list4)
print(list5)
print(type(list4))
print(type(list5))
執行輸出結果：
#
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd']
[True, False]
['a', 1, True, None]
[]
<class 'list'>
<class 'list'>
想一想：list6 = [None]，print(list6)在控制檯執行輸出的是什麼結果
##05.03_Python語言基礎(執行輸出列表)(掌握)
* A: 可以呼叫print()函式直接列印
#
# 建立列表
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c", "d"]
# 執行輸出列表
print(list1)
print(list2)
執行輸出結果
#
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd']
* B: 使用下標執行輸出列表中的每一個元素
#
# 建立列表
list1 = ["a", "b", "c", "d"]
# 執行輸出列表
print(list1[0])
print(list1[1])
print(list1[2])
print(list1[3])
執行輸出結果：
#
a
b
c
d
* C: 使用for迴圈執行輸出列表的每個資料
#
#使用for迴圈
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
for name in namesList:
print(name)
執行輸出結果：
#
xiaoWang
xiaoZhang
xiaoHua
* D: 使用while迴圈執行輸出列表的每個資料
#
#使用while迴圈
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
length = len(namesList)
i = 0
while i < length:
print(namesList[i])
i += 1
執行輸出結果：
#
xiaoWang
xiaoZhang
xiaoHua
* E: 列表重複執行輸出
#
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
print(namesList * 2)
執行輸出結果：
#
['xiaoWang', 'xiaoZhang', 'xiaoHua', 'xiaoWang', 'xiaoZhang', 'xiaoHua']
##05.04_Python語言基礎(列表常用操作)(掌握)
### 我們對資料常用的操作一般可以總結為：增、刪、改、查，下面我們來學習關於列表的常用操作
* A: 訪問列表元素
#
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])
執行輸出結果：
#
xiaoHua
xiaoZhang
xiaoHua
想一想：print(namesList[3])在控制檯執行輸出的結果是什麼
* B: 更改列表元素
#
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
print("更改前的nameList：%s" % namesList)
namesList[0] = "小王"
print("更改後的nameList：%s" % namesList)
執行輸出結果：
#
更改前的nameList：['xiaoWang', 'xiaoZhang', 'xiaoHua']
更改後的nameList：['小王', 'xiaoZhang', 'xiaoHua']
* C: 增加列表元素--append(object)
* 通過append可以向列表中新增元素,新增的元素放在最後
#
# 列表增加元素
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
print("新增元素前的nameList：%s" % namesList)
namesList.append("xiaoMing")
print("新增元素後的nameList：%s" % namesList)
執行輸出結果：
#
新增元素前的nameList：['xiaoWang', 'xiaoZhang', 'xiaoHua']
新增元素後的nameList：['xiaoWang', 'xiaoZhang', 'xiaoHua', '小明']
* D: 增加列表元素--insert(index,object)
* 通過insert可以向列表指定位置新增元素
#
# 列表增加元素--insert(index, object)
namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
print("新增元素前的nameList：%s" % namesList)
namesList.insert(1, "小明")
print("新增元素後的nameList：%s" % namesList)
執行輸出結果：
#
新增元素前的nameList：['xiaoWang', 'xiaoZhang', 'xiaoHua']
新增元素後的nameList：['xiaoWang', '小明', 'xiaoZhang', 'xiaoHua']
* E: 增加列表元素--extend(index,object)
#
# 列表增加元素--extend(list)
namesList1 = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
namesList2 = ['小王', '小張', '小華']
print("新增元素後的nameList：%s" % namesList1)
namesList1.extend(namesList2)
print("新增元素後的nameList：%s" % namesList1)
執行輸出結果：
#
新增元素後的nameList：['xiaoWang', 'xiaoZhang', 'xiaoHua']
新增元素後的nameList：['xiaoWang', 'xiaoZhang', 'xiaoHua', '小王', '小張', '小華']
* F: 列表相加
#
# 列表相加
namesList1 = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
namesList2 = ['小王', '小張', '小華']
namesList3 = namesList1 + namesList2
print(namesList3)
執行輸出結果：
#
['xiaoWang', 'xiaoZhang', 'xiaoHua', '小王', '小張', '小華']
* G: 查詢元素（in, not in, index, count）
* in(存在):如果存在返回的結果為True,反之False
* not in(不存在):如果不存在結果為True,反之False
* index(str, start, end) 查詢元素第一次出現的下標
* count(str) 查詢元素個數目
#
# 查詢列表元素
namesList1 = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
# 獲取使用者要查詢的名字
findName = input("請輸入需要查詢的名字:")
# 查詢判斷,是否存在
if findName in namesList1:
print("找到有這個人...")
elif findName not in namesList1:
print("查無此人....")
執行輸出結果：
#
請輸入需要查詢的名字:aaa
查無此人....
請輸入需要查詢的名字:xiaoHua
找到有這個人...
index()案例:
#
# index /count
a = ["a", "b", "c", "b", "d", "a"]
print(a.index("b"))
print(a.index("b", 2, 5))
print(a.count("a"))
執行輸出結果：
#
1
3
2
想一想：print(a.index("e"))和print(a.count("e"))執行輸出什麼結果
* G: 刪除元素（del/pop/remove）
* del list[index] 刪除指定位置的元素
* pop(index) 刪除一個元素，把刪除的這個元素返回，index不寫時預設是最後一個
* remove(onject)
del案例：
#
# 刪除元素（del list[index]）
word = ["a", "b", "c", "b", "d", "a"]
print("刪除元素前的word：%s" % word)
del word[1]
print("刪除元素後的word：%s" % word)
執行輸出結果：
#
刪除元素前的word：['a', 'b', 'c', 'b', 'd', 'a']
刪除元素後的word：['a', 'c', 'b', 'd', 'a']
pop()案例：
#
# 刪除元素（pop(index)）
word = ["a", "b", "c", "b", "d", "e"]
print("刪除指定位置元素", word.pop(1))
print("刪除預設位置元素", word.pop())
執行輸出結果：
#
刪除指定位置元素 b
刪除預設位置元素 e
remove()案例：
#
# 刪除元素（remove(object)）
word = ["a", "b", "c", "b", "d", "e"]
print("刪除元素前的word：%s" % word)
word.remove("a")
print("刪除元素後的word：%s" % word)
word.remove("a")
* H：列表排序sort()
* sort將列表按照特定的順序重新的排列，預設由小到大
#
# 列表排序sort(reverse=False)
word = ["a", "b", "c", "b", "d", "e"]
print("排序前的word：%s" % word)
word.sort(reverse=False)
print("順序排序後的word：%s" % word)
word.sort(reverse=True)
print("逆序排序後的word：%s" % word)
執行輸出結果：
#
排序前的word：['a', 'b', 'c', 'b', 'd', 'e']
順序排序後的word：['a', 'b', 'b', 'c', 'd', 'e']
逆序排序後的word：['e', 'd', 'c', 'b', 'b', 'a']
* I：列表的巢狀
* 類似while、for迴圈的巢狀，列表也支援巢狀
* 一個列表中的列表作為一個元素
* 格式：列表名 = [ [ ], [ ], [ ] ]
* 例如：schoolNames = [["清華大學"，"北京大學"],["哈爾濱佛學院"],[]]
* 練習： 一個學校，有3個辦公室，現在有8個老師等待分配工位，請編寫程式，完成隨機分配
#
# 列表巢狀
namesList = [["趙毅", "錢爾", "孫三"], ["里斯", "周武"], ["吳柳", "鄭琦"]]
for cls in namesList:
for name in cls:
print(name, end=",")
print()
執行輸出結果：
#
趙毅,錢爾,孫三,
里斯,周武,
吳柳,鄭琦,
* J：獲取列表中的最大/最小值
* max(list)
* min(list)
#
# 獲取最大值
word = ["a", "b", "c", "b", "d", "e"]
print(max(word))
print(min(word))
執行輸出結果：
#
e
a
## 05.05_Python語言基礎(元組概述)(熟練)
* 元組概述
* python的元組和列表類似，不同之處在於元組的元素不能修改，
* 元組格式：
* 元組名 = (元組元素1，元組元素2.....元組元素n)
* 建立元組
#
tuple1 = ()
tuple2 = (1, 2, 3)
tuple3 = (1, 2, 3, "hello", True)
print(tuple1)
print(tuple2)
print(tuple3)
print(type(tuple1))
print(type(tuple2))
print(type(tuple3))
執行輸出結果：
#
(1, 2, 3)
(1, 2, 3, 'hello', True)
<class 'tuple'>
<class 'tuple'>
>做一做：tuple0 = (1)，print(type(tuple0))執行輸出結果是什麼
## 05.06_Python語言基礎(訪問元組)(熟練)
* 訪問元組內容
* 通過下標訪問,格式：元組名[下標],下標從0開始
#
# 訪問元組元素
tuple4 = (1, 2, 3, "hello", True)
print(tuple4[2])
print(tuple4[3])
執行輸出結果：
#
3
hello
>試一試：print(tuole4[-2])執行輸出結果是什麼
#### 遍歷元組
# 遍歷元組
tuple5 = (1, 2, 3, "hello", True)
for t in tuple5:
print(t)
執行輸出結果：
#
1
2
3
hello
True
>做一做：使用while迴圈遍歷元組
* 重複執行輸出元組
#
tuple1 = (1,2,3)
print(tuple1 * 3)
執行輸出結果：
#
(1, 2, 3, 1, 2, 3, 1, 2, 3)
## 05.07_Python語言基礎(元組常用操作)(掌握)
#
# 修改元組
tuple6 = (1, 2, 3, "hello", True)
tuple6[1] = 100
print(tuple6)
執行輸出結果：
#
Traceback (most recent call last):
File "Day06/Tuple_Demo01.py", line 26, in <module>
tuple6[1] = 100
TypeError: 'tuple' object does not support item assignment
>元組內一旦建立，不可更改
#
tuple5 = (1, 2, 3, 4, True, [5, 6, 7])
# tuple5[0] = 100 #報錯,元組不能修改
# tuple5[-1] = [7,8,9] #報錯,
tuple5[5][0] = 500
print(tuple5)
執行輸出結果
#
(1, 2, 3, 4, True, [500, 6, 7])
>元組被改變了,這個是什麼情況呢？
* 刪除元組
* del可以刪除元組，但是後果很嚴重。。。
#
tuple6 = (1, 2, 3)
del tuple6
print(tuple6)
執行輸出結果：
#
Traceback (most recent call last):
File "/Day06/Tuple_Demo01.py", line 61, in <module>
print(tuple6)
NameError: name 'tuple6' is not defined
>元組被刪除的很徹底,直接從記憶體中抹去了
* 試一試：del tuple6[1]執行輸出什麼結果
* 元組相加
#
# 元組相加
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
tuple3 = tuple1 + tuple2
print(tuple3)
print(type(tuple3))
print(tuple1)
print(tuple2)
執行輸出結果：
#
(1, 2, 3, 4, 5, 6)
<class 'tuple'>
(1, 2, 3)
(4, 5, 6)
* 判斷元組是否存在XX元素
* 使用in,not in可以判斷某個元素是否在目標元組
#
# in, not in
tuple4 = (1, 2, 3)
print(3 in tuple4)
print(3 not in tuple4)
print(tuple_demo009.index("c"))
print(tuple_demo009.count("c"))
執行輸出結果：
#
True
False
>對比一下列表的in,not in
* 擷取元組內容
* 格式: 元組名[開始 : 結束 ：步長]（含頭不含尾）
* 案例：
#
# 擷取元組內容
tuple6 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple6[:])
print(tuple6[3:7])
print(tuple6[3:])
print(tuple6[:7])
print(tuple6[:-1])
print(tuple6[-1::-1])
執行輸出結果：
#
(1, 2, 3, 4, 5, 6, 7, 8)
(4, 5, 6, 7)
(4, 5, 6, 7, 8)
(1, 2, 3, 4, 5, 6, 7)
(1, 2, 3, 4, 5, 6, 7)
(8, 7, 6, 5, 4, 3, 2, 1)
* 元組巢狀
* 元組的巢狀(二維元組),元素是一維元組
* 格式:元組名 = ((),(),().....)
* 案例：
#
# 元組巢狀
tuple7 = ((1, 2, 3), (4, 5, 6), (True, False))
print(tuple7[1][1])
for tuple0 in tuple7:
for num in tuple0:
print(num, end=",")
print()
執行輸出結果：
#
5
1,2,3,
4,5,6,
True,False,
## 05.08_Python語言基礎(字典概述)(掌握)
* 字典概述
#
想一想：
如果有列表如下：
nameList = ['xiaoZhang', 'xiaoWang', 'xiaoLi'];
需要對"xiaoWang"這個名字寫錯了，通過程式碼修改：
nameList[1] = 'xiaoxiaoWang'
如果列表的順序發生了變化，如下
nameList = ['xiaoWang', 'xiaoZhang', 'xiaoLi'];
此時就需要修改下標，才能完成名字的修改
nameList[0] = 'xiaoxiaoWang'
>**有沒有方法，既能儲存多個數據，還能在訪問元素的很方便就能夠定位到需要的那個元素呢？**
### 》》》字典能很好的解決這種問題，你印象中的字典是什麼樣的？
#
》》》另一個場景：
學生資訊列表，每個學生資訊包括學號、姓名、年齡等，如何從中找到某個學生的資訊？
>>> studens = [[1001, "王寶強", 24], [1002, "馬蓉", 23], [1005, "宋喆"，24], ...]
* 字典格式
* 格式：{key1 : value1, key2 : value2, key3 : value3, ....}
* 建立字典
* 定義一個變數info為字典型別
#
info = {"name" : "zhangsan", "id" : 1234, "address" : "北京"}
* 說明：
* 字典和列表相似，儲存多種資料
* 字典中找元素，根據名字（就是:前面的那個值--》key）
* 字典中的每一個元素分為兩個部分，鍵 值
* 例如：
name ---------> key
zhangsan -----> value
## 05.09_Python語言基礎(字典常用操作)(掌握)
* 新增字典內容
* 變數名["鍵"] = 資料時,如果該鍵在字典中不存在,會自動建立
#
# 字典新增元素
info = {"id": 100, "address": "北京", "name": "zhangsan"}
print("新增元素前的字典info:", info)
info["phoneNum"] = 10086
print("新增元素後的字典info:", info)
執行輸出結果：
#
新增元素前的字典info: {'id': 100, 'address': '北京', 'name': 'zhangsan'}
新增元素後的字典info: {'id': 100, 'address': '北京', 'name': 'zhangsan', 'phoneNum': 10086}
* 修改字典內容
* 變數名["鍵"] = 資料時,如果該鍵在字典中存在,會改變原值
* 變數名["鍵"] = 資料時,如果該鍵在字典中不存在,會自動建立
#
info = {"id": 100, "address": "北京", "name": "zhangsan"}
print("修改前的字典info:", info)
# 格式:
# 變數名["鍵"] = 資料時,如果該鍵在字典中存在,會改變原值
# 變數名["鍵"] = 資料時,如果該鍵在字典中不存在,會自動建立
newAddr = input("請輸入您所在的城市:")
info["address"] = newAddr
newAge = int(input("請輸入您的年齡:"))
info["age"] = newAge
print("修改後的字典info:", info)
執行輸出結果：
#
修改前的字典info: {'id': 100, 'address': '北京', 'name': 'zhangsan'}
請輸入您所在的城市:上海
請輸入您的年齡:18
修改後的字典info: {'id': 100, 'address': '上海', 'name': 'zhangsan', 'age': 18}
* 刪除字典元素
* del :刪除指定的元素
* clear()：清空字典
* 案例：
del案例
#
# 刪除字典元素
info = {"id": 100, "address": "北京", "name": "zhangsan"}
print("刪除元素前的字典info:", info)
del info["address"]
print("刪除元素後的字典info:", info)
執行輸出結果：
#
刪除元素前的字典info: {'id': 100, 'address': '北京', 'name': 'zhangsan'}
刪除元素後的字典info: {'id': 100, 'name': 'zhangsan'}
clear()案例
#
# clear()
print("clear()前的字典info:", info)
info.clear()
print("clear()後的字典info:", info)
執行輸出結果：
#
clear()前的字典info: {'id': 100, 'name': 'zhangsan'}
clear()後的字典info: {}
>使用clear()會把字典清空，不會把字典從記憶體中抹去
* 檢視字典元素
* get()函式：在我們不確定字典中是否存在某一個鍵而又想獲取它的值，可以使用get(),可以設定預設值
* 案例：
#
# get()函式
info = {"id": 100, "address": "北京", "name": "zhangsan"}
age = info.get("age") # age鍵不存在,所以age的值為None
print(age)
# 如果info中不存在age,設定預設值
age = info.get("age", 18)
print(age)
執行輸出結果：
#
None
18
## 05.10_Python語言基礎(字典常用函式)(掌握)
* 字典長度
* len(dict)
* 獲取所有的鍵key
* dict.keys()
* 獲取所有的值value
* dict.values()
* 獲取所有的鍵值對
* dict.items()
* 遍歷字典
* 使用for迴圈可以搞定
* 案例：
#
# 字典常用函式
info = {"id": 100, "address": "北京", "name": "zhangsan"}
# len()
len0 = len(info)
print("字典info的長度是：", len0)
# keys()
keys = info.keys()
print("字典info的鍵集合是：", keys)
# values()
values = info.values()
print("字典info的值集合是：", values)
# items()
items = info.items()
print("字典info的鍵值對集合是：", items)
執行輸出結果：
#
字典info的長度是： 3
字典info的鍵集合是： dict_keys(['id', 'address', 'name'])
字典info的值集合是： dict_values([100, '北京', 'zhangsan'])
字典info的鍵值對集合是： dict_items([('id', 100), ('address', '北京'), ('name', 'zhangsan')])
字典的遍歷：
#
# 字典的遍歷
# 遍歷字典中的key
info = {"id": "100", "address": "北京", "name": "zhangsan"}
print("--------遍歷字典中的key--------")
b = info.keys()
print(type(b))
for key in b:
print(key, end=",")
print("\n--------遍歷字典中的value--------")
# 遍歷字典獲取字典中所有的值
c = info.values()
for value in c:
print(value, end=",")
print("\n--------遍歷字典中的鍵值對--------")
# 獲取鍵值對
itmes = info.items()
for itme in itmes:
print(itme)
print("\n--------遍歷字典中的鍵值對改良版--------")
# 改進
for key, value in itmes:
print("key = %s,value = %s" % (key, value))
執行輸出結果：
#
--------字典的遍歷--------
--------遍歷字典中的key--------
<class 'dict_keys'>
id,address,name,
--------遍歷字典中的value--------
100,北京,zhangsan,
--------遍歷字典中的鍵值對--------
('id', '100')
('address', '北京')
('name', 'zhangsan')
key = id,value = 100
key = address,value = 北京
key = name,value = zhangsan
>想一想，如何實現帶下標索引的遍歷
第一種方式：輸出時直接加上
#
chars = ['a', 'b', 'c', 'd']
i = 0
for chr in chars:
print("%d %s"%(i, chr))
i += 1
執行輸出結果：
0 a
1 b
2 c
3 d
* 第二種方式：使用enumerate()解決
#
print("第二種方式：")
for i, c in enumerate(chars):
print(i, c)
執行輸出結果：
0 a
1 b
2 c
3 d
## 05.11_Python語言基礎(字典和列表優缺點比較)(掌握)
* 字典和列表比較：
* 優點
* 字典查詢和插入的速度較快，不會隨著key-value的增加而變慢
* 列表需要從頭遍歷，列表的順序變化後查詢引數也要改變
* 缺點
* 字典需要佔用較大的記憶體
* 列表結構比較簡單，佔用記憶體比較小
## 05.12_Python語言基礎(集合概述)(掌握)
* 集合與之前的列表和元組類似，可以儲存多個型別資料，這些資料不能重複
* 理解
* 相對於字典，是一組key,沒有value
* 本質：
* 無序，無重複元素元素的集合
* 集合的物件支援union(聯合)，intersection(交)，difference(差)，system-difference(系統差集)等運算
* 特點：
* 不能儲存重複元素
## 05.13_Python語言基礎(集合的格式和建立)(掌握)
* 建立集合：
* 集合的建立 ,需要列表、元組、字典等可迭代型別作為元素輸入集合
* 重複的元素在集合中會被自動過濾掉
* set = {}，print(type(set))執行得到的結果不是集合
* set = set()
建立集合案例：
#
set01 = set([1, 6, 9, 3, 6])
set02 = set({"id": "100", "address": "北京", "name": "zhangsan"})
set03 = {} # 建立的不是集合，是字典
set04 = set("abcde")
print(set01)
print(set02)
print(set03)
print(set04)
print(type(set03))
print(type(set04))
執行輸出結果：
#
{1, 3, 6, 9}
{'name', 'id', 'address'}
{}
{'e', 'a', 'c', 'd', 'b'}
<class 'dict'>
<class 'set'>
## 05.14_Python語言基礎(集合的常用操作)(掌握)
* 向集合新增元素
* 集合新增元素使用add()
* 格式：set.add(obj)
集合新增資料案例：
#
# 集合新增元素
print("---------add---------")
# 新增add
s1 = set([1, 2, 3, 4, 5])
s1.add(6)
print(s1)
s1.add(3) # 新增重複的元素,沒有效果
print(s1)
執行輸出結果：
#
---------add---------
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
>向集合內新增重複元素不報錯，也沒作用
讀一下程式碼，說出執行結果：
#
s1.add([7, 8, 9]) # set的元素不能是列表,列表是可變的
print(s1)
s1.add({1: "haha"}) # set的元素不能是字典,字典也是可變的
print(s1)
s1.add(7, 8, 9) # set的元素不能連續新增
print(s1)
s1.add((7, 8, 9)) # set的元素可以是字典,字典也是不可變的
print(s1)
* 集合更新update()
* 插入(更新)update()
* 可以插入list/tuple/String打碎插入(無序,去重)
update()案例：
#
# 插入(更新)update()
# 可以插入list/tuple/String打碎插入(無序,去重)
print("----------Update()----------")
s2 = set([1, 2, 3])
s2.update([4, 5, 6])
print(s2)
s2.update((9, 10))
print(s2)
s2.update("haha")
print(s2)
s2.update("哈哈")
print(s2)
執行輸出結果：
#
----------Update()----------
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6, 9, 10}
{'h', 1, 2, 3, 4, 5, 6, 9, 10, 'a'}
{'h', 1, 2, 3, 4, 5, 6, 9, 10, '哈', 'a'}
>可迭代元素被打碎放入集合，
>重複元素會被消除，
>更新後的集合無序
* 刪除集合元素
* 刪除集合元素使用remove(object)
刪除元素案例：
#
# 刪除集合元素
print("------remove------")
# 刪除remove()
s3 = set([1, 2, 3, 4, 5])
s3.remove(4) # 刪除是具體的元素
print(s3)
s3.remove(9) # 這個元素是不存在的
print(s3)
執行輸出結果：
#
------remove------
{1, 2, 3, 4, 5}
{1, 2, 3, 5}
刪除不存在元素：
#
# 刪除集合元素
print("------remove------")
# 刪除remove()
s3 = set([1, 2, 3, 4, 5])
s3.remove(9) # 這個元素是不存在的
print(s3)
執行輸出結果：
#
Traceback (most recent call last):
File "/Day06/Set_Demo01.py", line 58, in <module>
s3.remove(9) # 這個元素是不存在的
KeyError: 9
* 遍歷集合
* 集合是可迭代型別資料
* 使用for迴圈可以遍歷集合
* set集合沒有索引，無法使用while進行遍歷
* 如果想要得到索引和對應的值,使用enumerate
遍歷集合案例：
#
# 遍歷集合
print("---------for迴圈遍歷集合——----")
s4 = set([1, 2, 3, 4, 5])
for i in s4:
print(i, end=",")
print("-------帶索引的遍歷方式-------")
s5 = set("床前明月光")
for index, i in enumerate(s5):
print(index, i)
執行輸出結果：
#
1,2,3,4,5,
-------帶索引的遍歷方式-------
0 前
1 床
2 月
3 光
4 明
* 集合的交集和並集
* 交集：返回兩個集合相同的元素，返回資料型別是集合
* 並集：返回兩個集合內多有的元素並去除重複，返回資料型別是集合
交集和並集案例：
#
print("--------交集-------")
# 交集，使用運算子 "&"
s5 = set([1, 2, 3])
s6 = set([4, 5, 6, 2, 3])
# 交集 &
s7 = s5 & s6
print(s7)
print("--------並集-------")
# 並集，使用運算子 "|"
s8 = s5 | s6
print(s8)
print(type(s8))
執行輸出結果：
#
--------交集-------
{2, 3}
--------並集-------
{1, 2, 3, 4, 5, 6}
<class 'set'>
## 05.15_Python語言基礎(生成器)(熟練)
* Python的生成器是一個返回可以迭代物件的函式。
* 先看案例：
建立一個列表，元素為0--20以內的偶數
#
list01 = [2, 4, 6, 8, 10, 12, 14, 16, 18]
list02 = [x * 2 for x in range(1, 10)]
Generator01 = (x * 2 for x in range(1, 10))
print(list01)
print(list02)
print(Generator01)
for i in Generator01:
print(i, end=",")
執行輸出結果：
#
[2, 4, 6, 8, 10, 12, 14, 16, 18]
[2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x0000014043D37200>
2,4,6,8,10,12,14,16,18,
* 建立生成器的方式有多種，只要把一個列表生成式的[]改成()
* 建立list和Generator區別在於外層[],(),list表示一個列表，Generator表示生成器
* 遍歷生成器內容：
* next()
* for迴圈
next()讀取生成器內容
#
# next
# 定義一個生成器
Generator = (x * 2 for x in range(5))
temp = next(Generator)
print(temp)
temp = next(Generator)
print(temp)
temp = next(Generator)
print(temp)
temp = next(Generator)
print(temp)
temp = next(Generator)
print(temp)
temp = next(Generator)# 注意:如果一直寫next()函式,當超出了元素的個數範圍的時候會直接報錯
print(temp)
執行輸出結果：
#
0
2
4
6
8
Traceback (most recent call last):
File "/Day06/Generator_Demo01.py", line 24, in <module>
temp = next(Generator)
StopIteration
for迴圈遍歷生成器內容：
#
# 迴圈遍歷
Generator = (x*2 for x in range(5))
for temp in Generator:
print(temp)
執行輸出結果：
#
0
2
4
6
8
>讀取到最後一個元素自動結束，不會報錯
#
總結:
生成器儲存的是一個演算法,每次呼叫next()函式,就能計算出生成器下一個元素的值,直到最後一個元素，
如果超出了元素的最大長度範圍,報錯,
通過for迴圈來迭代他,並且不用關心超出界限的問題
## 05.16_Python語言基礎(函式實現生成器)(熟悉)
* 函式來實現生成器(函式後面學習)
#
函式的定義:
格式: def 函式名():
方法體語句
函式的呼叫:函式名()
* 練習:菲波拉鍥數列
#
1 1 2 3 5 8 13 除第一個和第二個外,任意的數都是由前兩個數相加得到
a = 0
b = 0
c = 1
while a < 5:
temp = c
c = b + c
b = temp
a += 1
print(b)
* 函式（方式一）
#
def fib1():
a = 0
b = 0
c = 1
while a < 5:
temp = c
c = b + c
b = temp
a += 1
print(b)
fib1()
* 函式（方式二）
#
def fib2():
a = 0
b,c = 0,1
while a < 5:
print(c)
b, c = c , b + c
# b = c
# c = b + c
a += 1
fib2()
解釋一下程式碼：
#
a = 0
b = 1
a,b = b, a + b
相當於
temp = b
b = a + b
a = temp
或者:
a, b = b , a + b
## 05.17_Python語言基礎(生成器--yield)(熟悉)
* 先看程式碼：
#
print("-----fib3()---------")
def fib3():
a = 0
b, c = 0, 1
while a < 5:
# print(c)
yield c
b, c = c, b + c
a += 1
f = fib3()#生成器
print(f)
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
執行輸出結果：
#
-----fib3()---------
<generator object fib3 at 0x000002352A007360>
1
1
2
3
5
* yield是一個類似return的關鍵字,迭代一次遇到yield的時候返回(右側,後面的值)
* 重點:
* 下一次迭代時,從上一次迭代遇到yield後面的程式碼(下一行)開始執行
* return返回一個值,並且記住返回值的位置,
* 下次迭代的時候就從這個記錄的位置開始
* 輸出時注意呼叫next()的次數，超出內容會報錯
## 05.18_Python語言基礎(迭代器概述)(掌握)
* 迭代：
* 迭代是重複反饋過程的活動，其目的通常是為了逼近所需目標或結果。
* 每一次對過程的重複稱為一次“迭代”，而每一次迭代得到的結果會作為下一次迭代的初始值。
* 計算機中的迭代：對計算機特定程式中需要反覆執行的子程式*(一組指令)，進行一次重複，即重複執行程式中的迴圈，直到滿足某條件為止，亦稱為迭代
* Python中的迭代是訪問集合元素的一種方式
* 迭代器：
* 可以被next()函式呼叫並且不斷的返回下一個值的物件(迭代器 Iterator)
* 迭代物件：
* 是一個可以記住遍歷位置的物件
* 迭代器物件從集合的第一個元素開始訪問，直到所有的元素訪問完畢為止
* 迭代器的特點：
* 只能往前，不會後退
## 05.19_Python語言基礎(可迭代物件)(掌握)
* 直接可用for迴圈遍歷的資料型別有哪些？
* 一類：list tuple dict set str
* 一類：生成器
* 這些可以直接作用與for迴圈的物件的統稱----》可迭代物件（Iterable）
* **怎麼判斷是否可以迭代？**
* 可以使用isinstance()來判斷一個物件是否是Iterable，返回值是True或者False
* 需要使用一個模組collections
#
from collections import Iterable
a = isinstance([],Iterable)
b = isinstance((),Iterable)
c = isinstance({},Iterable)
d = isinstance("aaaa",Iterable)
e = isinstance(1000,Iterable)#false
f = isinstance((x for x in range(5)),Iterable)
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
執行輸出結果：
#
True
True
True
True
False
True
## 05.20_Python語言基礎(迭代器)(掌握)
* 迭代器：
* 可以被next()函式呼叫並且不斷的返回下一個值的物件(迭代器 Iterator)
* 判斷一個元素是不是迭代器：isinstance（ocject, Iterator）
#
print("--------Iterator---------")
from collections import Iterator
a = isinstance([], Iterator)
b = isinstance((), Iterator)
c = isinstance({}, Iterator)
d = isinstance("aaaa", Iterator)
e = isinstance(1000, Iterator)
f = isinstance((x for x in range(5)), Iterator)
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
執行輸出結果：
--------Iterator---------
False
False
False
False
False
True
#
Python中 list、truple、str、dict這些都可以被迭代，但他們並不是迭代器。為什麼？
因為和迭代器相比有一個很大的不同，list、truple、map、dict這些資料的大小是確定的，
也就是說有多少事可知的。
但迭代器不是，迭代器不知道要執行多少次，所以可以理解為不知道有多少個元素，
每呼叫一次next()，就會往下走一步，是惰性的。
判斷是不是可以迭代，用Iterable
判斷是不是迭代器，用Iterator
所以，
凡是可以for迴圈的，都是Iterable
凡是可以next()的，都是Iterator
集合資料型別如list、truple、dict、str都是Itrable不是Iterator，
但可以通過iter()函式獲得一個Iterator物件
Python中的for迴圈就是通過next實現的
## 05.21_Python語言基礎(Iter()函式)(掌握)
* 生成器都是Iterator物件，但是list、dict、str都是迭代物件但是不是迭代器
* 使用iter()函式可以把這些可迭代物件轉換為迭代器
案例程式碼：
#
print("-----------Iter()-------------")
from collections import Iterator
words = [1, 5, 8, 3, 5]
a = isinstance(iter(words), Iterator)
b = isinstance(iter(()), Iterator)
c = isinstance(iter({}), Iterator)
d = isinstance(iter("hhaha"), Iterator)
f = isinstance((x for x in range(5)), Iterator)
print(a)
print(b)
print(c)
print(d)
print(f)
words = iter(words)
print(next(iter(words)))
print(next(iter(words)))
print(next(iter(words)))
執行輸出結果：
#
-----------Iter()-------------
True
True
True
True
True
1
5
8
## 05.22_Python語言基礎(迭代器總結)(掌握)
#
1.凡是可以作用與for迴圈物件都是Iterable型別
2.可以作用與next()函式的物件都是Iterator型別
3.集合資料型別list、tuple、dict、str等是Iterable但不是Iterator
4.集合資料型別list、tuple、dict、str等通過iter()可以將其轉換為Iterator