本文主要结合例题介绍了序列【常用函数、可迭代对象】，字典【函数、写法、定义、视图对象】，集合【常用函数】，运算符优先级。这几种数据集合在Python中也是蛮重要的，对于新手比较友好。
本文例题大多来自哔站up主鱼C-小甲鱼【Python教程】的练习过程，当然有所改变，up主也是用的交互式，注重理解注重理解！！！
持续更新中，蟹蟹٩('ω')大家支持，更多内容，敬请期待！。有点小用的话，点赞收藏+关注吧！！！
目录
例42 ‘is’ ‘is not’ ‘in’ ‘not in’ “+” “*” ‘del’
例43 列表、元组和字符串相互转换----list（）、tuple（）、str（）
例45 列表都是可迭代对象（迭代器是一次性的，可迭代对象可以重复使用）
例49 字典中的常见函数(len keys values item update clear)
3.添加元素，注意（添加列表时会出现错误，因为列表是可变的,在向集合中添加元素时，只能添加不可变的值，比如说字符串或者元组)
十六、序列（上）通用操作
例42 ‘is’ ‘is not’ ‘in’ ‘not in’ “+” “*” ‘del’
#列表，序列，元组...
[1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
(1,2,3)+(4,5,6)
(1, 2, 3, 4, 5, 6)
'123'+'456'
'123456'
[1,2,3]*2
[1, 2, 3, 1, 2, 3]
(1,2,3)*2
(1, 2, 3, 1, 2, 3)
s = [1,2,3]
id(s)
2102001109248
s*=2
s
[1, 2, 3, 1, 2, 3]
t = (1,2,3)
id(t)
2102001117504
t*=2
t
(1, 2, 3, 1, 2, 3)
id(t)
2101999632000
x = "FishC"
y = "FishC"
x is y
True
x = [1,2,3]
y = [1,2,3]
x is y
False
'鱼' in '鱼C'
True
'C' not in '鱼C'
False
x = 'FishC'
y = [1,2,3]
del x,y
x
Traceback (most recent call last):
File "<pyshell#25>", line 1, in <module>
x
NameError: name 'x' is not defined
y
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
y
NameError: name 'y' is not defined
x = [1,2,3,4,5]
del x[::2] #切片操作：间距是2
x
[2, 4]
y = [1,2,3,4,5]
y[::2] = [] #错误操作
Traceback (most recent call last):
File "<pyshell#31>", line 1, in <module>
y[::2] = []
ValueError: attempt to assign sequence of size 0 to extended slice of size 3
del y[:]
y
[] #正确十七、序列（中）
例43 列表、元组和字符串相互转换----list（）、tuple（）、str（）
list("Zmr248") #list()转化为序列
['Z', 'm', 'r', '2', '4', '8']
list((1,2,3,4,5))
[1, 2, 3, 4, 5]
tuple("Zmr248") #tuple()转化为元组
('Z', 'm', 'r', '2', '4', '8')
tuple([1,2,3,4,5])
(1, 2, 3, 4, 5)
str([1,2,3,4,5]) #str()转化为字符串
'[1, 2, 3, 4, 5]'
str((1,2,3,4,5))
'(1, 2, 3, 4, 5)'
s = [1,2,3,4,0]
min(s) #min()寻找最小值，如果是字符串则是寻找编码中的较小值，max()亦同
0
t = "Zmr248"
max(t)
'r'
s = []
min(s) #错误代码
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
min(s)
ValueError: min() iterable argument is empty
min(s,default='屁，啥也没有，怎么找到最小？') #default默认在字符串是空的时候进行输出的值
'屁，啥也没有，怎么找到最小？'
min(1,4,2,3,6)
1
len(range(2**100)) #？？？？？？？
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
len(range(2**100))
OverflowError: Python int too large to convert to C ssize_t十八、序列（下）
例44 函数：(map函数返回的对象是一个迭代器)
map函数 文心一言
enumerate :转换为object对象
zip(x,y,...):将两个列表进行拼接成元组，再进行拼接成序列 一一对应的关系
map(ord,"Fishc"):转化为每个字符的编码
map(pow,[2，3，10],[5，2，3])：将两个列表进行次方幂（等同于[pow(2，5)，pow(3，2)，pow(10，3)]）
(map(max,[1,3,5],[2,2,2],[0,3,9，8]))：将列表进行比较出最大值
list(filter(str.islower,"Fishc"))：选出小写字母
seasons = ["spring","summer","fall","winter"]
enumerate(seasons)
<enumerate object at 0x000001B1C600A520>
list(enumerate(seasons))
[(0, 'spring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]
list(enumerate(seasons,10))
[(10, 'spring'), (11, 'summer'), (12, 'fall'), (13, 'winter')]
x = [1,2,3]
y = [4,5,6]
zipped = zip(x,y)
list(zipped)
[(1, 4), (2, 5), (3, 6)]
z = [7,8,9]
zipped = zip(x,y,z)
list(zipped)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
z = ("zmr248")
zippde = zip(x,y,z)
list(zippde)
[(1, 4, 'z'), (2, 5, 'm'), (3, 6, 'r')]
import itertools
zipped = itertools.zip_longest(x,y,z)
list(zipped)
[(1, 4, 'z'), (2, 5, 'm'), (3, 6, 'r'), (None, None, '2'), (None, None, '4'), (None, None, '8')]
mapped = map(pow,[2,3,10],[5,2,3])
list(mapped)
[32, 9, 1000]
[pow(2,5),pow(3,2),pow(10,3)]
[32, 9, 1000]
list(map(max,[1,3,5],[2,2,2],[0,3,9,8]))
[2, 3, 9]
list(filter(str.islower,"zmr248"))
['z', 'm', 'r']例45 列表都是可迭代对象（迭代器是一次性的，可迭代对象可以重复使用）
mappde = map(ord,"Zmr248")
for each in mappde:
print(each)
90
109
114
50
52
56
list(mappde)
[]
x = [1,2,4,5]
y = iter(x)
type(x)
<class 'list'>
type(y)
<class 'list_iterator'>
next(y)
1
next(y)
2
next(y)
4
next(y)
5
next(y) #出现异常，并不是错误
Traceback (most recent call last):
File "<pyshell#13>", line 1, in <module>
next(y)
StopIteration
z = iter(x) #重新激活x
next(z,"没啦，被你掏空了") #将字符串“没啦，被你掏空了”代替
1
next(z,"没啦，被你掏空了")
2
next(z,"没啦，被你掏空了")
4
next(z,"没啦，被你掏空了")
5
next(z,"没啦，被你掏空了")
'没啦，被你掏空了'
next(z,"没啦，被你掏空了")
'没啦，被你掏空了'十九、字典（上）
例46 字典的几种写法，比较复杂
主要还是使用直接初始化：
直接在大括号{}中指定键值对，每个键值对之间用逗号,分隔。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}例47 常用函数：增删改查
增（y["刘备"]="刘Baby"直接添加即可）
删（pop(' ')函数 clear(' '):直接删除所有元素，将其变成空） d.popitem()：默认删除最后一个元素 del d['i']
改（直接根据键进行修改即可）
查（略）
在Python中，字典（dictionary）是一种非常灵活的数据结构，它允许你存储键值对（key-value pairs）。字典的增删改查操作主要通过以下方法实现：
1. 增加（添加）元素
向字典中添加新元素或更新现有元素的键对应的值，可以直接使用赋值操作符=。如果键已存在，则更新其值；如果键不存在，则添加新键值对。
my_dict = {'name': 'John'}
my_dict['age'] = 30 # 添加新元素
my_dict['name'] = 'Jane' # 更新现有元素的值
2. 删除元素
删除字典中的元素可以使用多种方法：
-
del语句：用于删除指定的键及其对应的值。
del my_dict['age'] # 删除键为'age'的元素
-
pop()方法：删除指定键的元素，并返回该键对应的值。如果键不存在，可以指定一个默认值作为返回值。
age = my_dict.pop('age', None) # 如果'age'存在，则删除并返回其值；否则返回None
-
clear()方法：清空字典中的所有元素。
my_dict.clear() # 清空字典
3. 修改元素
修改字典中的元素实际上就是更新键值对。如上所述，使用赋值操作符=即可。
4. 查找元素
-
直接通过键来访问值：如果键存在，则返回其对应的值；如果键不存在，则抛出
KeyError。
name = my_dict['name'] # 访问键为'name'的值
-
使用
get()方法：更安全地访问字典中的值。如果键存在，则返回其对应的值；如果键不存在，则返回指定的默认值（默认为None）。
name = my_dict.get('name', 'Unknown') # 如果'name'不存在，则返回'Unknown'
-
遍历字典：可以使用
for循环遍历字典的键、值或键值对。
# 遍历键 for key in my_dict: print(key) # 遍历值 for value in my_dict.values(): print(value) # 遍历键值对 for key, value in my_dict.items(): print(key, value)
这些方法提供了在Python字典中进行增删改查操作的基本方式。
例48 增删改查2
dic = {'hero':'孙膑','sex':'f','profession':'辅助'}
print(dic)
# print(dic['hero'])
# #通过get访问字典数据
# print(dic.get('hero'))
#区别打印一个没有的键
# print(dic['a'])
# print(dic.get('a')) #此句不会报错，会打印None
#添加元素
# dic['route'] = '上单'
# print(dic)
# 修改数据
# dic['profession'] = '战士'
# print(dic)
#删除(先确定键是存在的)
# dic.pop('profession')
# print(dic)例49 字典中的常见函数(len keys values item update clear)
dic1 = {'hero':'安琪拉','sex':'t','profession':'法师'}
# len函数：统计字典中键值对的数量
print(len(dic1))
# keys函数：统计字典中所有的键key
print(dic1.keys())
# values方法：统计字典中所有的值value
print(dic1.values())
# items方法：统计字典中的所有的键值对
print(dic1.items())
# update方法：合并字典 注意如果新添加的键值对中存在值相同的情况下会覆盖掉原来的键值对
dic2 = {'location':'远程','viability':'6 stars'}
dic1.update(dic2)
print(dic1)
# clear方法清空字典，把字典中的键值对全部清空
dic1.clear()
print(dic1)字典（中）[视图对象]
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~3.16
d = dict.fromkeys("Zmr248") #声明一个字典
print(d)
d['2'] = 115
print(d)
d.update({'m':22})
print(d)
d.update(Z = '110')
print(d)
print(d['Z']) #查看value
print(d.get('c','这里没有这个字符'))
print(d.setdefault('Z','code'))
# 将字典的键和值转换为一个元组，在进行转换为列表
print(d)
# 视图对象，同时也将其转换为一个动态集合
keys = d.keys() #获取d的所有键
values = d.values() #获取所有的键的值
items = d.items() #获取字典的所有键值对，并将它们作为元组的列表值给变量item，是一个静态列表，item的值不会因为改变字典d而发生变化
print(items)
print(keys)
print(values)
d.pop('Z')
print(d)
# 浅拷贝
e = d.copy()
print(e)
print(len(d))iter将字典转换成迭代器：
# iter将字典转换为迭代器
d = {'m': 22, 'r': None, '2': 115, '4': None, '8': None}
list(d)
['m', 'r', '2', '4', '8']
list(d.values())
[22, None, 115, None, None]
e = iter(d)
next(e)
'm'
next(e)
'r'
next(e)
'2'
next(e)
'4'
list(reversed(d.values())) #反向输出字典（下）[字典的嵌套，查找，转换（ord()函数）]
d = {'吕布':{"语文":60,'数学':70,'英语':80},"关羽":{"语文":80,'数学':90,'英语':70}} #字典的嵌套
d
{'吕布': {'语文': 60, '数学': 70, '英语': 80}, '关羽': {'语文': 80, '数学': 90, '英语': 70}}
d["吕布"]['数学']
70
d = {'吕布':[60,70,80],'关羽':[80,90,70]} #字典嵌套的查找
d['吕布'][1]
70
d ={'F':70,'i':105,'s':115,'h':104,'c':67}
b = {v:k for k,v in d.items()}
b
{70: 'F', 105: 'i', 115: 's', 104: 'h', 67: 'c'}
c = {v:k for k,v in d.items() if v > 100}
c
{105: 'i', 115: 's', 104: 'h'}
d = {x:ord(x) for x in "Fishc"} #转换为其对应的ASCII值
d
{'F': 70, 'i': 105, 's': 115, 'h': 104, 'c': 99}
d = {x:y for x in [1,3,5] for y in[2,4,6]} #将两个列表变成一一对应的字典关系
d
{1: 6, 3: 6, 5: 6}二十、集合
例50 集合和字典的类型区别 以及优点
# set1 = {1,3,4,2,5}
# print(set1)
# s = {}
# print(type(s)) #类型是dict 字典类型
# #创建空的集合
# s1 = set()
# print(type(s1)) #类型是集合 set
# list = [1,2,2,3,2,5]
# s = set(list)
# print(s)
#通过集合可以实现元素的去重操作 # 1.如果说去重之前和去重之后的数量是相等的，就说明每一个元素都是唯一的，控制台返回的结果就会是true # 2.如果说不相等，就说明列表中存在着重复的元素，控制台就会返回false list2 = ['a','b','a','d','e','f','g'] s1 = set(list2) print(len(list2) == len(s1))
例51 集合在实际开发中如何使用？
1.集合有哪些数学操作：交集 补集 并集 差集
s1 = {1,2,3,4,5}
s2 = {6,2,4,7,9}
s3 = {8,12,23,34}
#交集
#使用‘&’(与)连接多个集合
print(s1 & s2) #打印的是相同的元素
print(s1 & s3) #set()：没有相同的元素
#intersection方法
print(s1.intersection(s2)) #打印的是相同的元素
# 并集
# 使用‘|’（或）连接多个集合，自动去除掉相同的元素
print(s1 | s2)
print(s1.union(s2))
# 差集
# 使用‘-’连接多个集合，一个集合中去掉另外一个集合的元素
print(s1 - s2)
print(s1.difference(s2))
# 补集：对称差集 去掉两个集合中重复的元素之后剩下的元素
# 使用‘^’异或符号
print(s1 ^ s2)
print(s1.symmetric_difference(s2))
2. 如何判断访问的元素是否存在于集合中
# in 、not in方法
s4 = ('a','b','c','d','e','f',)
print('a'in s4)
print('a' not in s4)
3.添加元素，注意（添加列表时会出现错误，因为列表是可变的,在向集合中添加元素时，只能添加不可变的值，比如说字符串或者元组)
s5 = {'p','y','t','h','o'}
print(s5)
s5.add('n')
print(s5)
4.如何删除集合中的元素
# 1.pop方法：删除任意一个元素
s6 = {1,2,3,4,5}
print(s6)
s6.pop()
print(s6)
# 2.remove方法：删除指定元素
s6.remove(2)
print(s6)
# 3.clear方法：清空集合中所有元素
s6.clear()
print(s6)
二十一、运算符（优先级）
注意：比较运算符，逻辑运算符
比较运算符：使用比较运算符得出来的结果为我们的布尔类型，其结果只有真或者假两种结果
逻辑运算符：and （与）or（或）not（非）
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~3.12 第一节
# 问题一：
# age = 21
# if age >= 22 and age <= 35:
# print('满足条件，欢迎加入')
# else:
# print('不满足条件')
# 非运算
# if not (1 >= 2):
# print('条件成立，执行代码')
# 非零即True
# if 1:
# print('t')
944
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
