集合、元组、字典的操作合集
代码换行
- 添加 \ 可以起到换行作用
- 使用小括号
集合（set）
集合的定义：
把一定范围的，确定的，可以区别的事物当做一个整体来对待，这个整体就是集合。
集合的性质：
- 无序性：集合中所有的元素的下标都是相等的。
- 互异性：一个集合中，任意两个元素都不能相等，每个元素只在一个集合中出现一次。
- 确定性：给定一个集合，任给一个元素属不属于这个集合是确定的。
- 集合是可变序列有增删等操作。
- 集合的标识{ }
集合的创建：
# 空集合
set2 = set()
print(type(set2), set2)
# 结果：
# <class 'set'> set()
# 集合的构造器语法
str1 = 'hello'
set3 = set(str1)
print(set3)
list1 = [1, 2, 3, 2, 1]
set4 = set(list1)
print(set4)
# 结果：
# {'o', 'e', 'l', 'h'} # 集合的无序性
# {1, 2, 3} # 集合的互异性
集合的遍历（循环）
for i in set4:
print(i, end='')
# 结果：
# 1 2 3
集合的运算
# 成员运算 in、not in
set5 = {'王者荣耀', '和平精英', 'LOL'}
print('王者荣耀' in set5)
# 结果：
# True
集合的交、并、差、对称差
set_1 = {1, 2, 3, 4, 6, 8}
set_2 = {2, 4, 6, 8}
# 交集：&
print(set_1 & set_2)
# {8, 2, 4, 6}
# 并集：|
print(set_1 | set_2)
# {1, 2, 3, 4, 6, 8}
# 差集：-
print(set_1 - set_2)
print(set_2 - set_1)
#{1, 3}
# set()
# 对称差：^
print(set_1 ^ set_2)
#{1, 3}
集合只能存放不可变数据类型的数据：
集合可变（unhashable），hashable：计算机能够计算出哈希码的数据类型，
整型、浮点型等不可变数据类型都是hashable。
集合的”比较运算“：
set_3 = {1, 2, 3, 4, 6}
set_4 = {1, 3, 6}
set_5 = set_4
# 集合中，< 运算符表示真子集，<=运算符表示子集
print(set_4 < set_3, set_4 <= set_3)
print(set_5 < set_4, set_5 <= set_4)
# True True
# False True
# >运算符，超集运算(A包括B并且A还需要大于B)
print(set_3 > set_4)
# True
集合的增删操作:
set_6 = set()
# 向集合中添加元素
# add()、update()
# add()方法向集合中添加单个元素（必须是不可变数据类型）
set_6.add('Python')
set_6.add('Java')
# update()将某个序列中的元素添加到集合中
set_6.update({'HTML','C','C++'})
set_6.update(['Go','R','PHP'])
print(set_6)
# {'R', 'C', 'HTML', 'PHP', 'Go', 'Python', 'Java', 'C++'}
# 删除集合中元素：discard()、pop()、remove()、clear()
# discard()删除指定元素,discard()删除不存在的元素不报错
set_6.discard('R')
set_6.discard('Android')
print(set_6)
# {'C', 'HTML', 'PHP', 'Go', 'Python', 'Java', 'C++'}
# remove()删除指定元素，如果元素不存在，报错；使用remove前先做成员运算
# pop():从集合中随机删除一个元素并且返回该元素
content = set_6.pop()
print(content)
print(set_6)
# C
# {'HTML', 'PHP', 'Go', 'Python', 'Java', 'C++'}
# clear():清空
set_6.clear()
print(set_6)
# set()
元组(tuple)
概念：多个元素按照一定的顺序构成一定的序列
序列和列表的不同之处
- 列表使用[ ]，元组使用( )
- 元组是可变的，列表是不可变的
元组的创建
t0 = ()
tuple1 = (20,)
tuple2 = (20, 'abc')
tuple3 = (20, 'abc', [1, 2, 3])
print(type(tuple1), type(tuple2), type(tuple3))
# 结果：
# <class 'tuple'> <class 'tuple'> <class 'tuple'>
元组的基本运算和操作
-
查看元组长度：len()
print(len(tuple3))#结果：3 -
成员运算：
print(print(([1, 2, 3]) not in tuple3))# 结果：False -
拼接和重复：
print(tuple3 + tuple3) print(tuple3 * 3) # 结果： #(20, 'abc', [1, 2, 3], 20, 'abc', [1, 2, 3]) #(20, 'abc', [1, 2, 3], 20, 'abc', [1, 2, 3], 20, 'abc', [1, 2, 3])
4.遍历：
-
直接遍历：
for i in tuple3: print(tuple3，end=' ') # 结果： # 20 abc [1, 2, 3] -
间接遍历：
for i in range(len(tuple3)): print(len(t3uple, end=' ')) # 结果： #20 abc [1, 2, 3]
-
元组的下标：
正序从0开始，倒序从-1开始
print(tuple3[1]) print(tuple3[-2]) # abc # abc -
切片：
列表、字符串、元组的切片一样的
元组的打包和解包
-
打包：把多个使用逗号分割的值赋值给一个变量，多个值会打包成一个元组
t1 = 20, 30, 'abc' print(t1,type(t1)) # 结果：(20, 30, 'abc') <class 'tuple'> -
解包：如果有多个（多于三个）变量值要互相交换，必须使用打包解包操作，
a, b, c = t1 print(a, b, c) # 结果：20 30 abc -
解包的不定长参数：*
t2 = 1, 10, 100, 1000 i, j, k, m = t2 i, *j, k = t2 *l, n, m = t2 o, p, *q = t2 print(i, j, k) print(l, n, m) print(o, p, q) # 结果： # 1 [10, 100] 1000 # [1, 10] 100 1000 # 1 10 [100, 1000] -
解包操作对所有的序列都成立：
a, *b, c = range(1, 10) print(a, b, c) # 结果： # 1 [2, 3, 4, 5, 6, 7, 8] 9 -
两个或者三个变量交换值：
在python中存在ROT-TOW 和 ROT-THREE可以交换两个元素的值
a, b = 10, 20 a, b = b, a print(a, b) # 结果： # 20 10 a, b, c = 10, 20, 30 a, b, c = c, a, b print(a, b, c) # 结果： # 30 10 20
字典：
字典的特点和性质：
- 字典中的每一个元素，都是一个键值对(key: value)
- 字典是无序的可变的数据类型。
- 字典的容器符号也是{ }，每个元素用" , "隔开，字典的数据类型为dict
- 字典中的值可以是任意类型，值就是我们要保存的数据。
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
- 字典存在增删改操作
创建一个字典：
dict0 = {}
dict01 = dict()
# 空字典
dict1 = {'name': '张三', 'age': 30,
'weight': 55, 'address': '地球村',
'tel': 123132211, 'height': 175}
print(dict0, dict01, dict1) # 打印字典
print(type(dict0), type(dict01), type(dict1)) # 打印类型
print(len(dict0), len(dict01), len(dict1)) # 打印字典长度
# 结果：
# {} {} {'name': '张三', 'age': 30, 'weight': 55, 'address': '地球村', 'tel': 123132211, 'height': 175}
# <class 'dict'> <class 'dict'> <class 'dict'>
# 0 0 6
字典的操作：
1.字典的遍历
dict1 = {'name': '寂静岭', 'age': ' 2006', 'classify': '恐怖电影'}
for i in dict1:
print(i, end=' ')
# name age classify
2.字典的成员运算：
print('name' in dict1)
# True
3.获取字典中的值：
print(dict1['name'])
# 如果键不存在，报错：KeyError: '寂静岭'
# print(dict1['寂静岭'])
# get()方法：获取键对应的内容，如果键不存在，可以返回空值也可以返回指定内容
print(dict1.get('name'))
print(dict1.get('寂静岭')) # 只能查找键不能查找值
print(dict1.get('寂静岭', '查无此结果'))
# 寂静岭
# None
# None
# 查无此结果
4.获取字典中所有的键：keys()
dict1 = {'name': '寂静岭', 'age': ' 2006', 'classify': '恐怖电影'}
print(dict1.keys(), type(dict1.keys())) # 查看字典中键的类型
for i in dict1.keys():
print(i)
# dict_keys(['name', 'age', 'classify']) <class 'dict_keys'>
# name age classify
5.获取字典中所有的值：values()
print(dict1.values(), type(dict1.values()))
# dict_values(['寂静岭', ' 2006', '恐怖电影']) <class 'dict_values'>
6.获取字典中的所有键值对：items()
print(dict1.items(), type(dict1.items()))
# dict_items([('name', '寂静岭'), ('age', ' 2006'), ('classify', '恐怖电影')]) <class 'dict_items'>
# ('name', '寂静岭')
# ('age', ' 2006')
# ('classify', '恐怖电影')
for key, value in dict1.items():
print(key, value)
# name 寂静岭
# age 2006
# classify 恐怖电影
7.字典的增删查改：
（1）向字典中增加元素：
dict2 = {} # 创建一个空字典
# 1.直接添加元素：
dict2['name'] = '金刚狼'
print(dict2)
# {'name': '金刚狼'}
# 2.使用setdefault():向字典中添加元素，如果不存在则直接添加，如果存在则不对字典进行修改
dict2.setdefault('name' , '狼叔')
dict2.setdefault('age', 40)
print(dict2)
# {'name': '金刚狼', 'age': 40}
(2)修改字典中的元素：update()
# 1.直接修改
dict2['name'] = '派大星'
print(dict2)
# {'name': '派大星', 'age': 40}
# 2.update():如果字典中某个值存则修改，不存在则添加（可以批量修改或者添加）
dict2.update({'age': 30, 'address': '比奇堡'})
print(dict2)
# {'name': '派大星', 'age': 30, 'address': '比奇堡'}
(3)删除字典中的元素：del 、 pop（）
del dict2['address']
dict2.pop('age')
print(dict2)
# {'name': '派大星'}
8.字典推导式：
# 取出字典中值大于100的键和值
dict_A = {'a': 101, 'b': 99,'c': 20.1,'d': 160}
dict_B = {key: value for key, value in dict_A.items() if value > 100}
dict_C = {i: dict_A[i] for i in dict_A if dict_A[i] > 100 }
print(dict_B)
print(dict_C)
# {'a': 101, 'd': 160}
# {'a': 101, 'd': 160}
以上内容来自于上课笔记
113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
