Python 元组、字典、集合

今日目录：

• 一、元组

• 二、字典

• 三、集合

• 四、后期添加内容

一、元组

1.定义

t1 = ()  # 参数为for可以循环的对象（可迭代对象）

思考：
	如何定义一个只有一个值的元组？
("lisi")
tuple(['lisi'])

2.常用操作

2.1 元组有序存储,索引取值

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

2.2 切片

print(id(t))
nt = t[:-1:]
print(nt, id(nt))

2.3 长度（item元素个数）

print(len(t))

2.4 元组内置方法

t.count(2)  # 该数据集合可以有效存放相同数据
t.index(2)
# .count(obj)  .index(obj,bindex,eindex)

案例一：

• 提前有一个老师列表，打算开出，如果是亲友团，免开

• 原始列表为list类型

• 手动输入是否是亲友团，决定是否能开除

teas = ['Bob','lisi']
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)

案例二

• 元组中的数据一定不能改变吗：一定不能改变，但元组中的数据（可变类型）的数据可以改变

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]))
# (1, 2, []) <class 'tuple'> 2654984899464 2654984915912
# (1, 2, [10, 20]) <class 'tuple'> 2654984899464 2654984915912

二、字典

特别了解：dict 是Python中仅存的mapping类型

1.声明

d1 = {'name': 'zhangsan', 'age': 18}
1.dict 的 key 可以为所有不可变类型 （一般用str）int，float,tuple,str,bool,None

注：key具有唯一性（重复会覆盖旧值）
    value可以重复
    
2.dict的value 可以为所有数据类型
d1 = {'name':'zhangsan','age' = 18}
d2 = dict({'name': 'lisi', 'age': 18})
d3 = dict(name='zhangsan', age=17)
# 字典无序存储数据，无索引与切片，用key来取值

2.增删改查

 增：
    d3['gender'] = 'female'
 改：
    d3['name'] = 'lisi'
 查：
    print(d2['name'])
 删：
    del d3['name']

3.内置方法

3.1 get 取值

dic = {'a': 10, 'b': 20}
# print(dic['c'])  # KeyError: 'c'
res = dic.get('c')  # 拥有默认值None,可以避免错误
print(res)  # None

res = dic.get("c", "key不存在")  # 可以自定义默认值
print(res)  # key不存在

3.2 增

dic = {'a': 10, 'b': 20}
dic.update({'f': 100, 'c': 300})

print(dic)  # {'a': 10, 'b': 20, 'c': 300, 'f': 100}

# 参数有就修改，没有就添加
# 参数字典 与 dic可以重复，就是更新值，新key就是新增
    

3.3 删

dic.pop('c')  # 根据key删除指定对象，并返回删除的对象的值
print(dic)  # {'a': 10, 'b': 20, 'f': 100}

3.4 复制

（浅拷贝   深拷贝）
# 浅拷贝 ：只做第一层copy ，内部的成员地址还是原来的地址

new_dic = dic.copy()
d1 = {'list': [1, 2]}
d2 = d1.copy()
print(id(d1), id(d1['list']))  # 1805017721608 1805018516424
print(id(d2), id(d2['list']))  # 1805018516744 1805018516424

d1['list'].append('abc')
print(d2)  # {'list': [1, 2, 'abc']}  d2 的‘list’ id与d1的'list' id 相同

浅拷贝：（宏观字典会拷贝，但内部数据依旧使用原来的）
dic = {'list':[10,20]}
d1 = dic.copy()

深拷贝：

from copy from deepcopy

d2 = deepcopy(dic)

3.5 popitem()

#无参数
#随机删除，但返回值是（key,value）
print(dic)
print(dic.popitem())  # ('f', 100)

3.6 如何定义一个空字典

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

# fromkeys(['a','b'],' ')  
#第1个参数：keys = list |tuple|str  第2个参数：统一的默认value

案例

# 添加老师
d11 = {'a': 10}

# 如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
if 'teas' not in d11:
    d11['teas'] = []
d11['teas'].append('zhangsan')
print(d11)

4.字典循环与案例

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

#直接for循环（遍历）字典得到的是key
for obj in dic:
    print(obj)  # print(obj,dic[k])

# 能不能只循环值
values = dic.values()

# 存放key的集合
keys = dic.keys()

# 存放key-value的键值对关系
k_vs = dic.items()

print(k_vs)  # dict_items([('a', 10), ('c', 30), ('b', 20)])
print(keys)  # dict_keys(['c', 'a', 'b'])
print(values)  # dict_values([10, 30, 20])
    
ps: dic.valuses、dic.keys()、dic.items()都不是原生list，不能直接索引取值，但可以for循环遍历

案例：不区分大写、计数每一个名字出现的次数，记录在字典中

ls = ['Owen','Owen',"Egon",'Liuxx','Liuxx','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']
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)

# 结果：{'egon': 2, 'owen': 2, 'liuxx': 2}

三、集合

1.定义与声明

1.1 什么是set？
   1.单列数据集合：str、list、tuple、set
   2.无序存储：无key，无index ,无法取值
   3.可变数据类型，内部可以存放任意类型数据，但数据具有唯一性

    # {}代表字典，用set()来创建空集合
    s1 = set()

2.内置方法与使用 ---集合间的运算

p_set = {'a','b','c','lisi'}
l_set = {'x','y','z','lisi'}

--- # 交集：& ---------------------------------------------------------
res = p_set & l_set
print(res)  #{'lisi'}
res = p_set.intersection(l_set)
print(res)  # {'lisi'}

--- # 并集 ： | --------------------------------------------------------
res = p_set | l_set
print(res)  # {'z', 'b', 'lisi', 'a', 'y', 'x', 'c'} 一个无序集合
res = p_set.union(l_set)
print(res)  # {'x', 'y', 'z', 'b', 'c', 'a', 'lisi'} 一个无序集合

--- # 差集 ： -  -------------------------------------------------------
res = p_set - l_set
print(res)  # {'b', 'a', 'c'}  去掉 egon ,剩下'a','b','c'
res = p_set.difference(l_set)
print(res)  # {'a', 'b', 'c'}

--- # 对称差集 ：^ -----------------------------------------------------
res = p_set ^ l_set
print(res)  # {'z', 'c', 'y', 'a', 'x', 'b'}
res = p_set.symmetric_difference(l_set)
print(res)  # {'x', 'c', 'y', 'z', 'a', 'b'}

3、案例与应用场景

选课：

# 需求：
# 1.多少人参加了选课: ['owen', 'egon', 'liuxx']
# 2.都选了哪些课程: ['python', 'linux', 'java']
# 利用逻辑代码去重

class_map = [
    ('owen', 'python'),
    ('egon', 'linux'),
    ('egon', 'python'),
    ('liuxx', 'python'),
    ('liuxx', 'java')
]

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

利用set去重

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

print(classes)  #['python', 'java', 'linux']

了解：

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)  # True

四、后期添加内容

菜鸟教程tuple：元组

菜鸟教程dict：字典

菜鸟教程set：集合