基石爲勤能補拙的迷宮之旅——第六天（Python元祖，字典，集合）

一、元祖

1.作用

    存多個值，對比列表來說，元組不可變（是可以當做字典的key的），主要是用來讀

2.定義

tuple_example（）
print(tuple_example, type(tuple_example))

    定義只有一個值的元祖，值爲moon

print(("moon", ))
print(tuple(['moon']))

3.強制轉換爲元祖類型,參數爲for可以循環的對象(可迭代對象)

t1 =  tuple('123')
print(t1, type(t1))

4.常用操作

(1).索引取值

t = (1, 2, 3, 2, 3, 2)
print(t[1])  # 2
print(t[-2])  # 3

(2).切片

t = (1, 2, 3, 2, 3, 2)
nt = t[:-1:]  # (1, 2, 3, 2, 3）

切片不改變原值，複製出一個片段
(3).長度len（item元素個數）

t = (1, 2, 3, 2, 3, 2)
print(len(t))  # 6

5.內置方法

(1).count

t = (1, 2, 3, 2, 3, 2)
print(t.count(2))  # 3 	該數據集合可以存放相同數據

(2).index

print(t.index(2, 3))

6.案例
1.

• 提前擁有一個老師列表，打算開除，如果是校長親友團，免開
• 原始列表爲list類型
• 手動輸入是否是親友團，決定是否能開除

teas = ['Bob', 'Alex']
friends = input("親友團[0, 1]：")
if friends == '1':
    teas = tuple(teas)

# => 異常處理
# 判斷teas對象是否是tuple類型
if not isinstance(teas, tuple):  # 老師是否是親友團，不是就開除
    teas.clear()

for t in teas:
    print("在職老師：%s" % t)

2.元組中的數據一定不能改變，但是元組中的數據(可變類型)的數據可以改變

t1 = (1, 2, "abc", True, (1, 2))  # t1永遠無法改變
t2 = (1, 2, [])
print(t2, type(t2), id(t2), id(t2[2]))
t2[2].extend((10, 20))
print(t2, type(t2), id(t2), id(t2[2]))

二、字典

特別瞭解：dict是python中僅存的mapping類型

1、作用：

存多個值,key-value存取，取值速度快

2、聲明

• dict的key：可以爲所有不可變類型：int float tuple str bool None， 一般就採用字符串
• dict的value：可以爲所有數據類型
• 注：key具有唯一性（重複會覆蓋舊值），value可以重複

dic = {1: None, None: None, 3.14: None,
       True: None, 'abc': None, (1,): None,
       None: 12345
       }
print(dic)

#1
d1 = {'name': 'Owen', 'age': 18}
print(d1)
#2
d2 = dict({'name': 'Owen', 'age': 18})
print(d2)
#3
d3 = dict(name='Egon', age=58)
print(d3)

字典無序存儲數據，無索引與切片，用key來取值

3、常用操作——增刪改查

dic = {}
# 增：key不存在
dic['name'] = 'Mac'
print(dic)
# 改：key已存在
dic['name'] = 'Big Mac'
print(dic)
# 查：
print(dic['name'])
# 刪：
del dic['name']
print(dic)

4、內置方法

（1）get取值

普通取值，如果沒有key，會報錯

dic = {'a': 10, 'b': 20}
print(dic['c'])  # KeyError

res = dic.get('c') #擁有默認值None，可以避免錯誤
print(res) #  None

res = dic.get('d', 'key不存在')  # 可以自定義默認值
print(res) #  key不存在

（2）update

    添加的參數字典，與dic可以重複，就是更新值，新key就是新增

  dic = {} 
  dic.update({'a': 100, 'c': 300})
  print(dic) #  {'a': 100, 'c': 300}

（3）pop

dic = {'a': 100, 'c': 300} 
res = dic.pop('c')  # 根據key刪除指定對象，並返回刪除的對象的value
print(res) #  300

（4）copy：(淺拷貝|深拷貝)

dic = {'a': 100, 'c': 300} 
newDic = dic.copy()
print(newDic) #  {'a': 100, 'c': 300}

    淺copy：只做第一層copy，內部的成員地址還是原來的地址

（5）popitem

    隨機刪除，返回值是(key, value)
print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)

（6）fromkeys

    定義一個空字典

• 第一個參數：keys：list|tuple|str
• 第二個參數：統一的默認value

d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10)  # {'a': '', 'b': '', 'c': ''}

（7）setdefault

#添加老師
如果有teas，在原teas基礎上添加老師，如果沒有，新建一個空teas
d11 = {'a': 10}
if 'teas' not in d11:  # 成員運算
	d11['teas'] = []
d11['teas'].append('Egon')
d11['teas'].append('LiuXX')
print(d11)

#  原d11中，如果有teas這個key，setdefault相當於什麼都沒幹
d11 = {'a': 10, 'teas': ['Owen']}
#  如果沒有，就將第二個參數(默認值)傳給teas存放到d11中
d11 = {'a': 10}
d11.setdefault('teas', [])
d11['teas'].append('Egon')
d11['teas'].append('LiuXX')
print(d11)

5、字典的循環(迭代)

dic = {'a': 10, 'b': 20, 'c': 30}

1).直接for循環(遍歷)字典得到的是key

for k in dic:
	print(k) #   a
			 	 b
			 	 c

2).只循環值

values = dic.values()
print(values, type(values)) #  dict_values([10, 20, 30]) <class 'dict_values'>

3).存放key的集合

keys = dic.keys()
print(keys, type(keys)) #  dict_keys(['a', 'b', 'c']) <class 'dict_keys'>

4).存放key-value的鍵值對關係

k_vs = dic.items()
print(k_vs, type(k_vs)) #  dict_items([('a', 10), ('b', 20), ('c', 30)]) <class 'dict_items'>

    dic.values() | dic.keys() | dic.items() 不是原生list，不能直接索引取值，但可以for循環取值

dic = {'a': 10, 'b': 20, 'c': 30}
values = dic.values()

vs = list(values)
print(vs[1]) #  轉換爲list才能索引取值

for v in values:
    print(v) #  可以for循環取值

keys = dic.keys()
for k in keys:
    print(k)   # 跟直接遍歷字典是一樣的

for k, v in dic.items():
    print(k, v) #  同時遍歷key-value

    案例: 不區分大小寫，計算每一個名字出現的次數，記錄在字典中，ls = [‘Owen’, ‘owen’, ‘Egon’, ‘LiuXX’, ‘Liuxx’, ‘egon’, ‘egon’]
方法一：

ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
name_dic = {}
    for name in ls:
        # 名字全小寫，不用區分大小寫
        name = name.lower()
        # 名字是否在字典中存在：存在 - 次數+1 | 不存在 - 添加並設置初值1
        if name not in name_dic:
            # 不存在
            name_dic[name] = 1
        else:
            # 存在
            name_dic[name] += 1
    print(name_dic)

方法二

ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
name_dic = {}
for name in ls:
    name = name.lower()
    # name已存在，不管，不存在，初始化指定key：name值爲1
    name_dic.setdefault(name, 0)
    name_dic[name] += 1
print(name_dic)

三、集合

1、定義與聲明

什麼是set：
i) 單列數據集合：str，list，tuple，set 雙列：dict
ii) 無序存儲：無key無index，無法取值
iii) 可變數據類型，內部可以存放任意類型數據，但數據具有唯一性

{}代表空字典，用set()來創建空集合

s1 = set()
print(s1, type(s1))
s2 = set('abc')
print(s2, type(s2))

2、內置方法與使用 - 集合間的運算 （& | ^ - > < ==）

p_set = {'a', 'b', 'c', 'egon'}
l_set = {'x', 'y', 'z', 'egon'}
print(p_set)
print(l_set)

交集 &

res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res)  # {'egon'}

並集 |

res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res)  # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}

差集 -

res = p_set - l_set
print(res)  # {'a', 'b', 'c'}
res = l_set.difference(p_set)
print(res)  # {'x', 'z', 'y'}

對稱差集 ^

res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res)  # {'y', 'a', 'b', 'x', 'z', 'c'}

print(p_set)
print(l_set)
p_set.difference_update(l_set)  # 將運算結果賦值給調用者
p_set = p_set - l_set
print(p_set)  # {'c', 'a', 'b'}
print(l_set)  # {'egon', 'z', 'y', 'x'}

添加刪除操作

s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop()  # 隨機刪除一個ele元素
print(res)
if 'xyz' in s:
    s.remove('xyz')  # 有ele刪除，無ele拋異常

3、應用場景

class_map = [
    ('moon', 'python'),
    ('hysen', 'linux'),
    ('hysen ', 'python'),
    ('pinking', 'python'),
    ('pinking', 'java')
]

利用邏輯代碼去重

names = []
for name, _ in class_map:
    # 判斷列表中是否已存在，不存在才添加
    if name not in names:
        names.append(name)
print(names)

利用set去重

classes = set()
for _, cless in class_map:
    classes.add(cless)
classes = list(classes)
print(classes)

父子set

sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}

print(sup_set > sub_set) #  True
print(sup_set < sub_set) #  False
print(temp_set == sub_set) #  True

兩個set是否沒有交集

res = flag_set.isdisjoint(temp_set)
print(res)
res = temp_set.isdisjoint(sup_set)
print(res)