一. 元組（tuple）

      元組——只讀列表，資料能被查詢，不能修改。字串的切片操作同樣適用於元組。

1 s = ("ada", "jalksdj", "alkjsd")
2 
3 # 注意，元組內只有一個值時，必須加個英文符逗號，比如下面也會自動打印出來
4 print(s[-2:-1])    # ('jalksdj',)

二. 列表（list）

      列表中可以存放各種資料型別，比如：

      s = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

      列表的增刪改查操作：

 1 # 列表的增
 2 
 3 s = [1,'a','b',2,3,'a']
 4 
 5 
 6 # insert —— 按照索引增加
 7 s.insert(0, 55)
 8 print(s)     # [55, 1, 'a', 'b', 2, 3, 'a']
 9 
10 
11 # append —— 增加到最後
12 s.append("aaa")
13 print(s)     # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa']
14 
15 
16 # extend —— 迭代的增
 

17 s.extend(["q, a, w"])
18 print(s)     # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w']
19 # 注意這裡把列表的 5 個元素當作整體加進來了
20 # 與下面的對比
21 
22 s.extend('a,b,c')
23 print(s)     # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c']
24 # 這裡通過迭代把 "a,b,c" 裡的 5個元素(包括逗號) 都單獨加進去了
25 
26 s.extend(""
 
)    # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c']
27 s.extend("  ")  # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', 'q, a, w', 'a', ',', 'b', ',', 'c', "  "]
28 # 迭代一個空字串和一個只含空格的字串的區別

 1 # 列表的刪
 2 
 3 # pop() —— 預設刪除最後一個值
 4 # 括號裡要是新增索引位置數字，則刪除指定的元素，有返回值
 5 s = [1, 3, 4, "a", "abc", "12sda"]
 6 s1 = s.pop()
 7 s2 = s.pop(1)
 8 
 9 print(s1)    # 12sda
10 print(s2)    # 3
11 print(s)      # [1, 4, 'a', 'abc']
12 
13 
14 # del —— 按照指定位置刪除，也可以切片刪除，沒有返回值
15 s = [1, 3, 4, "a", "abc", "12sda"]
16 del s[1]    # [1, 4, 'a', 'abc', '12sda']
17 del s[:2]   # ['a', 'abc', '12sda']
18 
19 
20 # remove —— 按照指定元素刪除
21 s = [1, 3, 4, "a", "abc", "12sda"]
22 s.remove("a")
23 print(s)    # [1, 3, 4, 'abc', '12sda']
24 
25 
26 # clear() —— 直接清空整個列表
27 s = [1, 3, 4, "a", "abc", "12sda"]
28 s.clear()
29 print(s)    # []

1 # 列表的改
2 # 通過索引號更改對應的值即可，也可使用切片
3 
4 s = [1, "a", "b", 2, 3, "a"]
5 s[1] = "asd"
6 print(s)   # [1, 'asd', 'b', 2, 3, 'a']
7 s[1:3] = [123, "asdjlk"]
8 print(s)   # [1, 123, 'asdjlk', 2, 3, 'a']

     列表的其他操作

1 # count —— 統計某個元素在列表中出現的次數
2 
3 s = ["q","w","q","r","t","y"]
4 print(s.count("q"))    #     2

1 # index —— 從列表中找出某個值第一個匹配項的索引位置
2 
3 s = ["q","w","r","t","y"]
4 print(s.index("r"))    # 1

 1 # sort —— 在原位置對列表進行排序
 2 
 3 a = [2,1,3,4,5]
 4 a.sort()     # 他沒有返回值，所以只能列印a
 5 print(a)     # [1, 2, 3, 4, 5]
 6 
 7 
 8 # reverse —— 將列表中的元素反向存放
 9 
10 a = [2,1,3,4,5]
11 a.reverse()  # 他沒有返回值，所以只能列印a
12 print(a)       # [5, 4, 3, 1, 2]

三. 字典（dict）

      字典是Python中唯一的對映型別，採用鍵值對（key-value）的形式儲存資料。

      python對key進行雜湊函式運算，根據計算的結果決定value的儲存地址，所以字典是無序儲存的，且key必須是可雜湊的。

      可雜湊表示key必須是不可變型別，如：數字、字串、元組。

　  字典(dictionary)是除列表之外python之中最靈活的內建資料結構型別。

      列表是有序的物件結合，字典是無序的物件集合。

      兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

 1 # 字典的增
 2 
 3 dic = {'age': 18, 'name': 'jin', 'sex': 'male'}
 4 
 5 dic.setdefault('k','v')
 6 print(dic)     # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
 7 
 8 # setdefault —— 在字典中新增鍵值對，如果只有鍵那對應的值是none
 9 # 但是如果原字典中存在設定的鍵值對，則他不會更改或者覆蓋。
10 dic.setdefault('k','v1')  
11 print(dic)     # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}

 1 # 字典的刪
 2 
 3 # pop() —— 有返回值
 4 dic = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
 5 dic_pop = dic.pop("age")
 6 print(dic_pop)    # 18
 7 print(dic)           # {'name': 'jin', 'sex': 'male', 'k': 'v'}
 8 
 9 # pop根據key刪除鍵值對，並返回對應的值，如果沒有key則返回預設返回值
10 dic_pop2 = dic.pop("a")    # 報錯，顯示 "KeyError" : "a"
11 dic_pop2 = dic.pop("a", "無Key返回預設值")
12 print(dic_pop2)    # 無Key返回預設值
13 print(dic)            # {'name': 'jin', 'sex': 'male', 'k': 'v'}
14 
15 
16 # del —— 沒有返回值
17 del dic["name"]     
18 print(dic)             # {'sex': 'male', 'k': 'v'}
19 
20 
21 # popitem() —— 隨機刪除字典中的某個鍵值對，並將刪除的鍵值對以元組的形式返回
22 dic = {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}
23 dic_pop3 = dic.popitem()
24 print(dic_pop3)     # ('k', 'v')
25 print(dic)             # {'age': 18, 'name': 'jin', 'sex': 'male'}
26 
27 
28 # clear() —— 清空字典
29 dic_clear = dic.clear()
30 print(dic_clear)     # None
31 print(dic)             # {}

1 # 字典的改
2 
3 dic = {"name":"jin","age":18,"sex":"male"}
4 dic2 = {"name":"alex","weight":75}
5 
6 # 將dic所有的鍵值對覆蓋新增（相同的覆蓋，沒有的新增）到dic2中
7 dic2.update(dic)  
8 print(dic2)    # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

 1 # 字典的查
 2 
 3 dic = {"name":"jin","age":18,"sex":"male"}
 4 
 5 value1 = dic["name"]  # 沒有會報錯
 6 print(value1)    # jin
 7 
 8 value2 = dic.get("age")
 9 print(value2)    # 18
10 # 沒有對應的 Key 則返回設定的返回值
11 value3 = dic.get("djffdsafg","預設返回值")  
12 print(value3)    # 預設返回值

 1 # 字典的其他操作
 2 
 3 dic = {"name":"jin","age":18,"sex":"male"}
 4 item = dic.items()
 5 print(item,type(item))  
 6 # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)])   <class 'dict_items'>
 7 # 這個型別就是dict_items型別，可迭代的
 8 
 9 keys = dic.keys()
10 print(keys,type(keys))  
11 # dict_keys(['sex', 'age', 'name'])   <class 'dict_keys'>
12 
13 values = dic.values()
14 print(values,type(values))  
15 # dict_values(['male', 18, 'jin'])     <class 'dict_values'> 

 1 # 字典的迴圈
 2 
 3 dic = {"name":"jin","age":18,"sex":"male"}
 4 
 5 for key in dic:
 6     print(key)
 7 
 8 for item in dic.items():
 9     print(item)
10 
11 for key,value in dic.items():
12     print(key,value)　

四. 集合（set）  

      集合和字典一樣，是無序的。

      集合有一點就是它是不重複的資料集合，它裡面的元素是可雜湊的(不可變型別)

      但是集合本身是不可雜湊（所以集合做不了字典的鍵）的。

      以下是集合最重要的兩點：

　  去重，把一個列表變成集合，就自動去重了。

　  關係測試，測試兩組資料之前的交集、差集、並集等關係。

1 # 集合的建立
2 
3 set1 = set({1,2,'barry'})
4 set2 = {1,2,'barry'}
5 
6 print(set1,set2)    # {1, 2, 'barry'}     {1, 2, 'barry'}

 1 # 集合的增
 2 
 3 set1 = {'alex','wusir','ritian','egon','barry'}
 4 set1.add('景女神')
 5 print(set1)    # {'ritian', 'wusir', 'barry', '景女神', 'alex', 'egon'}
 6 
 7 
 8 #update：迭代著增加，注意看與前面的區別
 9 set1.update('A')
10 print(set1)    # {'ritian', 'wusir', 'barry', '景女神', 'A', 'alex', 'egon'}
11 
12 set1.update('老師')
13 print(set1)    # {'ritian', 'wusir', '師', 'barry', '景女神', 'A', 'alex', '老', 'egon'}
14 
15 set1.update([1,2,3])
16 print(set1)    
17 # {1, 2, 3, 'ritian', 'wusir', '師', 'barry', '景女神', 'A', 'alex', '老', 'egon'}
18 # 可以看出與列表的迭代的增類似

 1 #  集合的刪
 2 
 3 set1 = {'alex','wusir','ritian','egon','barry'}
 4 
 5 # 刪除一個元素
 6 set1.remove('alex')  
 7 print(set1)         # {'ritian', 'wusir', 'barry', 'egon'}
 8 
 9 # 隨機刪除一個元素
10 set_pop = set1.pop()
11 print(set_pop)    # ritian
12 print(set1)         # {'wusir', 'barry', 'egon'}
13 
14 # 清空集合
15 set1.clear()  
16 print(set1)         # set()
17 
18 # 刪除集合
19 del set1  
20 print(set1)         # 報錯

       集合的其他操作

 1 # 交集（&  或者 intersection）
 2 
 3 set1 = {1,2,3,4,5}
 4 set2 = {4,5,6,7,8}
 5 
 6 print(set1 & set2)                 # {4, 5}
 7 print(set1.intersection(set2))  # {4, 5}
 8 
 9 
10 # 反交集 （^ 或者 symmetric_difference）
11 
12 set1 = {1,2,3,4,5}
13 set2 = {4,5,6,7,8}
14 
15 print(set1 ^ set2)                                  # {1, 2, 3, 6, 7, 8}
16 print(set1.symmetric_difference(set2))       # {1, 2, 3, 6, 7, 8}

1 # 並集 （| 或者 union）
2 
3 set1 = {1,2,3,4,5}
4 set2 = {4,5,6,7,8}
5 
6 print(set1 | set2)         # {1, 2, 3, 4, 5, 6, 7,8}
7 print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

 1 # 差集 （- 或者 difference）
 2 
 3 set1 = {1,2,3,4,5}
 4 set2 = {4,5,6,7,8}
 5 
 6 print(set1 - set2)               # {1, 2, 3}
 7 print(set1.difference(set2))  # {1, 2, 3}
 8 
 9 print(set2 - set1)               # {8, 6, 7}
10 print(set2.difference(set1))  # {8, 6, 7}

 1 # 子集與超集
 2 
 3 set1 = {1,2,3}
 4 set2 = {1,2,3,4,5,6}
 5 
 6 # 這兩個相同，都是說明set1是set2子集。
 7 print(set1 < set2)               # True
 8 print(set1.issubset(set2))     # True 
 9 
10 
11 # 這兩個相同，都是說明set2是set1超集。
12 print(set2 > set1)                # True
13 print(set2.issuperset(set1))   # True

1 # frozenset —— 不可變集合，讓集合變成不可變型別
2 
3 s = frozenset('barry')
4 
5 print(s, type(s))
6 # frozenset({'b', 'y', 'a', 'r'})     <class 'frozenset'>

五. 基礎資料型別總結

   按儲存空間的佔用分（從低到高）

數字
字串
集合：無序，即無序存索引相關資訊
元組：有序，需要存索引相關資訊，不可變
列表：有序，需要存索引相關資訊，可變，需要處理資料的增刪改
字典：無序，需要存key與value對映的相關資訊，可變，需要處理資料的增刪改

    按存值個數區分

    按可變不可變區分

    按訪問順序區分

六. for -- enumerate -- range 的用法

 1 # for 迴圈 —— 按順序迴圈可迭代物件的內容
 2 
 3 msg = '老男孩python是全國範圍內最好的python培訓機構'
 4 for item in msg:
 5     print(item)
 6 
 7 
 8 li = ['alex','銀角','女神','egon','太白']
 9 for i in li:
10     print(i)
11 
12 
13 dic = {'name':'太白','age':18,'sex':'man'}
14 for k,v in dic.items():
15     print(k,v)

 1 # enumerate —— 列舉
 2 # 對於一個可迭代、可遍歷的物件，enumerate 將其組成一個索引序列
 3 # 利用它同時獲得索引和值
 4 
 5 li = ['alex','銀角','女神','egon','太白']
 6 
 7 for i in enumerate(li):
 8     print(i)
 9 # (0, 'alex')
10 # (1, '銀角')
11 # (2, '女神')
12 # (3, 'egon')
13 # (4, '太白')
14 
15 for index,name in enumerate(li,1):
16     print(index,name)
17 # 1 alex
18 # 2 銀角
19 # 3 女神
20 # 4 egon
21 # 5 太白
22 
23 # 起始位置預設是0，可更改
24 for index, name in enumerate(li, 100):  
25     print(index, name)
26 # 100 alex
27 # 101 銀角
28 # 102 女神
29 # 103 egon
30 # 104 太白　

 1 # range —— 指定範圍，生成指定數字
 2 
 3 for i in range(1,10):
 4     print(i)
 5 
 6 for i in range(1,10,2):  # 步長
 7     print(i)
 8 
 9 for i in range(10,1,-2): # 反向步長
10     print(i)