python的五大数据容器——字符串、列表、元组、集合、字典

原创 已于 2026-03-18 15:18:17 修改 · 367 阅读 · 9 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#python #开发语言
于 2026-03-17 14:12:46 首次发布
Python3.8

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

字符串

定义：字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可

字符串的定义

可以使用单引号、双引号、三引号来定义
类如：name = "tom"

如果字符串中有单引号、双引号、或既有单引号又有双引号
a、使用 \ 将引号进行转义
b、字符串中有 单引号 外边使用 双引号
字符串中有 双引号 外边使用 单引号
字符串中有 既有单引号又有双引号 外边使用 三引号

s1 = '\'张三\'是一家上市公司的员工'
s2 = "'张三'是一家上市公司的员工"
s3 = """'张三\'是一家"上市公司"的员工"""
print(f"{s1}\n{s2}\n{s3}")
#输出
"""
'张三'是一家上市公司的员工
'张三'是一家上市公司的员工
'张三'是一家"上市公司"的员工
"""

字符串的查看方法

【常用】str[]:通过索引查看对应位置

基本方法：

str[index] # str：字符串名称，index：索引
str[start_index:end_index:step]  #start_index：开始位置索引，end_index：结束位置索引，step：步长(类似与for循环中range中的第三个参数)

注意：
[ ]中索引的取值时左开右闭
索引是从0开始的，[0,1,2,3…]
索引、步长可以为负数，索引为负数从后边开始数，步长为负：反着遍历
字符串是不可变数据类型，更改后会生成一个新的字符串，原来的不变
示例：

str_test = 'afrgvag'
# 输出第一个字符，索引为0
print(str_test[0])
# 输出第4个字符，索引为5
print(str_test[5])
# 输出倒数第三个字符
print(str_test[-3]) 
# 输出索引为1-6的，字符串的1-5的元素
print(str_test[1:6])  # 输出：frgva
# 输出索引以此为6,5,4,3,2的元素
print(str_test[6:1:-1])  # 输出：gavgr
# 反转字符串
print(str_test[::-1]) # 输出:gavgrfa
【熟悉】find()
作用：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1（只匹配第一个）

基本语法：

字符串.find(要查找的字符或者子串)

示例代码：
注意：区分大小写

str_test = 'Hello,I am Jason,How can i call you?'
# 从上边字符串中查看是否存在Jason,存在则这个子串开始的位置下标，否则则返回-1
print(f'find_Jason: {str_test.find("Jason")}')  # 输出：find_Jason: 11
# 从上边字符串中查看是否存在Tom,存在则这个子串开始的位置下标，否则则返回-1
print(f'find_Tom: {str_test.find("Tom")}')  # 输出：find_Tom: -1
# 从上边字符串中查看是否存在J,存在则这个子串开始的位置下标，否则则返回-1
print(f'find_J:{str_test.find("J")}')   # 输出：find_J:11
# 从上边字符串中查看是否存在j,存在则这个子串开始的位置下标，否则则返回-1
print(f'find_j:{str_test.find("j")}')  # 输出：find_j:-1
【熟悉】index()
作用：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。（只匹配第一个）

基本方法：

字符串.index(要查找的字符或者子串)

示例：

str_test = 'Hello,I am Jason,How can i call you?'
# 从上边字符串中查看是否存在Jason,存在则这个子串开始的位置下标，否则则报错
print(f'index_Jason: {str_test.index("Jason")}')   # 输出：
# 从上边字符串中查看是否存在Jason,存在则这个子串开始的位置下标，否则则报错
print(f'index_Tom: {str_test.index("Tom")}')  # 输出：报错异常ValueError: substring not found
# 从上边字符串中查看是否存在Jason,存在则这个子串开始的位置下标，否则则报错
print(f'index_J: {str_test.index("J")}')   # 输出：index_Jason: 11
# 从上边字符串中查看是否存在Jason,存在则这个子串开始的位置下标，否则则报错
print(f'index_j: {str_test.index("j")}')  # 输出：报错异常ValueError: substring not found

字符串的修改方法

【熟悉使用】replace()
作用：有指定字符串，替换字符串中指定字串，返回替换后的字符串

基本方法：

字符串.replace(要替换的内容, 替换后的内容, 替换的次数-可以省略)
#替换次数不写，默认匹配全部

示例：

str_photo = "avatar.png"
print(f'{str_photo.replace("png","jpg")}')  #输出：avatar.jpg
【熟悉使用】split()
作用：对字符串按照 指定分隔符 进行切割操作，**返回一个list()列表**类型的数据
基本语法：
要进行分割的对象.split("分隔符(需前边要分割对象中包含的)")
输入值
字符串
返回值
列表

示例：

str2 = 'apple-banana-orange'
str2_split = str2.split("-")
print(str2_split) # 输出：['apple', 'banana', 'orange']
【了解】title()
作用：将所有单词首字母大写，其余字母转换为小写

基本语法：

字符串.title()

示例：

str_join = "apPle baNana orange"
print(str_join.title())  #输出：Apple Banana Orange
【常用】join()
作用：和split()方法正好相反，主要功能是 接受一个可迭代对象作为参数，并将其中的元素用前边指定的连接符连接起来
基本语法：
"连接符".join(可迭代对象)
输入值
可迭代对象：列表，元组等
返回值
字符串

示例：

str2 = 'apple-banana-orange'
str2_split = str2.split("-")
print(str2_split)
print(" ".join(str2_split))  # 输出：apple banana orange(指定的连接符是空格)

其它的操作

#str1 = " How are You?"

操作名称基本方法功能示例
len()len(字符串)计算字符串的长度len(str1) #输出：13
strip()字符串.strip(“要去除字符”)去除字符串前后的指定字符，默认去除空格str1.strip() #输出:How are You?
upper()字符串.upper()转换字符串中的小写字母为大写str1.upper() #输出： HOW ARE YOU?
lower()字符串.lower()转换字符串中的大写字母为小写str1.lower() #输出： how are you?

列表

定义：打了激素的数组，可以存储多个不同类型的变量。在其他的编程语言中，如Java、PHP、Go等等中其被称之为数组

与数组区别：数组存储相同类型数据，列表可以是不同类型

定义一个列表：

列表序列名称 = [列表中的元素1, 列表中的元素2, 列表中的元素3, ...]
列表名称 = [] #定义一个空列表
注意: 列表是可变的

示例：

list1 = []
list2 = ["apple","orange"]
print(type(list1))  # 输出：<class 'list'>
print(type(list2))  # 输出：<class 'list'>

列表的查

函数作用基本方法示例
list[start_index:end_index:step]获取对应索引的数据list[start_index:end_index:step]list1[1:5:2]
count()统计指定数据在当前列表中出现的次数列表名.count(“要查找的字符或者子串”)list1.count(“apple”)
not in判断指定数据在某个列表序列，如果在返回True，否则返回Falseif “字符串” not in 列表名称:(在if语句中使用)if “ollama” in list1:
index()指定数据所在位置的下标，从左到右第一个list.index(“要查找的字符或者子串”)list1.index(“apple”)

代码示例：

list1 = ['python','java','hello','world','python','ollama','hello','python']

print(f"python 出现的次数是：{list1.count("python")}")
print(f"world 出现的索引是：{list1.index("world")}")

if "ollama" in list1:
    print(f"ollama 出现的索引是：{list1.index("ollama")}")
else:
    print("ollama 不存在")

if "streamlimt" not in list1:
    print("streamlimt 不存在")
else:
    print(f"streamlimt 出现的索引是：{list1.index("streamlimt")}")

#输出：
"""
python 出现的次数是：3
world 出现的索引是：3
ollama 出现的索引是：5
streamlimt 不存在
"""

列表的增

函数作用基本方法示例
append()增加指定数据到列表中列表名.append(“要添加的”)list1.append(“apple”)
extend()列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表列表名.extend(“要添加的”)list1.extend(list2)
insert()指定位置新增数据列表名.insert(index,“要添加的”)list1.insert(1,“peach”)

注意点：
append 添加元组、列表等迭代器时，会将其作为一个整体，添加到列表最后；
extend 会将其中元素注意添加到列表

list1 = ["apple", "orange", "peach", "grape"]
tuple1 = ("pear", "banana")
list1.append(tuple1)
print(list1) # result:['apple', 'orange', 'peach', 'grape', ('pear', 'banana')]
tuple2 = ("mango", "watermelon")
list1.extend(tuple2)
print(list1)  # result:['apple', 'orange', 'peach', 'grape', ('pear', 'banana'), 'mango', 'watermelon']

示例代码：

list1 = ['张三', '李四', '王五']

# 增加的API:
# append(): 追加元素到列表中   添加 赵六 到尾部
list1.append("赵六")
print(list1)

# extend(): 将一个列表中元素 直接追加到另一个列表中
list2 = ['田七', '周八']
# 将list2中元素 追加到list1中
list1.extend(list2)
print(list1)


# insert(): 在指定的位置新增元素
# 请在索引0的位置中, 添加一个 老张
list1.insert(0,"老张")
print(list1)
#输出
"""
['张三', '李四', '王五', '赵六']
['张三', '李四', '王五', '赵六', '田七', '周八']
['老张', '张三', '李四', '王五', '赵六', '田七', '周八']
"""

列表的删

函数作用基本方法示例
del 列表[索引]删除列表中的某个指定索引的元素del 列表名[索引]del list1[3]
pop()删除指定下标的数据(默认为最后一个)，并返回该数据列表名.pop(索引)list1.pop()
remove()移除列表中某个数据的第一个匹配项。列表名.remove(变量名)list1.remove(“李四”)

示例代码：

# 删除操作:
# del 列表[索引] :  删除列表中指定索引的元素
# 删除 索引为 3的元素
del list1[3]
print(list1)

# pop(): 删除列表中指定索引的元素,默认为最后一个 并且会将删除了那个元素返回
# 删除第一个元素
num_pop = list1.pop(0)
print(list1)
print(f"num_pop:{num_pop}")

# 删除最后一个元素
list1.pop()
print(list1)


# remove(): 根据元素的内容 来删除
# 删除 李四这个元素
list1.remove("李四")
print(list1)

#输出：
"""
['老张', '张三', '李四', '赵六', '田七', '周八']
['张三', '李四', '赵六', '田七', '周八']
num_pop:老张
['张三', '李四', '赵六', '田七']
['张三', '赵六', '田七']
"""

列表的改

函数作用基本方法示例
列表[索引] = 修改后的值修改列表中的某个元素列表名[索引] = 修改后的值list1[2] = “小田”
reverse()将数据序列进行倒叙排列列表名.reverse()list1.reverse()
sort()对列表序列进行排序，默认为升序，reverse = False列表名.sort(), 列表名.sort(reverse = True),list3.sort()，list3.sort(reverse = True)

示例代码：

# 修改操作
# 列表[索引] = 修改后的值    : 修改指定索引的元素值
# 将田七修改为小田
print(f"田七的索引：{list1.index("田七")}")
list1[list1.index("田七")] = "小田"
print(list1)

# reverse(): 对列表进行反转
list1.reverse()
print(list1)

# sort(): 排序  默认从小到大排序  如果要从大到小排序, 可以添加  reverse=True  默认为 False
list3 = [3, 5, 1, 8, 13, 15, 12]
# 尝试从小到大 和 从大到小排序
list3.sort()
print(list3)
list3.sort(reverse = True)
print(list3)

#输出：
"""
田七的索引：2
['张三', '赵六', '小田']
['小田', '赵六', '张三']
[1, 3, 5, 8, 12, 13, 15]
[15, 13, 12, 8, 5, 3, 1]
"""

列表的遍历

for循环遍历
list1 = ["apple", "orange", "peach", "grape"]

for i in list1:
    print(i)
 
#results
"""
apple
orange
peach
grape
"""
while循环遍历
list1 = ["apple", "orange", "peach", "grape"]
# 定义计数器
i = 0

# 定义while循环
while i < len(list1):
    print(list1[i])
    # 更新计数器
    i += 1
#results
 """
 apple
orange
peach
grape
 """

列表的嵌套

嵌套列表的定义
class_total = [
    ['张三','李四','王五'],
    ['赵六','田七','周八'],
    ['李九','老张','老李']
]

# 输出大列表中，第二个列表的第二个元素
print(class_total[1][1])  

#result： 田七
嵌套列表的遍历
class_total = [
    ['张三','李四','王五'],
    ['赵六','田七','周八'],
    ['李九','老张','老李']
]
for group in class_total:
    for student in group:
        print(student)
 
 #results:
 """
 张三
李四
王五
赵六
田七
周八
李九
老张
老李

Process finished with exit code 0

 """

元组

作用：可以存储多个数据且元组内的**数据是不能修改的**

元组的定义：

基本语法：
tuple1 = (10, 20, 30)
#空元组没有意义，因为元组不可更改

元组中只有一个元素时，需要在元素后添加一个英文逗号。若不添加元素时什么类型，元组就会是什么类型

my_tuple = (1,)
my_tuple1 = (1)
print(type(my_tuple)) 
print(type(my_tuple1))
#输出
#<class 'tuple'>
#<class 'int'>

元组特点：

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
元组中的数据不可更改

元组的常用方法

函数作用基本语法示例
元组[索引]根据索引下标查找元素元组名称[索引]tuple1[1]
index()查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同元组名称.index(元素名称)tuple1.index(“orange”)
count()统计某个数据在当前元组出现的次数元组名称.count(元素名称)tuple.count(“apple”)
len()获取元组的长度len(元组名称)len(tuple1)

示例代码：

# 1- 定义一个元组:

tuple1 = (1, 2, 4, "apple", "peach",2)

# 2- 获取元组中的数据:
# 根据索引获取指定的元素
print(tuple1[1])

# 获取某个元素的索引值
print(tuple1.index("apple"))

# 获取某个元素出现了几次
print(tuple1.count(2))

# 获取元组的长度
print(len(tuple1))


print("_______________________")
# 3- 如何遍历元组:
for i in tuple1:
    print(i)

print("_______________________")

i = 0
while i < len(tuple1):
    print(tuple1[i])
    i += 1

#输出：
"""
2
3
2
6
_______________________
1
2
4
apple
peach
2
_______________________
1
2
4
apple
peach
2

"""

案例需求：

编写一个程序来提取嵌套元组中的唯一元素。
例如: 在嵌套元组((1,2,3),(2,4,6),(2,3,5))中, 2重复出现了3次，3重复出现了2次，但我们的输出列表只会包含2、3一次。
即：[1, 2, 3, 4, 5, 6]

tuple1 = ((1, 2, 3), (2, 4, 6), (2, 3, 5))
list1 = []

for i in tuple1:
    for element in i:
        if element not in list1:
            list1.append(element)

print(list1)

集合

什么是集合：

集合（set）是一个**无序**的**不重复**元素序列
① 天生去重
② 无序

集合的定义

set() #定义一个空集合
set{1,2,4}  #定义有元素的元组
set([1, 2, 4]) #定义有元素的元组，方法二

特点：

集合中元素不重复，会自动去重
集合可以存储多种类型的数据，但需要满足集合元素的不可变性要求
   不可变数据类型：数字类型（整数、浮点数），字符串，布尔值，元组，None等
   可变数据类型：列表、集合、字典等

示例代码：

set1 = {1, 2, 4}
set2 = set()
set3 = set([1, 2, 4])
print(type(set1))
print(type(set2))
print(type(set3))

#输出：
"""
<class 'set'>
<class 'set'>
<class 'set'>
"""

集合的增

add()
一次只能添加一个元素
基本语法：
集合名.add(要添加元素名)

示例代码：

set1 = {1, 2, 4}
set1.add("apple")
print(set1)
#输出：{1, 2, 'apple', 4}
update()
一次可添加多个元素
基本语法
集合名称.update(可迭代对象)
注意点
update添加的必须是 **可迭代** 对象  #可迭代对象：列表、字符串、字典、元组等可以被遍历
所有被添加的**元素**必须是可哈希的（**不可变类型**）
如果传入的是字典，只会添加字典的键
不传参数时方法不会报错，但无效果
update() 方法会原地修改原集合，不会返回新集合

示例代码：

set1 = {1, 2, 'apple', 4}
set1.update(["peach", "mango", 5])  #添加元素为列表，列表中元素为不可变元素
print(set1)

#输出：{1, 2, 4, 5, 'apple', 'peach', 'mango'}

集合的查

函数作用基本语法示例
in判断元素是否在集合中if 元素名 in 集合名：if 5 in my_set:
not in判断元素是否在集合中if 元素名 not in 集合名：if 5 not in my_set:
len()查看集合长度len(集合名)len(my_set)
示例代码：
set2 = {2, 5, 3, 7, 5, 7}
enter = int(input("please enter a integer: "))
if enter in set2:
    print(enter)
else:
    print("Not exist")

集合的删

函数作用基本语法示例
remove()删除指定元素（如果元素不存在会抛出异常）集合名.remove(元素名)my_set.remove(3)
discard()删除指定元素 （如果元素不存在不会抛出异常）集合名.discard(元素名)my_set.discard(10)
pop()随机删除并返回一个元素集合名.pop(元素名)my_set.pop()
clear()清空集合集合名.clear()my_set.clear()

示例代码：

set2 = {2, 5, 3, 7, 5, 7}
set2.remove(2)
print(set2)
set2.discard(2)  # 集合中没有元素2，删除也不会报错
print(set2)
set_pop = set2.pop()  # pop删除之后会返回被删除的数
print(f"{set_pop} has been deleted!")

#输出
"""
{3, 5, 7}
{3, 5, 7}
3 has been deleted!
"""

集合案例

编写一个程序来统计缺失的数字并返回它们的总和。缺失的数字是指给定列表中两个极端（最大和最小数字）之间没有出现的数字。
例如，在集合{2, 5, 3, 7, 5, 7}中，两个极端（即2和7）之间缺失的数字是4和6。

set1 = {2, 5, 3, 7, 5, 7}

max_set = max(set1)
min_set = min(set1)
sum = 0
for i in range(min_set,max_set):
    if i not in set1:
        print(i)
        sum += i

print(sum)

#输出：
"""
4
6
10
"""

字典

作用：

存储键值对类型数据，如学生信息等

定义一个字典：

字典由键（key）和值（value）组成，每个键都唯一对应一个值。键是任何不可变类型，如字符串、数字或元组，而值则可以是任意类型的数据，包括列表、字典等。字典使用大括号 {} 定义，键值对之间用冒号 : 分隔，键值对之间用逗号 , 分隔。
基本语法：
#定义一个空字典
字典名 = {} 
#定义有数据字典
字典名 = {key1:value1,key2:value2}  #字典中存储的是键值对。键是任何不可变类型，值则可以是任意类型的数据
示例：
dict1 = {}
print(type(dict1))

dict2 = {"name": "Tom", "age": 18, "address": "changping"}
print(dict2)

#输出
"""
<class 'dict'>
{'name': 'Tom', 'age': 18, 'address': 'changping'}
"""

特点：

在同一个字典中，key必须是唯一（类似于索引下标）
字典通过键来访问值，时间复杂度为 O(1)，因此在查找、插入和删除操作上非常高效。
由于字典是可变的，你可以随时添加、修改或删除键值对

字典的操作：

字典的增
基本方法：
字典名[key] = value

示例代码：

student = {"name": "张三", "age": 20, "gender": "male"}
# 添加新元素
student["address"] = "beijing"
print(student)

#输出：{'name': '张三', 'age': 20, 'gender': 'male', 'address': 'beijing'}
字典的查
基本语法：
字典名[key]
字典名.get(key)
注：如果未找到，则直接报错

示例代码：

student = {"name": "张三", "age": 20, "gender": "male"}
print(student["name"])
print(student.get("age"))
#输出：
"""
张三
20
"""
字典的改
基本语法
字典名称[key] = value
注：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

示例代码：

student = {'name': '张三', 'age': 20, 'gender': 'male', 'address': 'beijing'}
student["address"] = "xian"
print(student)

#输出：{'name': '张三', 'age': 20, 'gender': 'male', 'address': 'xian'}
字典的删
基本语法：
del 字典名称[key]：删除指定元素
clear()方法：清空字典中的所有key

示例代码：

student = {{'name': '张三', 'age': 20, 'gender': 'male', 'address': 'xian'}}
del student["address"]
print(student)
#输出：{'name': '张三', 'age': 20, 'gender': 'male'}
字典的遍历

案例1：提取student 字典中的所有key

student = {'name': '张三', 'age': 20, 'gender': 'male'}
for i in student:
    print(i)
# 输出：
"""
name
age
gender
"""

案例2：提取student 字典中的所有value值

student = {'name': '张三', 'age': 20, 'gender': 'male'}
for i in student.values():
    print(i)
#输出：
"""
name
age
gender
"""

案例3：使用items()方法提取数据
字典名.items() 是一个列表：dict_items([(‘name’, ‘张三’), (‘age’, 20), (‘gender’, ‘male’)])

student = {'name': '张三', 'age': 20, 'gender': 'male'}
for key, value in student.items():
    print(f"{key}:{value}")
#输出：
"""
name:张三
age:20
gender:male
"""

字典的案例

给定一个字符串my_string，现在要求统计每个字符出现的次数: 形成结果: {‘字符’:出现次数,‘字符2’:次数}
例如: ‘abceacf’ ==> {‘a’:2,‘b’:1,‘c’:2,‘e’:1,‘f’:1}

方法一：通过集合

my_string = 'abceacf'

# 定义一个集合用于对之后结果进行去重
set1 = set()
for i in my_string:
    count_str = my_string.count(i)
    # 将遍历后的元素和出现次数添加到集合中
    set1.add((i,count_str))

# 将集合转换为字典
print(dict(set1)) # 输出：{'a': 2, 'e': 1, 'c': 2, 'b': 1, 'f': 1}

方法二：

my_string = 'abceacf'
dict1 = {}
for i in my_string:
    # 判断当前字符是否在字典中
    if i in dict1:
        # 之前已经添加到字典的元素，对应的次数加1
        dict1[i] += 1
    else:
        # 之前没有添加元素，新增到字典中
        dict1[i] = 1

print(dict1)  # 输出：{'a': 2, 'e': 1, 'c': 2, 'b': 1, 'f': 1}

需求: 编写一个程序将字符串转换为字典 例如:输入: ‘5=Five 6=Six 7=Seven’ 输出: {‘5’: ‘Five’, ‘6’: ‘Six’, ‘7’: ‘Seven’}

str2 = '5=Five 6=Six 7=Seven'
str2_list = str2.split()
# 定义一个空字典，用于将之后的结果追加
dict2 = {}
for i in str2_list:
    # 分别将切割后的0、1个元素，作为key、value添加到字典中
    dict2[i.split("=")[0]] =i.split("=")[1]
print(dict2)  # 输出：{'5': 'Five', '6': 'Six', '7': 'Seven'}

容器拆包

什么是容器拆包：

容器拆包（Unpacking）是指将容器（如元组、列表、字典等）中的元素逐个提取出来，并分别赋值给多个变量的过程。这种操作使得代码更加简洁和易读。

常见示例

元组拆包
# 基本拆包
a, b, c = (1, 2, 3)
print(a, b, c)  # 输出: 1 2 3

# 从元组中提取元素
person = ("apple", "peach", "mango", "grape")
a, b, c, d = person
print(a, b, c, d) # 输出: 张三 25 北京
列表拆包
# 列表拆包
a, b, c = [1, 2, 3]
print(a, b, c)  # 输出: 1 2 3

# 从列表中提取元素
colors = ["红色", "绿色", "蓝色"]
red, green, blue = colors
print(red, green, blue)  # 输出: 红色 绿色 蓝色
字符串拆包
a, b, c = "abc"
print(a, b, c)  # 输出: a b c
字典拆包
# 字典拆包（只取键）
a, b, c = {"a": 1, "b": 2, "c": 3}
print(a, b, c)  # 输出: a b c
使用星号(*)进行扩展拆包
# 使用 * 收集剩余元素
a, *b, c = [1, 2, 3, 4, 5]
print(a, b, c)  # 输出: 1 [2, 3, 4] 5
在函数参数中使用 * 进行拆包
def my_function(a, b, c):
    print(a, b, c)

my_list = [1, 2, 3]
my_function(*my_list)  # 输出: 1 2 3

注意点：

变量数量与元素数量匹配
拆包时，变量的数量必须与容器中的元素数量一致，否则会抛出 ValueError 异常。

使用下划线(_)忽略不需要的值

# 忽略不需要的值
a, _, c = [1, 2, 3]
print(a, c)  # 输出: 1 3

实际应用场景

交换变量值
a, b = 1, 2
a, b = b, a  # 交换 a 和 b 的值
print(a, b)  # 输出: 2 1
函数返回值处理
def get_coordinates():
    return 10, 20

x, y = get_coordinates()
print(x, y)  # 输出: 10 20
多层嵌套拆包
# 嵌套拆包
(a, b), (c, d) = (1, 2), (3, 4)
print(a, b, c, d)  # 输出: 1 2 3 4

推导式

是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列（一个有规律的列表或控制一个有规律列表）的结构体。 共有三种推导：`列表推导式`、`集合推导式`、`字典推导式`。
 将表达式(原代码的循环体)中每次的执行结果，添加到可变数据类型中。表达式(对变量进行运算int(i),i**等) for 变量 范围
 **条件：循环体中只有一行代码**

什么时候可以使用推导式:

当需要遍历一个容器, 然后遍历后需要返回一个新容器的场景

列表推导式(字典、集合的推导式逻辑于列表一致)

基本语法
变量名 = [表达式 for 变量 in 列表]
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]
案例
案例：定义0-9之间的列表

常见代码实现：

list1 = []
for i in range(10):
    list1.append(i)
print(list1)

列表推导式：

list1 =[i for i in range(9)]
print(list1)  # 输出：[0, 1, 2, 3, 4, 5, 6, 7, 8]
案例：对集合set1的每个元素平方(集合)
set1 = {1, 2, 4, 5}
set1 = {i**2 for i in set1}
print(set1)  # 输出：{16, 1, 4, 25}  #集合无序、不重复
案例：给所有水果涨价2倍(字典)
dict1 = {"orange": 2.5, "grape": 10, "peach": 5}
dict1 = { i:dict1[i]*2  for i in dict1}
print(dict1)  # {'orange': 5.0, 'grape': 20, 'peach': 10}
案例：生成0-9之间的偶数（i%2 0）序列

常见代码实现：

list1 = []
for i in range(10):
    if i % 2 == 0:
        list1.append(i)
print(list1)

列表推导式：

list2 = [j for j in range(9) if j % 2 == 0]
print(list2)
案例：创建列表 => [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

原生代码：for循环嵌套

list1 = []
# 外层循环
for i in range(1, 3):
    # 内层循环
    for j in range(0, 3):
        tuple1 = (i, j)
        list1.append(tuple1)
print(list1)

列表推导式：

list3 = [ (i,j) for i in range(1,3) for j in range(3) ]
print(list3) # 输出：list3 = [ (i,j) for i in range(1,3) for j in range(3) ]
使用列表推导式生成平方数集合

例如, 用户输入10, 表示要生成 1~10的每一个数字的2平方的集合

num = int(input("Please enter a integer: "))
print([i**2 for i in range(num + 1)])

您可能感兴趣的与本文相关的镜像

Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

qingyulee
关注
Python中集合set的使用详解
热门推荐
涤生大数据
08-18 9万+
在python3中按数据类型的可变与不可变大致分为如下几种类型，前面已经介绍了另外几种了。今天讲讲set。 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）； 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 1.set是什么？用来干什么？ python中，用set来表示一个无序不重复元素的序列。set的只要作用就是用...
Python -- 集合
天行健 君子以自强不息，地势坤 君子以厚德载物。
03-24 3万+
集合 集合概述:Python中的集合(set)与数学中的集合概念类似 也是用于保存不重复的元素。它有可变集合(set)和不可变集合(frozenset)两种。 在形式上，集合的所有元素都放在一对大括号中，两个相邻元素间使用逗号“”分隔。 集合最好的应用就是去重，因为集合中的每个元素都是唯一的。 1.1 集合的创建 示例: 直接使用{}创建集合 collection = {1, 2, 3, 4, 5} print(collection) 运行结果: 示例: 使用set()函数创建集合 lists
Python数据结构——集合
Morse_Chen的博客
01-24 1万+
本文讲解Python数据结构的集合操作。集合的创建、可变集合用法、集合运算、集合常用函数和方法。
python：集合
OceanStar的博客
10-05 7711
【代码】python：集合。
Python学习——集合
m0_46155417的博客
06-27 6557
python学习——集合
3. Python 数据容器（列表、元组、字符串、集合、字典）
qq_44378854的博客
08-23 3792
列表内的每一个数据，称为元素。列表以[]作为标识，其中的元素之间用，隔开。#字面量 [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] #定义变量 变量名称 = [ 元素 1 , 元素 2 , 元素 3 , 元素 4 , . . . ] #定义空列表 变量名称 = [ ] 变量名称 = 1ist()注意：列表可以一次存储多个数据，且可以为不同、任意的数据类型，支持嵌套。
python基础——数据容器总结、通用方法和相互转换
tan_run的博客
03-24 2477
python基础——数据容器总结、通用方法和相互转换【数据容器间的区别，通用方法min，max，sorted，转换方法list，tuple，str，set，zip】
Python基础数据容器指南：特性解析与常用操作
qq_61638996的博客
04-04 1776
在 Python 编程中，数据容器是组织和管理数据的核心工具。无论是简单的数据存储、快速查找，还是复杂的数据处理，选择合适的数据容器能大幅提升代码效率和可读性。本文将以五大基础容器为核心，解析它们的核心特性、常用操作及适用场景。
Python-Python数据容器：数据容器:list、列表的定义、下标索引（下标（索引）反向、嵌套的下标（索引））、常用操作（查询方法、修改方法）、遍历、数据容器（tuple(元组)、str(字符串
放下华子我只抽RuiKe5的博客
07-18 2793
Python-Python数据容器：数据容器:list(列表)、列表的定义、列表的下标索引（列表的下标（索引）反向、嵌套列表的下标（索引））、列表的常用操作（查询方法、修改方法）、list(列表)的遍历、数据容器（tuple(元组)、str(字符串)、切片、set(集合)、for循环、dict(字典、映射)、数据容器的对比总结、数据容器的通用操作、字符串大小比较
Python基础篇------集合
m0_71494659的博客
04-22 3048
【代码】Python基础篇------集合。
Python中集合（set）定义和操作
2303_80075462的博客
01-28 1248
{元素，元素...}
【python】关于python的集合
2401_83859102的博客
04-06 1785
set3=set() #声明一个空集合集合本身的特点：集合是无序的，并且元素是唯一的，不重复（可以去重！！与字典的区别：字典内的元素是键值对，集合内的元素非键值对set1={'zhangsan'} #集合类型的话，大括号的元素不是键值对存在set2={} #如果大括号里面什么都不加，那么就是字典。
python基础变量之---集合
m0_73338216的博客
03-13 1852
在Python中，集合（set）是一种无序的、不重复的数据结构，用于存储唯一的元素，支持数学集合的一些操作，如交集、并集、差集等。集合中的元素是无序的，即不记录元素的插入顺序，且每个元素只能出现一次，集合可以通过大括号{}或set()函数来创建，集合的元素必须是可哈希的（不可变的），例如数字、字符串、元组等，但列表、字典等可变类型不能作为集合的元素集合是可变的容器，固定集合是不可变的集合集合相当于只有键没有值的字典，当然你也可以理解为键和值相等集合内的数据都是唯一的，不可变的。
Python基础：集合
m0_63784533的博客
03-30 2749
什么是集合？
Python集合(Set)全面解析：从入门到精通
x15514104477的博客
05-22 2758
集合(Set)是Python中一种非常重要的数据类型，它类似于数学中的集合概念，具有无序、不重复的特性。本文将用通俗易懂的方式，结合代码示例和图表，全面讲解Python集合的知识点。
python基本数据类型--集合（set）
爆笑蛙的博客
06-22 3715
本文详细介绍了集合的定义方式、求并集、求交集、求差集、求对称差集、判断子集、计算运算符、成员运算符、身份运算符、冻结集合等内容。集合是用{}作为边界逗号作为分隔符，只能容纳不可变的数据类型，如：{}，{1, 2, 'abc', (1, 2, 3)}等等，是可迭代的数据类型，可以被修改，集合中的元素排列方式是无序的。
python：集合【全用法】
dddxxy的博客
07-02 2万+
python中有列表、元组、集合、字典这四种可以存放多个数据元素的集合，他们在总体功能上都起着存放数据的作用，却都有着各自的特点。本片文章中我们会对集合的用法做详细说明。 演示环境： python3.6 pycharm中的python3.6 集合（set）：存储元素不重复、无序数据类型，只支持成员操作赋、for循环迭代、枚举。 无序的数据类型，添加顺序和在集合中的存储顺序不一样 ！！不支持索引，重...
Python集合
最新发布
Heliotrope_Sun的博客
08-20 1534
方法用于从集合中随机删除一个元素，并返回被删除的元素。由于集合是无序的，因此无法确定 pop() 方法删除的是哪一个元素。方法也用于从集合中删除一个指定的元素，但与 remove() 不同的是，如果该元素不存在于集合中，discard() 方法不会抛出异常。如果该元素不存在于集合中，remove() 方法会抛出一个 KeyError 异常。来创建集合，但需要注意的是，空的大括号{ }表示一个空字典，而不是空集合。，删除集合中的所有元素。到一个新的集合中，重复的元素会被自动忽略。，或者在删除操作前进行检查。
Python干货总结篇：列表、字典、集合、元组的区别与用途
2301_81711570的博客
12-02 4777
数据结构是否有序是否可变是否允许重复适用场景列表 (list是是是需要顺序、可修改的数据，如存储一系列元素。集合 (set否是否需要去重或者进行集合操作（并集、交集等）。字典 (dict否是否（键是唯一的）存储键值对，快速查找、存储映射关系。元组 (tuple是否是不需要修改的数据，如不可变的记录或作为字典键。简单来说，选择适合的容器类型取决于具体的应用场景和操作需求。
python 集合的详细用法
m0_61066945的博客
01-16 5147
集合和基本用法，集合的各种运算、数据去重、数据分析和统计等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值