一.元组
- 元组表现形式tuple
- 元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
- 使用()创建元素
- 元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略
- 元组解包指将元组当中的每一个元素都赋值给一个变量
# 创建元组
tuple_1 = ('C++', 'Python', 'Java', 'PHP')
# 解包
a, b, c, d = tuple_1
print(a, b, c, d) # C++ Python Java PHP
a, *b, c = tuple_1
print(a, b, c, d) # C++ ['Python', 'Java'] PHP
二.集合
- 集合表现形式set 集合和列表非常相似
- 集合只能存储不可变对象
- 集合中存储的对象是无序的
1.集合的使用
- 集合类型set()
- 字典、推导式、迭代器等可迭代参数转为集合
- 使用{}来创建集合
score = [95, 28, 80, 66, 95]
set_score = set(score) # set:将列表转化为集合
print(set_score) # {80, 66, 28, 95}
- 集合是无序的
- 集合中的元素不重复，可用于消除重复元素
# 想知道一个日期里有几个不重复的数字
date = '20201012'
set_date = set(date)
print(set_date) # {'1', '0', '2'}
print(len(set_date)) # 3
- 支持add()，remove()等方法，可遍历
- add()像集合中添加元素
- update()将一个集合中的元素添加到另一个集合当中
- remove() 删除集合中指定的元素
- pop()随机删除集合中的一个元素一般是删除最开始的一个元素
- clear() 清空集合
- 不支持索引和切片序列操作（无序）
# 有2018和2019手机销售数据（百分数）
sale = [['华为', 34.3], ['vivo', 18.5], ['OPPO', 18.6], ['小米', 12.3], ['Apple', 8.6]]
set_of_sale = {x[0] for x in sale}
print(set_of_sale) # {'OPPO', 'vivo', '华为', 'Apple', '小米'}
set_of_sale.add('三星')
print(set_of_sale) # {'三星', 'Apple', 'vivo', '小米', '华为', 'OPPO'}
set_of_sale.remove('Apple')
print(set_of_sale) # {'三星', 'vivo', '小米', '华为', 'OPPO'}
# remove(x) 当x不存在时触发异常
set_of_sale.remove('Apple') # KeyError: 'Apple'
# discard 从集合 s 中删除对象 x，s中不存在x也不会报错
set_of_sale.discard('Apple')
print(set_of_sale) # {'小米', 'OPPO', 'vivo', '华为', '三星'}
# 随机删除集合 s 中的任意一个对象，并返回删除的元素
s = set_of_sale.pop()
print(set_of_sale) # {'vivo', '三星', '华为', 'OPPO'}
print(s) # 小米
# 删除集合 s 中的所有元素，清空集合
set_of_sale.clear()
print(set_of_sale) # 空集合 set()
2.集合之间的关系
集合之间的关系如同我们在中学时学习的集合关系一样，有（真）子集， 空集，全集等等。
# 以下的代码中，集合s，集合t为当前已给出的集合。
s = {'t', 'y', 'p'}
t = set('python') # {'t', 'n', 'o', 'h', 'p', 'y'}
- <= 检查一个集合是否是另一个集合的子集
# s是否是t的子集，是返回True，否则返回False
print(s.issubset(t)) # True
print(s <= t) # True
- < 检查一个集合是否是另一个集合的真子集
# s是否是t的真子集，是返回True，否则返回False
print(s < t) # True
- >=检查一个集合是否是另一个集合的超集
# 当一个集合s中的元素包含另一个集合t中的所有元素时，称集合s是集合t的超集，或反过来，称t是s的子集。
# s是否是t的超集，是返回True，否则返回False
print(s.issuperset(t)) # False
print(s >= t) # False
- >检查一个集合是否是另一个集合的真超集
# s是否是真包含t，是返回True，否则返回False
print(s > t) # False
- == 集合1是否和集合2相等，是返回True，否则返回False
# s是否和t相等，是返回True，否则返回False
s = {'0', '1'}
t = set('10110011101') # {'1', '0'}
print(s == t) # True
3.集合的运算
# 以下的代码中，集合s，集合t为当前已给出的集合。
s = set('bookshop') # {'o', 'k', 'h', 's', 'b', 'p'}
t = set('cheeseshop') # {'o', 'e', 'c', 'h', 's', 'p'}
- | 并集运算
# 集合s和t的并集
print(s | t)
# {'h', 'k', 'e', 's', 'p', 'o', 'b', 'c'}
- & 交集运算
# 集合s和t的交集
print(s & t) # 两个集合共的的元素{'o', 'h', 's', 'p'}
- - 差集运算
# 集合s和t的差集
print(s - t) # s中存在，但t中不存在的元素{'b', 'k'}
- ^ 亦或集
# 集合s和t的对称差，即存在于s和t中的非交集数据
print(s ^ t) # 只属于s或只属于t的元素{'b', 'e', 'c', 'k'}
三.字典
字典属于一种新的数据结构称为映射(mapping)，它的作用和列表类似，都是用来存储对象的容器。列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反，在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素。这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值。所以字典我们也称之为键值对(key-value)结构。
- 字典使用一对大括号“{}”来存放数据，元素之间用逗号“,”分隔。
- 每个元素都是一个“键:值”（Key:Value）对，用来表示“键”和“值”的映射关系或对应关系。
- 字典的存储是按加入顺序存储，但不可用索引和切片等方法。
- 字典中的键不可重复
- 字典的值可以是任意类型的数据，也可以重复。
1.字典的创建
- 空字典的创建
D1 = {} # 使用一对不包含任何数据的“{}”创建一个空字典数据
D2 = dict() # 使用字典构造器创建一个空字典数据
print(D1, D2) # 输出：{} {}
- 非空字典的创建
D1 = {'name': '张三', 'age': 19, 'gender': 'M'}
print(D1)
- 使用字典构造器创建字典，给键名赋值（创建映射）且键名不加引号
D2 = dict(name='张三', age=19, gender='M')
print(D2)
- 使用字典构造器创建字典，通过包含两个元素（键和值）的序列
D3 = dict([('name', '张三'), ('age', 19), ('gender', 'M')])
print(D3)
2.字典的操作
# 以下的代码中，字典telephone_dict为当前已给出的字典。
telephone_dict = {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234'}
- 获取字典值——条件语句
query_name = input('请输入要查询的联系人姓名：')
# 接收查询的姓名字符串，返回其联系方式或该人信息不存在
if query_name in telephone_dict: # 判断是否存在,避免姓名不存在导致异常
print(query_name + ':' + telephone_dict[query_name]) # 以输入的人名为键访问字典中该键对应的值
else:
print(f'联系人{query_name}不存在') # 联系人某某某不存在
- 获取字典值——get函数
query_name = input('请输入要查询的联系人姓名：')
# 接收查询的姓名字符串，返回其联系方式或该人信息不存在
print(query_name + ':' + telephone_dict.get(query_name, f'联系人{query_name}不存在')) # 以输入的人名为键访问字典中该键对应的值
- 获取字典的键、值、键值对
# dict.keys() # 获取字典dict中的所有键组成一个可迭代数据对象。
# dict.values() # 获取字典dict中的所有值组成一个可迭代数据对象。
# dict.items() # 获取字典dict中的所有键值对，两两组成元组，形成一个可迭代数据对象。
telephone_dict = {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234'}
print(telephone_dict.keys()) # 返回可迭代对象，dict_keys(['李明', '张宏', '吕京'])
print(list(telephone_dict.keys())) # 将可迭代对象转为列表['李明', '张宏', '吕京']
print(telephone_dict.values())
# 输出dict_values(['13988887777', '13866668888', '13143211234'])
print(telephone_dict.items())
# 输出dict_items([('李明', '13988887777'), ('张宏', '13866668888'), ('吕京', '13143211234')])
- 遍历字典
for name in telephone_dict.keys(): # 对可迭代对象dict_keys()进行遍历输出
print(name) # 李明\n张宏\n吕京
for name,phone in telephone_dict.items(): # 对可迭代对象dict.items()进行遍历输出
print(name+':'+phone) # 李明:13988887777\n张宏:13866668888/n吕京:13143211234
- 修改字典值
# dict[key] = value
# dict.update(k1=v1[, k2=v2,…])
telephone_dict = {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234'}
telephone_dict['李明'] = '13988887788' # 将李明的电话更新为 '13988887788'
telephone_dict.update(张宏='13866668877') # 将张宏的电话更新为'13866668877'
telephone_dict.update(王晶='13244441111') # 键‘王晶’不存在，将键值对加入字典
print(telephone_dict) # 输出更新后的字典
# {'李明': '13988887788', '张宏': '13866668877', '吕京': '13143211234', '王晶': '13244441111'}
- 增加元素
# dict[newkey] = value
# dict.setdefault(key[, value])
telephone_dict = {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234'}
telephone_dict['赵雪'] = '13000112222' # 为字典新增元素 '赵雪': '13000112222'
telephone_dict.setdefault('刘飞', '13344556655') # 为字典新增元素 '刘飞': '13344556655'
telephone_dict.setdefault('程钱') # 值缺省时，默认为None，为字典新增元素'程钱': None
print(telephone_dict)
# {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234', '赵雪': '13000112222', '刘飞': '13344556655', '程钱': None}
- 值的删除
# pop() 返回字典 dict 中键 key 对应的值，并将键为 key 的键值对元素删除
# popitem() 从字典中移除并返回一个元组形式的 (键, 值) 对
# clear() 清空dict中所有数据，dict成为空字典。
# 关键字del命令
telephone_dict = {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234', '赵雪': '13000112222', '刘飞': '13344556655', '程钱': None}
delkey = telephone_dict.pop('李明')
# 删除键为李明的元素，返回值是键'李明'对应的值'13988887777'
print('删除的联系人的电话是：', delkey)
# 删除的联系人的电话是： 13988887777
telephone_dict = {'李明': '13988887777', '张宏': '13866668888', '吕京': '13143211234'}
delitem = telephone_dict.popitem() # 随机删除并返回一个键值对
print('删除的联系人是：', delitem) # 删除的联系人一般是最后一个元素
# 删除的联系人是： ('吕京', '13143211234')
print(telephone_dict)
# {'李明': '13988887777', '张宏': '13866668888'}
del telephone_dict['张宏'] # 删除键为'张宏'的键值对
print(telephone_dict) #{'李明': '13988887777'}
- 字典排序输出
# 字典本身是无序的，但可以在输出时，将字典的元素、键或值转为列表再排序输出。
# dict.keys()、dict.values()、dict.items()都是可迭代对象，可以作为sorted()函数的参数。
dic = {'Tom': 21, 'Bob': 18, 'Jack': 23, 'Ana': 20}
print(sorted(dic.keys())) # ['Ana', 'Bob', 'Jack', 'Tom']
print(sorted(dic.items())) # [('Ana', 20), ('Bob', 18), ('Jack', 23),('Tom', 21)]
dic = {'Tom': 21, 'Bob': 18, 'Jack': 23, 'Ana': 20}
print(sorted(dic.items(), key=lambda item: item[1]))
# key参数利用lambda函数，根据item[1]的值进行排序
# [('Bob',18), ('Ana', 20), ('Tom', 21), ('Jack', 23)]
四.应用练习
- a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3
a = {"name":"123","data":{"result":[{"src":"python1"},{"src":"python2"},{"src":"python3"}]}}
# 方法一：
print(a['data']["result"][0]["src"], end='/')
print(a['data']["result"][1]["src"], end='/')
print(a['data']["result"][2]["src"])
# 方法二：
print([a['data']["result"][i]["src"] for i in range(3)])
- 有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。
s = {11,22,33,44,55,66,77,88,99,90}
myDict = {'key_1' : [], 'key_2' : []}
for i in s:
if i < 66:
myDict['key_1'].append(i)
elif i > 66:
myDict['key_2'].append(i)
print(myDict)
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
