一、数据容器

数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据类型称之为1个元素。每一个元素可以是任意类型的数据。

数据容器特点对比

	列表(list)	元组(tuple)	字符串(str)	集合(set)	字典(dict)
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	k:v
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
是否支持while循环	是	是	是	否	否
使用场景	可修改、可重复	不可修改、可重复	一串字符	不可重复	以key检索value

二、序列

序列是指：内容连续、有序，可以使用下标索引的一类数据容器
列表(list)、元组(tuple)、字符串(str)均可以视为序列。

如上图，序列的典型特征就是：有序可用下标索引，字符串、元组、列表均满足这个要求

三、列表(list)

3.1、列表定义：

# 字面量
["tai", "bai", "python"]
# 定义变量
name = ["tai", "bai", "python"]
# 定义空列表
name = []
name = list()
# 嵌套列表
message = [[1, 2, 3], ["tai", "bai", "python"], [21, 22, 25]]

3.2、列表下标索引

列表的每一个元素，都有编号称之为下标索引
从前向后的方向，编号从0开始递增
从后往前的方向，编号从-1开始递减

通过下标获取对应位置的元素

列表[下标]

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 通过下标索引去除数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

注意：

要注意下标索引的取值范围，超出范围无法取出元素，并且会报错（IndexError: list index out of range）

3.3、列表常用方法：

方法	作用
列表.append(元素)	向列表中追加一个元素
列表.extend(容器)	将数据容器的内容依次去除，追加到列表尾部
列表.insert(下标, 元素)	在指定下标出，插入指定的元素
del 列表[下标]	删除列表指定下标元素
列表.pop(下标)	删除列表指定下标元素（返回删除的元素）
列表.remove(元素)	从前向后，删除此元素第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标（找不到报错ValueError）
len(列表)	统计容器中有多少元素

示例：

# 1.1 查找某元素在列表内的下标索引
index = name.index("tai")
print(f"tai在list的下标为{index}")# 1.2 如果被查找的元素不存在，会报错   ValueError: 'li' is not in list
# index = name.index("li")
# print(f"li在list的下标为{index}")# 2、修改特定下标索引的值
name[1] = "libai"
print(name)# 3、在指定下标位置插入新元素
name.insert(1, "li")
print(name)# 4、在列表的尾部追加  单个  新元素
name.append("bai")
print(name)# 5、在列表的尾部追加  一批  新元素
name.extend(["java", "mysql"])
print(name)
# 6、 删除指定下标的元素 （两种方法）
# 6.1 方式1：del 列表[下标]
del name[2]
print(name)
# 6.2 方式2：列表.pop(下标)
element = name.pop(2)
print(f"通过pop取出元素后列表内容为：{name}，取出的元素为{element}")# 7、删除某元素在列表中的第一个匹配项
name.remove("tai")
print(name)# 8、清空列表
# name.clear()
# print(name)
# 9、统计列表内某元素的数量
count = name.count("bai")
print(f"bai在列表中出现了{count}次")
# 10、统计列表中全部的元素数量
len = len(name)
print(f"name一个有{len}个元素")

3.4、list遍历

def list_while_func():"""使用while循环遍历列表的演示函数:return: None"""my_list = ["li", "tai", "bai"]# 循环控制变量通过下标索引来控制，默认0# 每一次循环将下标索引变量+1# 循环条件： 下标索引变量 < 列表的元素数量# 定义一个变量用来标记列表的下标index = 0           # 初始值的下标为0while index < len(my_list):print(my_list[index])index += 1# list_while_func()
def list_for_func():"""使用for循环遍历列表的演示函数:return: None"""my_list = [1, 2, 3, 4, 5]# for 临时变量 in 数据容器:for i in my_list:print(i)

四、元组(tuple)

4.1、元组定义

# 定义元组字面量
("taibai", 666, True)
# 定义元组变量
t1 = ("taibai", 666, True)
# 定义空元组
t2 = ()
t3 = tuple()
# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))

4.2、元组的常用方法

在上述数据容器的描述中，已描述元组是不可修改的，所以并没有 增删改的操作

方法	作用
元组.index(元素)	查找某个元素，如果数据存在返回对应下标，否则报错（ValueError: tuple.index(x): x not in tuple）
元组.count(元素)	统计某个元素在当前元组出现的次数
len(元组)	统计元组中的元素个数

示例：

# 元组的操作： index查找方法
t6 = ("tai", "bai", "python", "python")
index = t6.index("bai")
print(f"bai出现在元组的下标为{index}")# 元组的操作：count统计方法
count = t6.count("python")
print(f"python在元组中出现了{count}次")# 元组的操作： len函数统计元祖元素数量
len = len(t6)
print(f"t6元组一共有{len}个元素")

4.3、元组的遍历

t6 = ("tai", "bai", "python", "python")
def tuple_while_func():i = 0while i < len:print(t6[i])i += 1# 元组的遍历： for
def tuple_for_func():for i in t6:print(i)

五、字符串(str)

尽管字符串看起来并不像列表、元组那样，看起来存放了许多数据的容器
但不可否认，字符串也是数据容器的一员
并且字符串也是一个无法修改的数据容器，每次修改只是得到了一个新的字符串

5.1、字符串定义

# 字面量
'taibai'
"taibai"
# 定义变量
name = 'taibai'
name = "taibai"
name = """taibai"""
# 定义空字符串
str1 = ''
str2 = ""
str3 = """"""
str4 = str()

5.2、常用方法

方法	作用
字符串[下标]	根据下标索引去除特定位置字符
字符串.index(字符串)	给定字符的第一个匹配项的下标
字符串.replace(字符串1,字符串2)	将字符串内的全部字符串1，替换为字符串2（并不会修改原字符串，而是得到一个新的字符串）
字符串.split(字符串)	按照给定字符串，对字符串进行分割，不会修改原字符串，而是得到一个新的列表
字符串.strip()	移除首尾的空格和换行符
字符串.strip(字符串)	移除首尾的指定字符串（此处是按照单个字符去除）
字符串.count(字符串)	统计字符串内某字符串的出现次数
len(字符串)	统计字符串的字符个数

示例：

my_str = "My name is taibai"
# 通过下标索引取值
value = my_str[5]
value2 = my_str[-4]
print(f"从字符串{my_str}取下标为5得值为：{value}，取下标为-4的值为：{value2}")
# index方法
value = my_str.index("is")
print(value)
# replace方法
my_str1 = my_str.replace("taibai", "taibai_yuan")
print(my_str1)
# split方法
my_list = my_str.split(" ")
print(my_list)
# strip方法 不添加参数去除前后空格 添加参数去除前后参数
my_str = "  My name is taibai  "
my_aa = my_str.strip()
print(my_aa)
my_str = "123My name is taibai321"
my_bb = my_str.strip("123")
print(my_bb)
# 统计字符串中某字符串的出现次数
count = my_str.count("a")
print(f"在{my_str}中a出现了{count}次")
# 统计字符串的长度
num = len(my_str)
print(f"{my_str}长度为{num}")

5.3、字符串遍历

my_str = "My name is taibai"# 使用while循环遍历
index = 0
while index < len(my_str):print(my_str[index])index += 1# 使用for循环遍历
for i in my_str:print(i)

六、序列切片

语法

序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次去除元素，到指定位置结束，得到一个新的序列

• 起始下标：表示从何处开始，可以不写，不写表示从头开始
• 结束下标：表示从何处结束，可以不写，不写表示截取到结尾
• 步长：表示依次取元素的间隔（可以为负数，表示倒序执行）

注意：

此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

示例：

# 对list进行切片，从1开始，4结束，步长为1
my_list = [0, 1, 2, 3, 4, 5, 6]
result = my_list[1:4]       # 步长默认为1，可以不写
print(result)# 对tuple进行切片，从头开始，到最后结束，步长为1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result1 = my_tuple[:]       # 起始和结束不写，表示从头到尾  步长默认为1，也可以不写
print(result1)# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "0123456"
result2 = my_str[::2]
print(result2)
# 对str进行切边，从头开始，到最后结束，步长为-1
result3 = my_str[::-1]
print(result3)# 对列表进行切片，从3开始，到1结束，步长为-1
result4 = my_list[3:1:-1]
print(result4)
# 对元组进行切片，从头开始，到尾结束，步长为-2
result5 = my_tuple[::-2]
print(result5)

七、集合(set)

7.1、集合定义

# 定义集合字面量
{"my", "name", "taibai", "python"}
# 定义集合变量
my_set = {"my", "name", "taibai", "python"}
# 定义空集合
my_set1 = set()

使用下列代码结果可看为 去重且无序

my_set = {"my", "name", "taibai", "python", "python", "python", "python"}
my_set1 = set()
print(my_set)

7.2、常用方法

方法	作用
集合.add(元素)	集合内添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素（并返回取出的元素）
集合.clear()	将集合清空
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集（原有2个集合内容的不变）
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素（集合1被修改，集合2不变）
集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素（原有的2个集合内容不变）
len(集合)	得到一个整数，记录了集合的元素数量

示例：

my_set = {"my", "name", "taibai", "python"}
# 添加新元素
my_set.add("taibai_yuan")
print(my_set)
# 移除元素
my_set.remove("my")
print(my_set)
# 随机取出一个元素
string = my_set.pop()
print(string)
print(my_set)
# 清空集合
my_set.clear()
print(my_set)
# 取2个集合的差集
set1 = {"tai", "bai", "yuan"}
set2 = {"my", "name", "tai", "yuan"}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)
# 消除两个集合的差集
set1.difference_update(set2)
print(set1)
print(set2)
# 2个集合合并为1个
set1 = {"tai", "bai", "yuan"}
set2 = {"my", "name", "tai", "yuan"}
set3 = set1.union(set2)
print(set3)# 统计集合元素数量
count = len(set1)
print(count)

7.3、遍历集合

由于集合无序，不可使用下标。所以不能使用while进行循环遍历

# 集合遍历
for i in set1:print(i)

八、字典(dict)

8.1、字典定义

# 定义字典字面量
{"taibai": 21, "yuan": 19, "libai": 30, "zhangsan": 10}
# 定义字典变量
my_dict = {"taibai": 21, "yuan": 19, "libai": 30, "zhangsan": 10}
# 定义空字典
my_dict1 = dict()
my_dict2 = {}

注意：

• 每一份数据都是k-v键值对
• 可用于通过key获取value，key不可重复（重复会覆盖）

8.2、常用方法

方法	作用
字典[key]	获取指定key对应的value值
字典[key] = value	添加或更新键值对
字典.pop(key)	取出key对应的value并在字典内删除此key的键值对
字典.clear()	清空字典
字典.keys()	获取字典的全部key，可以用来for循环遍历字典
len(字典)	计算字典内的元素数量

示例：

my_dict = {"张三": 99, "李四": 88, "王五": 77}
# 获取指定key对应的value值
value = my_dict["张三"]
# 新增元素
my_dict["太白"] = 100
print(my_dict)
# 更新元素
my_dict["太白"] = 150
print(my_dict)
# 删除元素
value = my_dict.pop("张三")
print(value)
print(my_dict)
# 清空元素
my_dict.clear()
print(my_dict)# 获取全部的key
my_dict = {"张三": 99, "李四": 88, "王五": 77}
dict_set = my_dict.keys()
print(dict_set)

8.3、遍历字典

# 遍历字典
# 方式一：获取到所有的key来遍历key获取dict的元素
for i in dict_set:print(f"{i}:{my_dict[i]}")
# 方式二：直接使用for循环就可以获取到dict的key
for i in my_dict:print(f"{i}:{my_dict[i]}")

九、容器通用常用功能

功能	作用
通用for循环	遍历容器（字典是遍历key）
max()	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列,[reverse=True])	排序，reverse=True 表示降序（得到一个排好序的序列）

注意：

• 字典转换为字符串并不会又影响
• 字典转换为列表会将value丢失
• 字典转换为元组会将value丢失
• 字典转换为集合会将value丢失
• 其余容器转字典，由于其余数据容器并无键值对，所以无法转字典

示例：

my_list = [3, 1, 2, 8, 0]
my_tuple = (3, 1, 2, 8, 0)
my_str = "cdiracl"
my_set = {3, 1, 2, 8, 0}
my_dict = {"key1": 1, "key3": 3, "key2": 2}# len元素
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串 元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")# max最大元素
print(f"列表 元素最大元素有：{max(my_list)}")
print(f"元组 元素最大元素有：{max(my_tuple)}")
print(f"字符串元素最大元素有：{max(my_str)}")
print(f"集合 元素最大元素有：{max(my_set)}")
print(f"字典 元素最大元素有：{max(my_dict)}")# min最小元素
print(f"列表 元素最小元素有：{min(my_list)}")
print(f"元组 元素最小元素有：{min(my_tuple)}")
print(f"字符串元素最小元素有：{min(my_str)}")
print(f"集合 元素最小元素有：{min(my_set)}")
print(f"字典 元素最小元素有：{min(my_dict)}")# 类型转换：容器转列表
print(f"列表 转列表有：{list(my_list)}")
print(f"元组 转列表有：{list(my_tuple)}")
print(f"字符串转列表有：{list(my_str)}")
print(f"集合 转列表有：{list(my_set)}")
print(f"字典 转列表有：{list(my_dict)}")
# 类型转换：容器转元组
print(f"列表 转元组有：{tuple(my_list)}")
print(f"元组 转元组有：{tuple(my_tuple)}")
print(f"字符串转元组有：{tuple(my_str)}")
print(f"集合 转元组有：{tuple(my_set)}")
print(f"字典 转元组有：{tuple(my_dict)}")
# 类型转换：容器转字符串
print(f"列表 转字符串有：{str(my_list)}")
print(f"元组 转字符串有：{str(my_tuple)}")
print(f"字符串转字符串有：{str(my_str)}")
print(f"集合 转字符串有：{str(my_set)}")
print(f"字典 转字符串有：{str(my_dict)}")
# 类型转换：容器转集合
print(f"列表 转集合有：{set(my_list)}")
print(f"元组 转集合有：{set(my_tuple)}")
print(f"字符串转集合有：{set(my_str)}")
print(f"集合 转集合有：{set(my_set)}")
print(f"字典 转集合有：{set(my_dict)}")# 转字典，由于其余数据容器并无键值对，所以无法转字典# sorted 排序   将内容排序放入列表之中
print(f"列表 对象排序结果有：{sorted(my_list)}")
print(f"元组 对象排序结果有：{sorted(my_tuple)}")
print(f"字符串对象排序结果有：{sorted(my_str)}")
print(f"集合 对象排序结果有：{sorted(my_set)}")
print(f"字典 对象排序结果有：{sorted(my_dict)}")# 反向排序
print(f"列表 对象排序结果有：{sorted(my_list, reverse=True)}")
print(f"元组 对象排序结果有：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象排序结果有：{sorted(my_str, reverse=True)}")
print(f"集合 对象排序结果有：{sorted(my_set, reverse=True)}")
print(f"字典 对象排序结果有：{sorted(my_dict, reverse=True)}")

Python--数据容器相关推荐

1. python入门(六)——python数据容器

   系列文章目录 python入门(一)--你好python python入门(二)--python基础语法 python入门(三)--python判断语句 python入门(四)--python循环语句 ...

2. python数据容器专题

   Python容器专题 [导读] 容器通常属于序列(如列表或元组)或映射(如字典),但也存在其他形式的容器.依据Python官方的说法,Python语言中标准内建容器包括 dict , list , s ...

3. Python数据容器：list + set + tuple + dict + str 简记 黑马课程

   # -*- coding:utf8 -*- """ # editor: hjjdreamer # create-time: 2022/11/16-23:08 # Pyth ...

4. 【Python基础】Python数据容器（集合）

   文章目录 数据容器:set(集合) 集合的定义 集合的常用操作-修改 (1)添加新元素 (2)移除元素 (3)从集合中随机取出元素 (4)清空集合 (5)取出 两个集合的差集 (6)消除 两个集合的差 ...

5. 【Python基础】Python数据容器（字典）

   文章目录 数据容器:dict(字典.映射) 字典的定义 字典数据的获取 字典的嵌套 字典的注意事项 字典的常用操作 (1)新增元素 (2)更新元素 (3)删除元素 (4)清空字典 (5)获取全部key ...

6. 【Python基础】Python数据容器（元组）

   文章目录 数据容器:tuple(元组) 元组的定义格式 元组的相关操作 元组的相关操作-注意事项 元组的特点 数据容器:tuple(元组) 元组的定义格式 元组定义:定义元组使用小括号,且使用逗号隔开 ...

7. 【Python基础】Python数据容器（字符串）

   文章目录 数据容器:str(字符串) 字符串的常用操作 (1)查找特定字符串的下标索引值 (2)字符串的替换 (3)字符串的分割 (4)字符串的规整操作(去前后空格) (5)字符串的规整操作(去前后指 ...

8. python数据容器之集合、字典

   set集合 基本语法: # 定义集合字面量 (元素,元素,--元素) # 定义集合变量 变量名称 = (元素,元素,--元素) # 定义空集合 变量名称 = set() 列表使用 [] 元组使用 () ...

9. 3. Python 数据容器（列表、元组、字符串、集合、字典）

   1. 数据容器入门 数据容器:一种可以容纳多份数据的数据类型,容纳的每份数据称为一个元素. 每个元素,可以是任意类型数据,如:字符串.数字.布尔等. 数据容器根据特点的不同,如: 是否支持重复元素 是 ...

10. Python数据容器(五)

    python学习之旅(五) 学习汇总入口[Python]学习汇总(3万字+思维导图) 写作不易,如果您觉得写的不错,欢迎给博主来一波点赞.收藏~让博主更有动力吧! 一.数据容器 一种可以容纳多份数据的 ...

最新文章

1. ZooKeeper快速搭建
2. Android中Uri的使用
3. MySQL 优化原理（一）
4. php session 跨页失效问题
5. opencv 轮廓检测
6. 智能一代云平台（三十八）:单元测试推动开发，如何避免服务之间依赖拖了工期
7. .NET 漫淡(一) --- 需要充分认识的应用程序域-AppDomain
8. 在R语言中显示数学公式
9. 【kimol君的无聊小发明】—用python写音乐下载器
10. 网页 flash swf 无法调用 摄像头 问题解决
11. POI使用模板制作PPT，替换内容时原样式丢失问题的解决办法
12. nodejs q模块
13. 计算机应用退修后多久知道结果,计算机核心论文投稿的一点碎碎念
14. 入侵防御(IPS)技术，怎么做好入侵防护
15. 第七届河南省程序设计大赛~~海岛争霸(nyoj 1248)
16. 网站设计的理念与方法
17. Mindoc搭建流程
18. 智能无纸化办公，方便快捷，DIY也很简单
19. 2020春大连理工概率统计 上机作业
20. centos安装Libzip

热门文章

1. 零售AI厂商爱莫科技加入中国人工智能产业发展联盟
2. 8.2.2-elasticsearch内置分词器之whitespace/stop
3. eslint :error Parsing error: missing-whitespace-between-attributes
4. 【R】数据统计基础：集中趋势和离散程度及简单R语言代码
5. （三）【数学建模】Matlab BP神经网络
6. 甲骨文CEO埃里森的教战守则
7. 异构同步——mysql-oracle ogg同步
8. loadrunner常见报错解决
9. Docker 开启2375端口提供外部访问
10. css中的 type,css中如何使用list-style-type属性