元组、字典、集合的基本操作

一、元组

1、定义

①记录多个值，当值没有改的需求是，建议用元组更好
定义：在（）内用逗号分开任意类型的值
name = ('jerry', 120, 175.5, [120, 300.5])
print(name, type(name))    # 结果为 ('jerry', 120, 175.5, [120, 300.5]) <class 'tuple'>
print(tuple(name))         # 结果为 ('jerry', 120, 175.5, [120, 300.5])


t4 = tuple((7, 8, 9))
print(t4, type(t4))        # 结果为 (7, 8, 9) <class 'tuple'>

②思考:如何定义一个只有一个值的元组
"Owen"
print(("Owen", ))
print(tuple(['Owen']))

x = ('jerry',)
print(x)                   # 结果为 ('jerry',)
print(tuple(x))            # 结果为 ('jerry',)
print(type(x))             # 结果为 <class 'tuple'>

t2 = ('123',)
print(t2, type(t2))        # 结果为 ('123',) <class 'tuple'>

t3 = ([1, 2, 3],)
print(t3, type(t3))        # 结果为 ([1, 2, 3],) <class 'tuple'>

③总结：
t = (1, 2, 3)
x = tuple(t)
print(x)              # 结果为 (1, 2, 3)

t = (1, 2, 3)
print(t)              # 结果为 (1, 2, 3)

t = (1, )
print(t)              # 结果为 (1,)

2、基本操作

1、索引取值（正向、反向）
l = ('jerry', 175, 138.6, [789, 5000.6])
print(type(l))
print(l[0])           # 结果为 jerry
print(l[-1])          # 结果为 [789, 5000.6]

2、切片（顾头不顾尾，步长）
l = ('jerry', 175, 138.6, [789, 5000.6])
print(l[::1])
print(type(l))
print(l[1::1])
print(l[::-1])

3、长度len(元素个数)
l = ('jerry', 175, 138.6, [789, 5000.6])
print(len(l))           # 结果为 4

4、成员运算 in、 not in
l = ('jerry', 175, 138.6, [789, 5000.6])
print('jerry' in l)
print('tommy' not in l)

5、循环
l = ('jerry', 175, 138.6, [789, 5000.6])
for item in l:
    print(item)  
   
# 结果为
jerry
175138.6
[789, 5000.6]

3、内置方法

count 统计个数

name = ('jerry', 'tommy', 'judy', 'una', 'jerry', 'tommy', 'judy', 'jerry',)
print(name.count('jerry'))        # 3
print(name.count('una'))          # 1
print(name.count('anne'))         # 02、index:指定范围，查找某一个元素的位置

name = ('jerry', 'tommy', 'judy', 'una', 'jerry', 'tommy', 'judy', 'jerry',)
print(name.index('jerry', 5, 8))

t = (1, 2, 3, 2, 3, 2)
print(t.index(2, 0, 6))

4、总结

tuple类型总结：
　　　　　　存多个值
　　　　　　有序
　　　　　　不可变

5、案例

元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变
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、定义

1 用途：记录多个值，每一个值都对应的key用来描述value的作用
2 定义方式：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型， 而key必须是不可变的类型，通常情况下应该str类型

dict的key：可以为不可变类型：int float tuple str bool None， 一般就采用字符串
dict的value：可以为所以数据类型

注：key具有唯一性（重复会覆盖旧值），value可以重复
dic = {1: '178', 1.3: '196'，'name': 'egon', (1,): 'None',
      1: 5000, 'name': 'jerry'
      }
print(dic)           # 结果为 {1: 5000, 1.3: '196', 'name': 'jerry', (1,): 'None'}

d1 = {'name': 'Owen', 'age': 18}
print(d1)            # 结果为 {'name': 'Owen', 'age': 18}

d2 = dict({'name': 'Owen', 'age': 18})
print(d2)            # 结果为 {'name': 'Owen', 'age': 18}

d3 = dict(name='Egon', age=58)
print(d3)            # 结果为 {'name': 'Owen', 'age': 18}


二个用法：
用法一
dic = dict(x=1, y=3, z=4)
print(dic)              # 结果为 {'x': 1, 'y': 3, 'z': 4}

用法二
userinfo = [
    ['name', 'egon'],
    ['age', 18],
    ['sex', 'male']
    ]
d = {}
for k, v in userinfo:              # k,v=['name', 'egon']
    d[k] = v
print(d)

2、内置方法

按key存取值：可存可取。字典无序存储数据，无索引与切片
dic = {'name': 'Owen', 'age': 18}

增加一个元素。     key不存在
dic['weight'] = 120
print(dic)          # 结果为 {'name': 'Owen', 'age': 18, 'weight': 120}

改变一个元素。  key存在
dic['name'] = 'jerry'
print(dic)          # 结果为  {'name': 'jerry', 'age': 18, 'weight': 120}

删除 del
dic = {'name': 'Owen', 'age': 18}
del dic['name']
print(dic)     　　　　　　　　　　# 结果为 {'age': 18}
del dic['weight']
print(dic)                      # key不存在则报错

删除 pop:删除key对应的value,并返回value
dic = {'name': 'Owen', 'age': 18}
res = dic.pop('age')
print(dic)                      # 结果为 {'name': 'Owen'}
print(res)                      # 结果为 18


随机删除，返回值是(key, value)
dic = {'name': 'Owen', 'age': 18}
print(dic)                    # 结果为 {'name': 'Owen', 'age': 18}
print(dic.popitem())          # 结果为 ('age', 18)
print(dic.popitem())          # 结果为 ('name', 'Owen')
print(dic)                    # {}


查找
dic = {'name': 'Owen', 'age': 18}
print(dic['name'])              # 结果为  Owen
print(dic['weihght'])           # KeyError: 'weihght'   k不存在时会报错


长度len:统计长度
dic = {'name': 'Owen', 'age': 18}
print(len(dic))          # 结果为 23、成员运算in和not in:  字典的成员运算判断的是key
dic = {'name': 'Owen', 'age': 18}
print('name' in dic)     # 结果为 True
print('Owen' in dic)     # 结果为 False


get取值 *****
dic = {'name': 'Owen', 'age': 18}
print(dic.get('weight'))        # 结果为 None     # 拥有默认值，None，可以避免错误
print(dic.get('weight',120))    # 结果为 120      # 可以自定义默认值


update添加的参数字典，与dic可以重复，就是更新值，新key就是新增
dic = {'name': 'Owen', 'age': 18}
dic.update({'a': 123, 'b': 7589, 'name': 'jerry'})
print(dic)           
# 结果为 {'name': 'jerry', 'age': 18, 'a': 123, 'b': 7589}

如何定义一个空字典

第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10)  # {'a': '', 'b': '', 'c': ''}

添加老师

如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
d11 = {'a': 10, 'teas': ['Owen']}
if 'teas' not in d11:
    d11['teas'] = []
d11['teas'].append('Egon')
d11['teas'].append('LiuXX')
print(d11)           
# 结果为 {'a': 10, 'teas': ['Owen', 'Egon', 'LiuXX']}

3、字典的内置方法

字典的循环(迭代)
直接for循环(遍历)字典得到的是key
dic = {'a': 10, 'b': 20, 'c': 30}
for k in dic:
    print(k, dic[k])


能不能只循环值
dic = {'a': 10, 'b': 20, 'c': 30}
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
dic = {'a': 10, 'b': 20, 'c': 30}
for k, v in dic.items():
    print(k, v)         
# 结果为
a 10
b 20
c 30

4、案例

案例: 不区分大小写，计算每一个名字出现的次数，记录在字典中
ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
name_dic = {}
for name in ls:
    name = name.lower()
    if name not in name_dic:
        name_dic[name] = 1else:
        name_dic[name] += 1
print(name_dic)       
# 结果为 {'owen': 2, 'egon': 3, 'liuxx': 2}


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)              
# 结果为 {'owen': 2, 'egon': 3, 'liuxx': 2}

三、集合

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)

1、交集 &
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res)  # {'egon'}

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

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

4、对称差集
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'}


5、添加删除操作
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、案例

1、选课：
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)


2、了解：父子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)

四、练习

1、有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

num = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dic = {'k1': [], 'k2': []}
for i in num:
    if i > 66:
        dic['k1'].append(i)
    else:
        dic['k2'].append(i)
print(dic)

2、统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

s = 'hello alex alex say hello sb sb'
s = s.split(' ')
dic = {}
for i in s:
    if i not in dic:
        dic[i] = 1
    else:
        dic[i] += 1
print(dic)

3、关系运算 　　

有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 　

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} 　　

linuxs={'wupeiqi','oldboy','gangdan'} 　　

①求出即报名python又报名linux课程的学员名字集合

print(pythons & linuxs)

②求出所有报名的学生名字集合 　　

print(pythons | linuxs)

③求出只报名python课程的学员名字

print(pythons - linuxs)

④求出没有同时这两门课程的学员名字集合

print(pythons ^ linuxs)

4、去重

①有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重， # 得到新列表,且新列表无需保持列表原来的顺序

l = ['a', 'b', 1, 'a', 'a']
print(set(l))          # 结果为  {'a', 'b', 1}

②在上题的基础上，保存列表原来的顺序

l = ['a', 'b', 1, 'a', 'a']
l2 = []
for i in l:
    if i not in l2:
        l2.append(i)
print(l2)           # 结果为  ['a', 'b', 1]

③去除文件中重复的行，肯定要保持文件内容的顺序不变

import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

 5、将以下数据存储为字典类型

数据：info = "name:Owen|age:18|gender:男"

结果：{'name': 'Owen', 'age': 18, 'gender': '男'}

注：年龄存储为数字类型

info = "name:Owen|age:18|gender:男"
infos = info.split('|')   # ['name:Owen', 'age:18', 'gender:男']
info_dic = {}
for msg in infos:
    k, v = msg.split(':')
    info_dic[k] = v
print(info_dic)

6、完成数据的去重

数据：t3 = (1, 2, 1, 2, 3, 5, 9)

结果：t3 = (1, 2, 3, 5, 9)

# 考虑顺序
t3 = (1, 2, 1, 2, 3, 5, 9)
t3=set(t3)
print(t3)
t3=tuple(t3)
print(t3)


# 不考虑顺序
t3 = (1, 2, 1, 2, 3, 5, 9)
num =[]
for i in t3:
   if i not in num:
     num.append(i)
t3 = tuple(num)
print(t3)

7、计算元组中所有可以转换为数字的数据的总和

数据：t4 = (10, 'abc', '100', '3')

运算结果：113

t4 = (10, 'abc', '100', '3')
sum = 0
for i in t4:
    if isinstance(i, int):
        sum += i
    elif isinstance(i,str):
        if i.isdigit():
            i = int(i)
            sum += i
print(sum)

8、将数据转换类型存储

原数据：dic = {'name': 'Owen', 'age': 18, 'gender': '男'}

处理后：info = [('name', 'Owen'), ('age', 18), ('gender', '男')]

dic = {'name': 'Owen', 'age': 18, 'gender': '男'}
info = []
for k, v in dic.items():
    info.append((k, v))
print(info)