Python序列

已于 2023-05-05 22:29:40 修改
阅读量522 收藏 5
点赞数 1
分类专栏： python 文章标签： python 开发语言
于 2023-05-05 22:29:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33807380/article/details/130395287
版权

一、什么是序列

序列指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问。主要包括字符串、列表、元组、集合、字典，并且集合和字典不支持索引、切片、相加和相乘操作。

  1. 序列索引：在序列中，每个元素对应的位置编号。
str = "hello"
1.从左往右，序列的索引由0开始，依次递增
first = str[0]    	## 结果为'h'

2.从右往左，序列索引由-1依次递减
last = str[-1]		## 结果为'o'
  1. 序列切片：是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
语法格式：sname[start : end : step]
	sname：表示序列的名称；
	start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
	end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
	step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，如果省略设置 step 的值，则最后一个冒号就可以省略。
注意：
使用负数索引时，start 值依然是左边的索引，end 依然是右边的值
	
str = "hello world"
1.取索引区间为[0,3]之间（不包括索引3处的字符）的字符串
new_str = str[:3]    	## 结果为"hel",从0开始可以默认不写start参数
2.取索引区间为[3,7]之间（不包括索引7处的字符）的字符串
new_str = str[3:7]    	## 结果为"lo w"
3.取索引区间为[7,字符串结尾]之间的字符串
new_str = str[7:]    	## 结果为"orld"，取到结尾可以默认不写end参数
4.隔 1 个字符取一个字符，区间是整个字符串
new_str = str[::2] 		## 结果为"hlowrd"
5.取整个字符串，此时 [] 中只需一个冒号即可
new_str = str[:] 		## 结果为"hello world"
6.使用负数索引来截取一个新的字符串
new_str = str[-6:-1] 		## 结果为"lo worl"
  1. 序列相关的内置函数
    （1）len()：计算序列的长度；
    （2）max()：找出序列中的最大元素；
    （3）min()：找出序列中的最小元素；
    （4）list()：将序列转换为列表；
    （5）str()：将序列转换为字符串；
    （6）sum()：计算元素和；
    （7）sorted()：对元素进行排序；
    （8）reversed()：反向序列中的元素；
    （9）enumerate()：将序列组合为一个索引序列，多用在 for 循环中；

二、列表（list）

列表中可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。

  1. 列表的创建
    列表的数据结构由一对中括号 [ ] 包裹，[ ] 里面相邻元素之间用逗号,分隔开。
1.使用 [ ] 直接创建列表
nums = [1, 2, 3, 4, 5, 6, 7]
strs = ["您好", "world"]
others = [1, 2, 3.5, "您好", "world", [4, "hello"], (6, 7, 8.5)]

2.使用 list() 函数创建列表
## 创建空列表
list = list()
## 将字符串转换成列表
list1 = list("hello")
## 将元组转换成列表
tuple1 = ('您好', 'world', 'hello')
list2 = list(tuple1)
## 将字典转换成列表
dict1 = {'a':1, 'b':2, 'c':3}
list3 = list(dict1)
## 将区间转换成列表
range1 = range(1, 10)
list4 = list(range1)
  1. 访问列表元素
list = list("hello world")
1.使用索引访问列表中的某个元素
char1 = list[1]
char2 = list[-1]

2.使用切片访问列表中的一组元素
print(list[1: 5])  #使用正数切片
print(list[0: 7: 2])  #指定步长
print(list[-6: -1])  #使用负数切片
  1. 添加列表元素
1.使用+运算符将多个列表连接起来
list1 = ["hello", "world"]
list2 = ["您好", "世界"]
print(list1 + list2)    ## 结果为:['hello', 'world', '您好', '世界']

2.append()方法添加元素,该方法会在列表的末尾追加元素，追加的可以是单个元素，也可以是列表、元组等
lst = ['a', 'b', 'c']
lst.append('d')
lst.append(['e', 'h'])
lst.append(('i', 'j'))
print(lst)    ## 结果为:['a', 'b', 'c', 'd', ['e', 'h'], ('i', 'j')]

3.extend()方法添加元素,添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，
但不能是单个的数字。 append() 的不同之处在于：extend() 不会把列表或者元组视为一个整体，
而是把它们包含的元素逐个添加到列表中。
lst = ['a', 'b', 'c']
lst.extend('d')
lst.extend(['e', 'h'])
lst.extend(('i', 'j'))
print(lst)    ## 结果为:['a', 'b', 'c', 'd', 'e', 'h', 'i', 'j']

4.insert()方法插入元素,可以指定在列表中间某个位置插入元素，当插入列表或者元组时，
也会将它们视为一个整体插入到列表中。
lst = ['a', 'b', 'c']
lst.insert(1, 'd')
print(lst)    ## 结果为:['a', 'd', 'b', 'c']
lst.insert(2, ['e', 'h'])
print(lst)    ## 结果为:['a', 'd', ['e', 'h'], 'b', 'c']
lst.insert(3, ('i', 'j'))
print(lst)    ## 结果为:['a', 'd', ['e', 'h'], ('i', 'j'), 'b', 'c']
  1. 修改列表元素
1.修改单个元素非常简单，直接对元素赋值即可
nums = [1, 2, 3, 4, 5, 6, 7]
nums[2] = -2  
nums[-3] = -9
print(nums)    ## 结果为：[1, 2, -2, 4, -9, 6, 7]

2.通过切片语法给一组元素赋值，不指定步长时，新赋值的元素个数与原来的元素个数可以不同，
如果新赋值的元素个数少于原来的元素个数，则新的列表长度也会减小
nums = [1, 2, 3, 4, 5, 6, 7]
nums[1: 4] = [-2, -3, -4]   		## 个数相同时结果为：[1, -2, -3, -4, 5, 6, 7]
nums[1: 4] = [-2, -3]				## 个数小于时结果为：[1, -2, -3, 5, 6, 7]
nums[1: 4] = [-2, -3, -4, -5, -7]	## 个数大于时结果为：[1, -2, -3, -4, -5, -7, 5, 6, 7]

3.通过切片语法给一组元素赋值，指定步长时，新元素的个数必须与原有元素的个数相同，多了或者少了都会报错
nums = [1, 2, 3, 4, 5, 6, 7]
nums[1:6:2] = [-2, -3, -4]          ## 结果为：[1, -2, 3, -3, 5, -4, 7]

4.使用切片语法给一组元素赋值时，只包含单个元素的话，新元素也的是数组的形式，不能是单个值
nums[2:2] = [-2]
nums[2:2] = []
nums[2:2] = [-2, -3]
nums[2:2] = -2   ## 错误写法
  1. 查找列表元素
nums = [1, 2, 3, 4, 5, 6, 2, 8, 9]
1.从整个列表中检索值为2的索引，存在多个相同的值以最左边的结果为准
print(nums.index(2))   			## 结果为1
2.从索引区间4~7之间检索值为2的索引
print(nums.index(2, 4,7))    	## 结果为6
3.从索引位置4之后检索值为2的索引
print(nums.index(2, 4))   		## 结果为6
  1. 统计列表元素
nums = [1, 6, 3, 4, 3, 6, 2, 8, 6]
print(nums.count(6))  		## 结果为3

三、元组（tuple）

元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同。

  1. 元组的创建
    元组的数据结构由一对小括号( )包裹，( )里面元素用逗号,分隔开。
1.常见的元组创建方式
nums = (1, 2, 3, 4, 5, 6, 7)
strs = ("您好", "world")
others = (1, 2, 3.5, "您好", "world", [4, "hello"], (6, 7, 8.5))

2.省略()创建元组，只要将各元素用逗号隔开，也会将其视为元组
strs = "您好", "world"

3.当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号，否则解释器会将它视为字符串
strs = ("您好",)

4.使用tuple()函数创建元组
## 创建空元组
tup = tuple()
## 将字符串转换成元组
tup = tuple("hello")
## 将列表转换成元组
list1 = ['您好', 'world', 'hello']
tup = tuple(list1 )
## 将字典转换成列表
dict1 = {'a':1, 'b':2, 'c':3}
tup = tuple(dict1)
## 将区间转换成列表
range1 = range(1, 10)
tup = tuple(range1)
  1. 访问元组
1.使用索引访问元组中的某个元素
tup = tuple("hello")
print(tup[3]) 
print(tup[-2])  

2.使用切片访问元组中的一组元素
print(tup[1: 3])  #使用正数切片
print(tup[0: 4: 2])  #指定步长
print(tup[-3: -1])  #使用负数切片
  1. 修改元组
1.元组是不可变序列，元组中的元素不能被修改，只能创建一个新的元组去替代旧的元组
tup = (1, 2, -3, 4)
tup = (a, d, c, d)
print(tup)

2.使用+拼接元组
tup1 = (1, 2, -3, 4)
tup2 = (a, d, c, d)
print(tup1 + tup2)
  1. 删除元组
tup = (a, d, c, d)
del tup

四、字典（dict）

字典（dict）是一种无序的、可变的序列，它的元素以键值对（key-value）的形式存储，相当于 Java 或者 C++ 中的 Map 集合。字典的主要特征有以下几点：
（1）通过键（key）来读取元素，而不是通过索引。
（2）字典中的元素是无序的，而列表（list）和元组（tuple）都是有序的序列。
（3）字典中的键（key）可以是整数、字符串或者元组，只要保证唯一且不可变就行，不能是列表。
（4）字典的值（value）可以是 Python 支持的任意数据类型。
（5）整个字典是可变的，并且可以任意嵌套 。

  1. 字典的创建
    字典的数据结构是由一对{}包裹，{}中由多个键（key）和值（value）键值对组成，相邻键值对用,隔开，键和值之间使用冒号:分隔开。
1.使用字符串作为key创建字典
ages = {'xiaoming': 15, 'xiaohong': 18, 'xiaojiang': 20}

2.使用元组作为key创建字典
dict = {(1, 2, 3): '数字', ('a', 'b', 'c'): '英文', ('你好', '啊', '哈哈'): '汉字'}

3.使用数组作为key创建字典
dict1 = {1: '一', 2: '二', 3: '三'}

4.通过 fromkeys() 方法创建字典，通常用于初始化字典，设置 value 的默认值
name = ['xiaoming', 'xiaohong', 'xiaojiang']
ages = dict.fromkeys(name, 18)    ## 结果为：{'xiaoming': 18, 'xiaohong': 18, 'xiaojiang': 18}

5.通过 dict() 映射函数创建字典
# 创建一个空字典
dict1 = dict()

# key只能为字符串且不能带引号，value可以是任意值
dict1 = dict(name='xiaoming', age=18, 学科=('语文', '数学')) 
print(dict1)    ## 结果为：{'name': 'xiaoming', 'age': 18, '学科': ('语文', '数学')}

# 向 dict() 函数传入包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值
#方式1
list = [('two',2), ('one',1), ('three',3)]
#方式2
list = [['two',2], ['one',1], ['three',3]]
print(dict(list))    ## 结果为：{'two': 2, 'one': 1, 'three': 3}
#方式3
tup = (('two',2), ('one',1), ('three',3))
#方式4
tup = (['two',2], ['one',1], ['three',3])
print(dict(tup)) 	## 结果为：{'two': 2, 'one': 1, 'three': 3}

# 通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典
keys = ['one', 'two', 'three'] 	#还可以是字符串或元组
values = [1, 2, 3] 	#还可以是字符串或元组
dict1 = dict( zip(keys, values) )
print(dict1)
  1. 字典的访问
dic = dict(name='xiaoming', age=18, 学科=('语文', '数学')) 
1.通过[key]获取字典对应的value，当key不存在时会报错
print(dic['name'])   	## 结果为：xiaoming

2.通过get() 方法来获取字典对应的value，当key不存在时空值 None，也可以手动设置 get() 的第二个参数默认返回值
print(dic.get('age'))	## 结果为：xiaoming
print(dic.get('sex', 'key不存在'))	## 结果为：key不存在
  1. 字典的删除
dic = dict(name='xiaoming', age=18, 学科=('语文', '数学')) 
del dic
  1. 字典基本操作
dic = dict()
1.往字典中添加键值对
dic['name'] = 'xiaoming'
print(dic)   	## 结果为：{'name': 'xiaoming'}
dic[1] = 2		
print(dic)		## 结果为：{'name': 'xiaoming', 1: 2}
dic[(1,2,3)] = [4,5,6]
print(dic)		## 结果为：{'name': 'xiaoming', 1: 2, (1, 2, 3): [4, 5, 6]}

2.修改键值对
dic = {'数学': 95, '语文': 89, '英语': 90}
dic['数学'] = 100   ## key存在则会修改key对应的原value
dic['物理'] = 60	## key不存在则会新增一个键值对

3.删除键值对
dic = {'数学': 95, '语文': 89, '英语': 90}
del dic['数学']		## key存在则会删除对应的键值对
del dic['化学']		## key不存在则会报错

4.使用 in 或 not in 运算符判断key是否存在
dic = {'数学': 95, '语文': 89, '英语': 90}
print('数学' in dic) 		# True
print('物理' not in dic) 	# True

5.keys()、values() 和 items() 方法
dic = {'数学': 95, '语文': 89, '英语': 90}
print(dic.keys())				## dict_keys(['数学', '语文', '英语'])
print(dic.values())				## dict_values([95, 89, 90])
print(dic.items())				## dict_items([('数学', 95), ('语文', 89), ('英语', 90)])
# 使用 list() 函数，将上面返回的数据转换成列表
print(list(dic.keys()))			## ['数学', '语文', '英语']
print(list(dic.values()))		## [95, 89, 90]
print(list(dic.items()))		## [('数学', 95), ('语文', 89), ('英语', 90)]

6.copy() 方法返回一个字典的拷贝
# copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝，copy() 方法只会对最表层的键值对进行深拷贝，
# 而对于某些列表类型的值来说，此方法对其做的是浅拷贝
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)	## {'one': 1, 'two': 2, 'three': [1, 2, 3]}
## b字典中的'one': 1, 'two': 2是进行的深拷贝，会再申请一块内存用来存放这些数据，
## b字典中的'three': [1, 2, 3]则是进行的浅拷贝，不会再申请内存来存放[1, 2, 3]列表数据，而是和 a 共用同一块内存中的数据
## 如果再进行移除a字典中列表中的第一个元素，则b中的列表数据也会跟着移除
a['three'].remove(1)
print(a)		## {'one': 1, 'two': 2, 'three': [2, 3]}
print(b)		## {'one': 1, 'two': 2, 'three': [2, 3]}

7.update() 方法更新字典中的键值对，如果key已存在会覆盖掉原value，不存在则会添加到字典中
a = {'one': 1, 'two': 2, 'three': 3}
a.update({'one':5, 'four': 4})
print(a)		## {'one': 5, 'two': 2, 'three': 3, 'four': 4}

8.pop() 和 popitem() 方法，pop() 用来删除指定的键值对， popitem() 用来删除字典最右边的键值对
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
a.pop('one')
print(a)		## {'two': 2, 'three': [1, 2, 3]}
a.popitem()
print(a)		## {'two': 2}

9.setdefault() 方法返回某个 key 对应的 value，如果该 key 存在，那么直接返回该 key 对应的实际 value，
如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)		## {'数学': 95, '语文': 89, '英语': 90}
# key不存在，指定默认值
a.setdefault('物理', 94)
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94}
# key不存在，不指定默认值
a.setdefault('化学')		
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}
# key不存在，定默认值
a.setdefault('生物', 88)
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None, '生物': 88}
# key存在，指定默认值
a.setdefault('数学', 100)
print(a)		## {'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None, '生物': 88}

五、集合（set）

集合用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。

  1. 集合的创建
    集合的数据结构是由一对大括号 {}包裹， {}里面相邻元素之间用,隔开
1.使用 {} 创建集合
set1 = {1, 2.0, "hello", (1, 2, 3), 'a'}

2.set()函数创建集合
# 将字符串转化成集合，若存在相同的字符只会保存一个
set1 = set("hello")			## {'o', 'h', 'l', 'e'}
print(set1)
# 将列表转化成集合
set2 = set([1,2,3,4,5])		## {1, 2, 3, 4, 5}
print(set2 )
# 将元组转化成集合
set3 = set((1,2,3,4,5))
print(set3 )				## {1, 2, 3, 4, 5}

3.创建空集合
# 只能使用 set() 函数实现,因为直接使用一对 {}，Python 解释器会将其视为一个空字典
set1 = set()
  1. 集合的访问
    由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。
set1 = {1, 2.0, "hello", (1, 2, 3), 'a'}
for a in set1:
    print(a,end=' ')
  1. 集合的删除
set1 = {1, 2.0, "hello", (1, 2, 3), 'a'}
del(set1)
  1. 集合基本操作
1.add() 向 set 集合中添加元素
a = {1,2,3}
# 只能是数字、字符串、元组或者布尔类型（True 和 False）值,不能添加可变类型的数据
a.add((1,2))

2.remove() 从set集合中删除元素
a = {1,2,3}
a.remove(1)
# 如果被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误
a.remove(4)

3.set集合做交集、并集、差集运算
set1 = {1,2,3} 
set2 = {3,4,5}
# 交集运算符 & 取两集合公共的元素 
set1 & set2				## {3}

# 并集运算符 | 取两集合全部的元素
set1 | set2				## {1,2,3,4,5}

# 差集运算符 - 取一个集合中另一集合没有的元素
set1 - set2				## {1,2}
set2 - set1				## {4,5}

# 对称差集运算符 ^ 取两个集合中不公有的元素
set1 ^ set2				## {1,2,4,5}
  1. frozenset
    set 集合是可变序列，frozenset 集合是不可变序列。set 集合中所有能改变集合本身的方法，比如 remove()、discard()、add() 等，frozenset 都不支持；set 集合中不改变集合本身的方法，fronzenset 都支持。
1.创建frozenset
fset = frozenset(['hello', 'world'])

2.往set集合中添加frozenset集合
set = {1, 2, 3}
set.add(fset)
FearlessVoyager
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 序列
12-21
目录  python 序列简介  python 序列图表  列表与列表推导式 列表的创建与删除 创建列表 删除列表 列表常用方法 （1）append()、insert...Python序列类似于其他语言中的数组，但功能要强大很多。 Python中常用的序
Python序列结构实验报告.doc
12-19
Python序列结构
Python--序列
墨上烟雨
06-16 1092
一、定义。
Python数据类型——序列 ，近期有面试的必看
最新发布
2401_84002730的博客
04-01 859
假设需要访问序列的最后 3 个元素，我们当然可以像下面这样做：[4, 5, 6]有没有更简洁的方法呢？想到可以使用负数形式的索引，你可能会尝试这样做：numbers[-3:-1] # 实际取出的是 numbers[-3], numbers[-2][4, 5]numbers[-3:0] # 左边索引的元素比右边索引出现得晚，返回空序列[]上面的两种使用方式并不能正确获取序列的最后 3 个元素，
第四章 Python 的四种典型序列结构
hhcyyds的博客
06-11 1852
序列 = 元素 + 对应元素的索引 序列中的每一个元素都有其对应的索引。如果说，序列是一个大酒店，那么元素就是房间，索引值就是房号号。常见的序列有：字符串、列表、元组、字典、集合。
Python序列类型详解
永远是少年
11-25 8140
今天继续给大家介绍Python相关知识，本文主要内容是Python序列类型 一、序列类型定义 二、序列类型通用操作符 三、序列类型通用处理函数及方法 四、序列类型使用示例
Python——序列_列表
二哈喇子！
10-28 4567
Python——序列
python序列类型种类详解
09-17
主要介绍了python序列类型种类详解，需要的朋友们可以学习参考下。
Python 序列的方法总结
12-25
最近在做Python 的项目，特地整理了下 Python 序列的方法。序列sequence是python中最基本的数据结构，本文先对序列做一个简单的概括，之后简单讲解下所有序列都能通用的操作方法。 任何序列都可以引用其中的元素...
Python的序列
精益求精，永无止境，永远在路上！
04-04 3585
在Python中，序列结构主要有序列、元组、集合、字典和字符串。对于这些序列通用操作。
【python学习笔记】序列
weixin_38500144的博客
05-15 845
编程时基本上所有情况都可以用列表来代替元组，有一种例外是：将元组用作字典键，这种情况下不能用列表来代替元组，因为字典是不允许修改的。在于：列表是可以修改的，而元组不可以，这意味着列表适用于需要中途添加元素的情形，而元组适用于需要禁止修改序列的情形。满足时返回Ture，不满足返回False，这样的运算符叫做"布尔运算符"，而Ture和False叫做“布尔值”。序列中每个元素都有编号，即其位置或索引，第一个元素的索引为0，第二个索引为1，以此类推。，用于对序列中的每个元素都执行特定的操作，讲循环的时候再说。
Python——— 序列&列表
qq_63976098的博客
07-04 1270
Python 序列&列表
【大数据开发】Python基础——Python序列
白色风车
07-16 342
文章目录三、序列3.1列表3.2 切片3.3 通用操作 -- len、min、max、index、count3.4 修改元素 -- 增删改查、list3.5 列表的方法 -- append、insert、extend、clear、pop、remove、reverse、sort3.6 遍历列表 -- while、for-in3.7 EMS练习3.8 range函数的使用及遍历3.9 元组 -- 创建、解包3.10 可变对象 -- is / not is和== / !=的区别3.11 字典3.12 字典的使用
python中的序列——笔记
XD的博客
02-28 1093
ABC语言时一个致力于为初学者设计编程环境的长达十年的研究项目。Python也从ABC那里继承了用统一的风格去处理序列数据这一特点。不管是哪种数据结构，字符串、列表、字节序列、数组、XML元素，抑或是数据库查询结果，它们都共用一套丰富的操作：迭代、切片、排序，还有拼接。在切片和区间操作里不包含区间范围的最后一个元素是Python的风格，这个习惯符合Python、C和其他语言里以0作为起始下标的传统。这样做带来的好处如下。
5.Python 常见的序列
小发菜
11-13 306
认识常见的序列，以及序列的基本操作。
python序列
m0_72454242的博客
08-05 480
python序列知识
Python序列解包
12-14
Python序列解包是一种快速解包序列或元组的方法，将序列或元组中的每个元素分配给变量。以下是一些例子： 1. 解包列表 ```python fruits = ['apple', 'banana', 'cherry'] a, b, c = fruits print(a) # 输出：'apple' print(b) # 输出：'banana' print(c) # 输出：'cherry' ``` 2. 解包元组 ```python fruits = ('apple', 'banana', 'cherry') a, b, c = fruits print(a) # 输出：'apple' print(b) # 输出：'banana' print(c) # 输出：'cherry' ``` 3. 解包字典 ```python dicts = {'a': 'x', 'b': 1, 'c': 3} a, b, c = dicts.values() print(a) # 输出：'x' print(b) # 输出：1 print(c) # 输出：3 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值