列表、字典、元组、集合详解

列表、字典、元组、集合详解

1.列表内置方法补充

# 排序之sort（）（只针对数字）
# l1 = [2, 3, 5, 6, 9, 0, 2]
# l1.sort()  # 默认升序
# print(l1)  # [0, 2, 2, 3, 5, 6, 9]
# l1.sort(reverse=True)  # 参数指定，降序
# print(l1)  # [9, 6, 5, 3, 2, 2, 0]
# 顺序颠倒之reverse（）
# l1.reverse()  # 颠倒顺序
# print(l1)  # [2, 0, 9, 6, 5, 3, 2]
# 切片简写形式
# print(l1[:5])  # [2, 3, 5, 6, 9] 左边不写默认从第一个取
# print(l1[5:])  # [0, 2]  右边不写默认取到最后一个
# print(l1[:])  # [2, 3, 5, 6, 9, 0, 2]  左右都不写默认全取
# 列表比较大小
# 数字比较
# l1 = [888, 999]
# l2 = [555, 777, 888, 999]
# print(l1 > l2)  # True  列表比较运算，采用相同索引对应的值进行比较，只要有一个比较有了结果就下结论
# 字符串比较
# s1 = ['hello', 'world']
# s2 = ['why', 'what']
# print(s1 > s2)  # False  字符串比较大小根据索引对应的字符内部转换成ASCII码对应的数字进行比较

2.字典内置方法

• 字典的修改、增加、删除

# 字典默认暴露给外界的只有k值，在进行字典操作时只能通过k值
# 通过k值取值
# dic = {
#     'name': 'jane',
#     'age': 18,
#     'sex': 'female'
# }
# print(dic['name'])  # jane 根据k值取值，k值存在，返回对应的v值
# print(dic['hobby'])  # k值不存在报错
# 通过k值修改,k值存在时修改对应的v值，k值不存在，增加新的键值对
# 2.1 修改值
# dic['age'] = 20
# print(dic['age'])  # 20
# 2.2 增加新的键值对
# dic['hobby'] = 'play computer'
# print(dic)
# # 2.3 统计字典内键值对的个数之len
# print(len(dic))  # 4
# {'name': 'jane', 'age': 18, 'sex': 'female', 'hobby': 'play computer'}
# 2.4 成员运算
# print('sex' in dic)  # True
# 2.5 删除元素
# 2.5.1 通用删除del
# del dic['name']
# print(dic)  # {'age': 18, 'sex': 'female'}
# 2.5.2 指定k值弹出键值对。返回对应的v值
# print(dic.pop('name'))  # jane
# print(dic)  # {'age': 18, 'sex': 'female'}
# 2.5.3 弹出键值对，返回的键值对组成元组的形式，第一个元素是k值，第二个元素是v值，从最后一对键值对弹出
# print(dic.popitem())  # ('sex', 'female')
# print(dic)  # {'name': 'jane', 'age': 18}

• 字典的取值、更新

# 2.6 获取v值
# 2.6.1  通过字典的k取值的方式弹出
# k值存在时，弹出对应的v值
# print(dic['name'])  # jane
# k值不存在时，直接报错，不推荐这种取值方法
# print(dic['aaa'])  #  报错
# 2.6.2 通过字典内置方法get取值
# k值存在时，返回对应的v值
# print(dic.get('name'))  # jane
# 当k值存在时，返回对应的v值，第二个参数所对应的自定义信息不打印
# print(dic.get('name', '哈哈哈'))
# 当k值不存在时，返回Null
# print(dic.get('job'))  # None
# 当k值不存在时，返回Null,第二个参数所对应的自定义信息会打印
# print(dic.get('job', 'job 不存在'))  # job 不存在
# 2.7 返回所有的key值之keys（），返回所有的Value值之values（）
# 2.7.1 返回所有的k值，返回的k值会生成列表的形式
# print(dic.keys())  # dict_keys(['name', 'age', 'sex'])
# 2.7.2 返回所有的v值，返回的v值会生成列表的形式
# print(dic.values())  # dict_values(['jane', 18, 'female'])
# 2.8 返回字典里所有的键值对，所有的键值对存储在一个列表里，列表里的每一个元素都是一个键值对，元素采用元组的形式
# print(dic.items())  # dict_items([('name', 'jane'), ('age', 18), ('sex', 'female')])
# 2.9 更新字典之update（）
# 键值存在则修改，不存在则添加
# dic.update({'age': 20})
# print(dic)  # {'name': 'jane', 'age': 20, 'sex': 'female'}
# dic.update({'job': 'read'})
# print(dic.update({'job': 'read'})) # 返回none
# print(dic)  # {'name': 'jane', 'age': 18, 'sex': 'female', 'job': 'read'}
# 2.10 更新字典之setdefault（）
# 当k值存在时，不修改而是返回v值
# print(dic.setdefault('name', 'jane'))  # jane
#  当k值不存在时，新增一组键值对，并且结果返回新增的v值
# print(dic.setdefault('job', 'read'))  # read
# print(dic)
# 2.11 初始化字典
# print(dic.fromkeys(['k1', 'k2', 'k3'], []))  # v如果是空列表的，所有的k都指向同一个空列表
'''笔试题'''
# res = dict.fromkeys(['k1', 'k2', 'k3'], [])
# res['k1'].append(111)  # {'k1': [111], 'k2': [111], 'k3': [111]}
# print(res)
# res['k2'].append(222)
# res['k3'].append(333)
# print(res)  # {'k1': [222, 333], 'k2': [222, 333], 'k3': [222, 333]}
# res['k1'] = [111, 222, 333]
# res['k1'].append(444)
# print(res)  # {'k1': [111, 222, 333, 444], 'k2': [], 'k3': []}

3.元组的内置方法

'''再见元组:元组是用小括号括起来，元素与元素之间逗号隔开，
元素可以是任意数据类型，但是元组内的数据不支持'修改'（索引所指向的元素的内存地址不能改变），
也可以的简单的认为元组就是不可变列表
'''
# 3.1 类型转换
# 元组在做类型转换时，能够支持for循环的数据都可以转换成元组（字符串，列表，字典）
# print(tuple(11))  # 报错
# print(tuple(11.11))  # 报错
# print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
# print(tuple([1, 2, 3]))  # (1, 2, 3)
# print(tuple({'name': 'jane', 'age': 18}))  # ('name', 'age')
# 元组第一道笔试题
# t1 = (111)  # 整型
# t2 = (11.11)  # 浮点型
# t3 = ('hello')  # 字符串
'''元组哪怕内部只有一个元素，也需要加上逗号'''
# t4 = (111,)  # 元组
'''容器类型：内部可以存放多个值的数据类型都可以称之为容器类型
    建议：所有的容器类型存储数据的时候，如果内部只有一个元素，最好也加上逗号
'''
# t = (111, 222, 333, 444, 555)
# 1.索引取值
# print(t[2])  # 333
# print(t[-1])  # 555
# 2.切片操作
# print(t[1:5])  # (222, 333, 444, 555)
# print(t[1:])  # (222, 333, 444, 555)
# print(t[:])  # (111, 222, 333, 444, 555)
# 3.步长
# print(t[1:5:2])  # (222, 444)
# 4.统计元组内元素的个数
# print(len(t))  # 5
# 5.for循环
# for i in t:
#     print(i)
# 6.count计数
# print(t.count(111))  # 1
'''笔试题 '''
# t1 = (111, 222, [11, 22, 33])
# t1[2].append(44)
# print(t1)  # (111, 222, [11, 22, 33, 44])

4.集合的操作方法

# 4.1定义空集合需要使用关键字set
# s1 = set()
# 4.2类型转换
# 集合在做类型转换的时候，能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
'''集合内元素是无序的'''
# 4.3去重
# s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
# print(s1)  # {1, 2, 3, 4}
# 小练习
# name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
# 1.先将列表转换成集合
# s1 = set(name_list)
# 2.再将去重之后的集合转换成列表
# l1 = list(s1)
# print(l1)  # ['kevin', 'jason']
"""课堂练习题"""
# ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 基本要求:去重即可
# s1 = set(ll)
# ll1 = list(s1)
# print(ll1)
# 拔高要求:去重并保留原来的顺序
# 1.先定义一个新列表
# new_list = []
# # 2.for循环ll列表
# for i in ll:
#     # 3.判断当前元素是否在新列表中
#     if i not in new_list:
#         # 3.1 如果不在 则添加到新列表
#         new_list.append(i)
#     # 3.2 如果在 则不管
# print(new_list)
# 4.4 关系运算
"""两个群体之间做差异比较    共同好友 共同关注..."""
friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
# 1.求两个用户的共同好友
# print(friends1 & friends2)  # {'jason', 'eg'}
# 2.求两个用户所有的好友
# print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
# 3.求用户1独有的好友
# print(friends1 - friends2)  # {'zero', 'kevin'}
# 4.求用户2独有的好友
# print(friends2 - friends1)  # {'ricky', 'Jy'}
# 5.求用户1和用户2各自的好友
# print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}
# 6.父集与子集
# s1 = {11, 22, 33, 44}
# s2 = {11, 33}
# print(s1 > s2)  # 判断s1是否是s2的父集   True
# print(s2 < s1)  # 判断s2是否是s1的子集   True