1.数据容器入门

1.什么是数据容器？
一种可以存储多个元素的Python数据类型
2. Python有哪些数据容器？
list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
它们各有特点，但都满足可容纳多个元素的特性。

2.数据容器:list(列表)

列表的定义
基本语法：

列表内的每一个数据，称之为元素以 [] 作为标识列表内每一个元素之间用, 逗号隔开
注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

# 定义一个列表 list
my_list = ["gufeng", "itcast", "python"]
print(my_list)
print(type(my_list))my_list = ["gufeng", 666, True]
print(my_list)
print(type(my_list))# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

3.list(列表)的遍历

如何从列表中取出特定位置的数据呢？
我们可以使用：下标索引
如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
我们只需要按照下标索引，即可取得对应位置的元素。

列表的下标（索引） - 反向
或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）
如图，从后向前，下标索引为：-1、-2、-3，依次递减。

嵌套列表的下标（索引）如果列表是嵌套的列表，同样支持下标索引

如图，下标就有2个层级了。

mylist = ["itcast", "gufeng", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("gufeng")
print(f"gufeng在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")# 2. 修改特定下标索引的值
mylist[0] = "古典"
print(f"列表被修改元素值后，结果是：{mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 4. 在列表的尾部追加```单个```新元素
mylist.append("民谣")
print(f"列表在追加了元素后，结果是：{mylist}")
# 5. 在列表的尾部追加```一批```新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "gufeng", "python"]# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "gufeng", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "gufeng", "itcast", "gufeng", "python"]
mylist.remove("gufeng")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["itcast", "gufeng", "itcast", "gufeng", "python"]
count = mylist.count("gufeng")
print(f"列表中gufeng的数量是：{count}")# 10. 统计列表中全部的元素数量
mylist = ["itcast", "gufeng", "itcast", "gufeng", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

def list_while_func():"""使用while循环遍历列表的演示函数:return: None"""mylist = ["古典", "民谣", "Python"]# 循环控制变量：通过下标索引来控制，默认是0# 每一次循环，将下标索引变量+1# 循环条件：下标索引变量 < 列表的元素数量# 定义一个变量，用来标记列表的下标index = 0       # 初始下标为0while index < len(mylist):# 通过index变量取出对应下标的元素element = mylist[index]print(f"列表的元素：{element}")# 至关重要：将循环变量（index）每一次循环都+1index += 1def list_for_func():"""使用for循环遍历列表的演示函数:return:"""mylist = [1, 2, 3, 4, 5]# for 临时变量 in 数据容器:for element in mylist:print(f"列表的元素有：{element}")if __name__ == '__main__':# list_while_func()list_for_func()

列表的特点:
可以容纳多个元素（上限为2**63-1、9223372036854775807个）
可以容纳不同类型的元素（混装）
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加或删除元素等）

4.数据容器:tuple(元组)

元组一旦定义完成，就不可修改
元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
注意：元组只有一个数据，这个数据后面要添加逗号

元组的相关操作

元组由于不可修改的特性，所以其操作方法非常少。

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")# 定义单个元素的元组
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")
# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")# 元组的操作：index查找方法
t6 = ("古典", "民谣", "Python")
index = t6.index("民谣")
print(f"在元组t6中查找民谣，的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("古典", "民谣", "民谣", "民谣", "Python")
num = t7.count("民谣")
print(f"在元组t7中统计民谣的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("古典", "民谣", "民谣", "民谣", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
# 元组的遍历：while
index = 0
while index < len(t8):print(f"元组的元素有：{t8[index]}")# 至关重要index += 1# 元组的遍历：for
for element in t8:print(f"2元组的元素有：{element}")# 修改元组内容
# t8[0] = "itcast"# 定义一个元组
t9 = (1, 2, ["gufeng", "itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "民谣"
t9[2][1] = "古典"
print(f"t9的内容是：{t9}")

不可以修改元组的内容，否则会直接报错
可以修改元组内的list的内容(修改元素、增加、删除、反转等)
不可以替换list为其他list或其他类型
元组特点:
可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
允许重复数据存在
不可以修改（增加或删除元素等）
支持for循环

5.数据容器:str(字符串)

尽管字符串看起来并不像：列表、元组那样，一看就是存放了许多数据的容器。
但不可否认的是，字符串同样也是数据容器的一员。

字符串是字符的容器，一个字符串可以存放任意数量的字符。
同元组一样，字符串是一个：无法修改的数据容器。

"""
演示以数据容器的角色，学习字符串的相关操作
"""
my_str = "gufeng and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")# my_str[2] = "H"# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")# replace方法
new_my_str = my_str.replace("it", "程序")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")# split方法
my_str = "hello python gufengitcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")# strip方法
my_str = "  gufeng and itcast  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")my_str = "12gufeng and itcast21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")# 统计字符串中某字符串的出现次数, count
my_str = "gufeng and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度, len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

作为数据容器，字符串有如下特点：
只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
允许重复字符串存在
不可以修改（增加或删除元素等）
支持for循环

基本和列表、元组相同
不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。
不同于列表，相同于元组的在于：字符串不可修改

6. 数据容器(序列)的切片

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

如图，序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

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

"""
演示对序列进行切片操作
"""# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

7.数据容器:set(集合)

基本语法：

和列表、元组、字符串等定义基本相同：
列表使用：[]
元组使用：()
字符串使用：“”
集合使用：{}

"""
演示数据容器集合的使用
"""# 定义集合
my_set = {"古典", "民谣", "gufeng", "古典", "民谣", "gufeng", "古典", "民谣", "gufeng"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")# 添加新元素
my_set.add("Python")
my_set.add("古典")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("民谣")
print(f"my_set移除民谣后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"古典", "民谣", "gufeng"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:print(f"集合的元素有：{element}")

8.数据容器:dict(字典、映射)

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

"""
演示数据容器字典的定义
"""# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")
# 定义嵌套字典
stu_score_dict = {"王力鸿": {"语文": 77,"数学": 66,"英语": 33}, "周杰轮": {"语文": 88,"数学": 86,"英语": 55}, "林俊节": {"语文": 99,"数学": 96,"英语": 66}
}
print(f"学生的考试信息是：{stu_score_dict}")# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")

"""
演示字典的常用操作
"""
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:print(f"字典的key是:{key}")print(f"字典的value是：{my_dict[key]}")# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:print(f"2字典的key是:{key}")print(f"2字典的value是：{my_dict[key]}")# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

字典的特点：
可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复（重复会覆盖）
不支持下标索引
可以修改（增加或删除更新元素等）
支持for循环，不支持while循环

9.数据容器的统用操作

数据容器特点对比:

基于各类数据容器的特点，它们的应用场景如下：
列表：一批数据，可修改、可重复的存储场景
元组：一批数据，不可修改、可重复的存储场景
字符串：一串字符串的存储场景
集合：一批数据，去重存储场景
字典：一批数据，可用Key检索Value的存储场景

python数据容器相关推荐

python入门(六)——python数据容器
系列文章目录 python入门(一)--你好python python入门(二)--python基础语法 python入门(三)--python判断语句 python入门(四)--python循环语句 ...
python数据容器专题
Python容器专题 [导读] 容器通常属于序列(如列表或元组)或映射(如字典),但也存在其他形式的容器.依据Python官方的说法,Python语言中标准内建容器包括 dict , list , s ...
Python数据容器：list + set + tuple + dict + str 简记黑马课程
# -*- coding:utf8 -*- """ # editor: hjjdreamer # create-time: 2022/11/16-23:08 # Pyth ...
【Python基础】Python数据容器（集合）
文章目录数据容器:set(集合) 集合的定义集合的常用操作-修改 (1)添加新元素 (2)移除元素 (3)从集合中随机取出元素 (4)清空集合 (5)取出两个集合的差集 (6)消除两个集合的差 ...
【Python基础】Python数据容器（字典）
文章目录数据容器:dict(字典.映射) 字典的定义字典数据的获取字典的嵌套字典的注意事项字典的常用操作 (1)新增元素 (2)更新元素 (3)删除元素 (4)清空字典 (5)获取全部key ...
【Python基础】Python数据容器（元组）
文章目录数据容器:tuple(元组) 元组的定义格式元组的相关操作元组的相关操作-注意事项元组的特点数据容器:tuple(元组) 元组的定义格式元组定义:定义元组使用小括号,且使用逗号隔开 ...
【Python基础】Python数据容器（字符串）
文章目录数据容器:str(字符串) 字符串的常用操作 (1)查找特定字符串的下标索引值 (2)字符串的替换 (3)字符串的分割 (4)字符串的规整操作(去前后空格) (5)字符串的规整操作(去前后指 ...
python数据容器之集合、字典
set集合基本语法: # 定义集合字面量 (元素,元素,--元素) # 定义集合变量变量名称 = (元素,元素,--元素) # 定义空集合变量名称 = set() 列表使用 [] 元组使用 () ...
3. Python 数据容器（列表、元组、字符串、集合、字典）
1. 数据容器入门数据容器:一种可以容纳多份数据的数据类型,容纳的每份数据称为一个元素. 每个元素,可以是任意类型数据,如:字符串.数字.布尔等. 数据容器根据特点的不同,如: 是否支持重复元素是 ...
Python数据容器(五)
python学习之旅(五) 学习汇总入口[Python]学习汇总(3万字+思维导图) 写作不易,如果您觉得写的不错,欢迎给博主来一波点赞.收藏~让博主更有动力吧! 一.数据容器一种可以容纳多份数据的 ...

python数据容器