基石为勤能补拙的迷宫之旅——第六天（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)