python 序列总结

大概火车

已于 2024-01-12 17:05:43 修改

阅读量1.3k

点赞数 27

文章标签： python 开发语言

于 2023-12-25 20:03:44 首次发布

本文链接：https://blog.csdn.net/2301_81067195/article/details/135206992

版权

序列：包括列表、元组、字符串、集合和字典

1.序列切片

序列切片	元素	说明
sequence[start:end:step]	sequence	表示序列的名称(列表、元组等)。
	statr	表示切片开始的位置(包括该位置)。不填默认值为切片起始的位置（如果是正序，那就是0，如果是负序，那就是-1）。
	end	表示切片结束的位置(不包括该位置)。不填默认值为序列的长度（如果是正序，那就是正的序列长度，如果是负序，那就是负的序列长度-1）。
	step	表示切片的步长。不填默认为1。

# 序列切片(以字符串举例子)
str1 = "我是大概火车"
print(str1[:])
"输出结果：我是大概火车"
print(str1[2:6])
"输出结果：大概火车"
print(str1[-1::-1])
"输出结果：车火概大是我"

# 注意事项：
# 1.第一个冒号不能省略不写，第二个冒号可以省略不写。
# 2.填写start和end的时候不能超出序列的下标。
# 3.使用负数索引的时候，一定要把切片的步长设置为负数，不然是从左到右进行访问。
# 4.序列切片只能给列表、元组和字符串使用，不能给集合和字典使用

2.序列的相加和数乘

	说明	功能
序列的相加
sequence * sequence	sequence：序列序列进行相加，只能类型相同（列表与列表、元组与元组、字符串和字符串）的进行相加	会起到拼接的效果
序列的数乘
sequence * number	sequence: 序列 number：数字序列进行数乘法，只能序列和数字进行相乘	会起到拼接的效果

# 相加、相乘(以列表和字符串为例)
# 1.列表
list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]
print(list1 + list2)
"输出结果：[1, 2, 3, 4, 5, 6, 7, 8]"
print(list1 * 2)
"输出结果：[1, 2, 3, 4, 1, 2, 3, 4]"
print(list2 * 2)
"输出结果：[5, 6, 7, 8, 5, 6, 7, 8]"

# 2.字符串
str1 = "我是"
str2 = "大概火车"
print(str1 + str2)
"输出结果：我是大概火车"
print(str1 * 2)
"输出结果：我是我是"
print(str2 * 2)
"输出结果：大概火车大概火车"

# 注意事项：
# 1.只有列表、元组和字符串能够进行相加、相乘的操作，集合和字典不可以

3.检查元素是否在序列中

格式	说明	功能
value in sequence	value：要判断的值	判断该值是否在序列中，返回值为bool值
	in：关键字
	sequence：序列

# 检查元素是否在序列中(以字符串和字典举例)
str1 = "大概火车"
print("大" in str1)
"输出结果：True"
print("我" in str1)
"输出结果：False"

dict1 = {"1": 1}
print(1 in dict1)
"输出结果：False"
print("1" in dict1)
"输出结果：True"

# 注意事项：
# 1.返回值为bool值，也就是True或者False
# 2.序列中的列表、元组、字符串、集合和字典都可以检查元素是否在序列当中
# 3.查找元素是否在字典中时，只能查找key关键字，无法查找value值

4.序列的函数（共11种）

函数名	说明	功能
len()	无	返回序列中元素的个数。
max()	max()对字符串的时候，会返回字符串中在字典次序最大的值。	返回序列中元素的最大值。
min()	min()对字符串的时候，会返回字符串中在字典次序最小的值。	返回序列中元素的最小值。
sum()	sum()只能用于列表、元组和集合，不能用于字符串和字典，且只能用于数字。	返回序列中元素的和。
list()	list()对字典的时候，会返回字典的key值，不会返回value值,且会生成新的列表，不会改变原有的序列。	将序列转化为列表。
tuple()	tuple()对字典的时候，会返回字典的key值，不会返回value值,且会生成新的元组，不会改变原有的序列。	将序列转换为元组。
str()	str()对序列的时候，只会改变其类型，不会加上双引号，且会生成新的字符串，不会改变原有的序列。	将序列转化为字符串。
set()	set()对字典的时候，会返回字典的key值，不会返回value值，且会生成新的集合，不会改变原有的序列。	将序列转化成集合。
sorted()	sorted()对字符串的时候，其排序会按照字典的顺序从小到大排。sorted()对字典的时候，只会返回key值，不会返回value值。且会生成新的列表，不会改变原有的序列。	将序列中的元素进行排序。
reversed()	reversed()只能对列表、元组、字符串和字典使用，且对字典时只返回key值，不会返回value值。其返回值是反向迭代器，需要转换成其他类型才能输出。	将序列中的元素反向。
enumerate()	enumerate()的返回值是枚举对象，也是迭代器，需要转换成其他类型才能输出。每个元组都包含着元素下标和元素值。	将序列的索引和元素组合成元组。

（1）len()函数

# len()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(len(list1))
"输出结果：4"
print(len(tuple1))
"输出结果：4"
print(len(str1))
"输出结果：4"
print(len(set1))
"输出结果：4"
print(len(dict1))
"输出结果：2"

（2）max()函数

# max()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(max(list1))
"输出结果：4"
print(max(tuple1))
"输出结果：5"
print(max(str1))
"输出结果：车"
print(max(set1))
"输出结果：11"
print(max(dict1))
"输出结果：3"

（3）min()函数

# min()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(min(list1))
"输出结果：2"
print(min(tuple1))
"输出结果：2"
print(min(str1))
"输出结果：大"
print(min(set1))
"输出结果：2"
print(min(dict1))
"输出结果：2"

（4）sum()函数

# sum()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(sum(list1))
"输出结果：12"
print(sum(tuple1))
"输出结果：14"
print(sum(str1))
"报错"
print(sum(set1))
"输出结果：20"
print(sum(dict1))
"报错"

（5）list()函数

# list()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(list(list1))
"输出结果：[4, 2, 3, 3]"
print(list(tuple1))
"输出结果：[5, 2, 3, 4]"
print(list(str1))
"输出结果：['大', '概', '火', '车']"
print(list(set1))
"输出结果：[11, 2, 3, 4]"
print(list(dict1))
"输出结果：['2', '3']"

（6）tuple()函数

# tuple()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(tuple(list1))
"输出结果：(4, 2, 3, 3)"
print(tuple(tuple1))
"输出结果：(5, 2, 3, 4)"
print(tuple(str1))
"输出结果：('大', '概', '火', '车')"
print(tuple(set1))
"输出结果：(11, 2, 3, 4)"
print(tuple(dict1))
"输出结果：('2', '3')"

（7）str()函数

# str()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(str(list1))
"输出结果：[4, 2, 3, 3]"
print(str(tuple1))
"输出结果：(5, 2, 3, 4)"
print(str(str1))
"输出结果：大概火车"
print(str(set1))
"输出结果：{11, 2, 3, 4}"
print(str(dict1))
"输出结果：{'2': 122, '3': 2}"

（8）set()函数

list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(set(list1))
"输出结果：{2, 3, 4}"
print(set(tuple1))
"输出结果：{2, 3, 4, 5}"
print(set(str1))
"输出结果：{2, 3, 4}"
print(set(set1))
"输出结果：{11, 2, 3, 4}"
print(set(dict1))
"输出结果：{'2', '3'}"

（9）sorted()函数

# sorted()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(sorted(list1))
"输出结果：[2, 3, 3, 4]"
print(sorted(tuple1))
"输出结果：[2, 3, 4, 5]"
print(sorted(str1))
"输出结果：['大', '概', '火', '车']"
print(sorted(set1))
"输出结果：[2, 3, 4, 11]"
print(sorted(dict1))
"输出结果：['2', '3']"

（10）reversed()函数

# reversed()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(list(reversed(list1)))
"输出结果：[3, 3, 2, 4]"
print(list(reversed(tuple1)))
"输出结果：[4, 3, 2, 5]"
print(list(reversed(str1)))
"输出结果：['车', '火', '概', '大']"
print(list(reversed(set1)))
"报错"
print(list(reversed(dict1)))
"输出结果：['3', '2']"

（11）enumerate()函数

# enumerate()函数
list1 = [4, 2, 3, 3]
tuple1 = (5, 2, 3, 4)
str1 = "大概火车"
set1 = {11, 2, 3, 4}
dict1 = {"2": 122, "3": 2}
print(list(enumerate(list1)))
"输出结果：[(0, 4), (1, 2), (2, 3), (3, 3)]"
print(list(enumerate(tuple1)))
"输出结果：[(0, 5), (1, 2), (2, 3), (3, 4)]"
print(list(enumerate(str1)))
"输出结果：[(0, '大'), (1, '概'), (2, '火'), (3, '车')]"
print(list(enumerate(set1)))
"输出结果：[(0, 11), (1, 2), (2, 3), (3, 4)]"
print(list(enumerate(dict1)))
"输出结果：[(0, '2'), (1, '3')]"