元组、字典、集合

一、元组tuple

1、作用

存多个值，对比列表来说，元组不可变，主要是用来读。

2、定义

与列表类型比，只不过[ ]换成（）

t = ()  #本质：t = tuple(())
print(t,type(t))  #() <class 'tuple>
​
#强制类型转换中，参数为for可以循环的对象（可迭代对象）
t1 = tuple("123")
print(t1,type(t1)) #('1','2','3')
t2 = tuple([1,2,3]) #(1,2,3)
print(t2,type(t2)) #(1,2,3)
t3 = tuple((7,8,9))
print(t3,type(t3)) #(7,8,9)
​
#思考：如何定义一个只有一个值的元组
print(("owen",))  #注意要加逗号
print(tuple(['owen']))

3、常用操作

1、索引取值（元组有序存储）
t = (1,2,3,4,3)
print(t[1])  #2
print(t[-2])  #4
​
2、切片（顾头不顾尾，步长）
print(id(t))  #54657678
n = t[:-1:]
print(n,id(n))  #(1,2,3,4,3) 23434454
n = t[:-1:2]
print(n) #(1,3)
​
3、长度len
print(len(t))  #5
​
4、成员运算 in 和 not in
print(2 in t)  #true
​
5、元组内置方法
#求元组内某个元素的个数
print(t.count(3))  #2
#求元组指定区间内某个元素在总体内的位置
#index(要求的元素，起始位置，结束位置)
print(t.index(3,1,5))  #2
​
6、循环
for i in t:
    print(t)  #1 2 3 4 3

4、元组案列

案例一
'''
提前拥有一个老师列表，打算开除，如果是校长亲友团，免开
原始列表为list类型
手动输入是否是亲友团，决定是否能开除
'''
teachers = ['egon','owen']  #老师列表
friends = input('如果是亲友团输入1，否则输入0：')
if friends == '1':
    teachers = tuple(teachers)
#判断teachers对象是否是tuple类型
#isinstance用来判断对象是否属于某个类型，isinstance（对象，类型）
if not isinstance(teachers,tuple): #判断teachers是否是元组类型
    teachers.clear()
for t in teachers:
    print("在职老师：%s"%t)
    
案列二：
'''
元组中的数据一定不能改变，但是元组中的数据（可变类型）的数据可以改变
'''
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)) #注意extend()内只能跟一个变量，如元组，列表等，不能跟多个离散的值
print(t2.type(t2),id(t2),id(t2[2]))
​

二、字典dict

特别了解：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)  #key值none会被后一个none：12345覆盖
​
#几种定义方式
#1
d1 = {'name':'owen','age':18}
print(d1)  #{'name': 'owen', 'age': 18}
#2
d2 = dict({'name':'owen','age':18})
print(d2)  #{'name': 'owen', 'age': 18}
#3
d3 = dict(name = 'egon',age = 58)
print(d3)  #{'name': 'egon', 'age': 58}

3、常用操作

#字典无序存储数据，无索引与切片，用key来取值
#增删改查
 dic = {}
# 增：key不存在
dic['name'] = 'mac'
print(dic)
# 改：key已存在
dic['name'] = 'big mac'
print(dic)
# 查：
print(dic['name'])
# 删：
del dic['name']
print(dic)
​
# get取值 *****
dic = {'a': 10, 'b': 20}
print(dic['c'])  # keyerror
res = dic.get('c')
print(res) # 拥有默认值，none，可以避免错误
res = dic.get('d', 'key不存在')  # 可以自定义默认值
print(res) #key不存在
​
# 增
添加的参数字典，与dic可以重复，就是更新值，新key就是新增
dic.update({'a': 100, 'c': 300})
print(dic) #{'a':100,'b':20,'c':300}
​
# 删 **
res = dic.pop('c')  # 根据key删除指定对象，并返回删除的对象的value
print(res)
​
# 复制：(浅拷贝|深拷贝)
# 浅copy：只做第一层copy，内部的成员地址还是原来的地址
newdic = dic.copy()
print(newdic)
d1 = {'list': [1, 2]}
d2 = d1.copy()
print(id(d1), id(d1['list']))
print(id(d2), id(d2['list']))
d1['list'].append('abc')
print(d2)
​
# 随机删除，返回值是(key, value)
print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)
​
# 如何定义一个空字典
# 第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10)  # {'a': '', 'b': '', 'c': ''}
​
# 独自设置默认值
d11 = {'a': 10, 'teas': ['owen']}
# d11 = {'a': 10}
​
# 添加老师
如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
if 'teas' not in d11:  # 成员运算
    d11['teas'] = []
d11['teas'].append('egon')
d11['teas'].append('liuxx')
print(d11)
​
# 原d11中，如果有teas这个key，setdefault相当于什么都没干
# 如果没有，就将第二个参数(默认值)传给teas存放到d11中
d11.setdefault('teas', []) 
d11['teas'].append('egon')
d11['teas'].append('liuxx')
print(d11)
​
#循环
dic = {'a': 10, 'b': 20, 'c': 30}
# 直接for循环(遍历)字典得到的是key
for k in dic:
    print(k, dic[k])
​
# 能不能只循环值
values = dic.values()
print(values, type(values))
# 存放key的集合
keys = dic.keys()
print(keys, type(keys))
# 存放key-value的键值对关系
k_vs = dic.items()
print(k_vs, type(k_vs))
​
# dic.values() | dic.keys() | dic.items() 不是原生list，不能直接索引取值，但可以for循环取值
# vs = list(values)
# print(vs[1])
# for v in vs:
#     print(v)
​
for v in values:
    print(v)
print()
for k in keys:  # 跟直接遍历字典是一样的
    print(k)
​
print()
# ***** 同时遍历k-v
for k, v in dic.items():
    print(k, v)
'''

4、案列

# 案例: 不区分大小写，计算每一个名字出现的次数，记录在字典中
ls = ['owen', 'owen', 'egon', 'liuxx', 'liuxx', 'egon', 'egon']
# {'owen': 2, 'egon': 3 ...}
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)

三、集合set

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)) #{'c','b','a'} 无序
s3 = set('abc123')
print(s3, type(s2)) #{'b','a','1','3','2','c'} 无序

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)  #{'z', 'x', 'y', 'b', 'a', 'c'}
res = p_set.symmetric_difference(l_set)
print(res)  #{'z', 'x', 'y', 'b', 'a', 'c'}
​
print(p_set) #{'b', 'a', 'egon', 'c'}
print(l_set) #{'z', 'x', 'egon', 'y'}
# 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 = [
    ('owen', 'python'),
    ('egon', 'linux'),
    ('egon', 'python'),
    ('liuxx', 'python'),
    ('liuxx', 'java')
]
需求：
1.多少人参加了选课: ['owen', 'egon', 'liuxx']
2.都选了哪些课程: ['python', 'linux', '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)
print(sup_set < sub_set)
print(temp_set == sub_set)
​
# 两个set是否没有交集
res = flag_set.isdisjoint(temp_set)
print(res)
res = temp_set.isdisjoint(sup_set)
print(res)