python基础知识总结（第四篇）：python数据容器_python的数据就是数据容器-CSDN博客

# 定义一个列表 list
my_list = ["xiaowang", "itcast", "python"]
print(my_list)
print(type(my_list))

my_list = ["xiaowang", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

运行结果：

（3）列表的常用操作

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

mylist = ["itcast", "xiaowang", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("xiaowang")
print(f"xiaowang在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = 666
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", "xiaowang", "python"]

# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "xiaowang", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "xiaowang", "itcast", "xiaowang", "python"]
mylist.remove("xiaowang")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["itcast", "xiaowang", "itcast", "xiaowang", "python"]
count = mylist.count("xiaowang")
print(f"列表中xiaowang的数量是：{count}")

# 10. 统计列表中全部的元素数量
mylist = ["itcast", "xiaowang", "itcast", "xiaowang", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

运行结果：

（4）列表的特点

可以容纳多个元素(上限为2**63-1)
可以容纳不同类型的元素(混装)
数据是有序存储的(有下标序号)
允许重复数据存在
可以修改

（5）列表的遍历

遍历：将容器内的元素依次取出，并处理，称之为遍历操作

使用while遍历：

index = 0

while index < len(列表名)

元素 = 列表名[index]

对元素进行处理

index += 1

mylist = [666, "程序员", "Python"]
# 循环控制变量：通过下标索引来控制，默认是0
# 每一次循环，将下标索引变量+1
# 循环条件：下标索引变量 < 列表的元素数量
# 定义一个变量，用来标记列表的下标
index = 0  # 初始下标为0
while index < len(mylist):
    # 通过index变量取出对应下标的元素
    element = mylist[index]
    print(f"列表的元素：{element}")
    # 将循环变量（index）每一次循环都+1
    index += 1

运行结果：

使用for遍历

for 临时变量 in 数据容器:

对临时变量进行处理

mylist = [1, 2, 3, 4, 5]
# for 临时变量 in 数据容器:
for element in mylist:
    print(f"列表的元素有：{element}")

运行结果：

三、数据容器：tuple(元组)

（1）元组的定义

语法：

字面量：(元素1,元素2,元素3,元素4,元素5,.......)
定义变量：变量名称 = (元素1,元素2,元素3,元素4,元素5,.......)
定义空元组：变量名称 = () 或者变量名称 = 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}")

运行结果：

（2）元组的操作

方法	作用
元组名.index(元素)	查找某个元素，如果存在返回对应的下标，否则报错
元组名.count(元素)	统计某个数据在当前元组出现的次数
元组名.len(元组)	统计元组内的元素个数

# 元组的操作：index查找方法
t6 = (111, 666, "Python")
index = t6.index(666)
print(f"在元组t6中查找666，的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("教育", "程序员", "程序员", "程序员", "Python")
num = t7.count("程序员")
print(f"在元组t7中统计程序员的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("教育", "程序员", "程序员", "程序员", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")

运行结果：

（3）元组的特点

可以容纳多个数据
可以容纳不同类型的数据(混装)
数据是有序存储的(有下标序号)
允许重复数据存在
不可以修改
遍历方式和列表相同

四、数据容器：str(字符串)

（1）字符串常用操作

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

my_str = "itxiaowang 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 itxiaowang itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")

# strip方法
my_str = "  itxiaowang and itcast  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "2112itxiaowan2112g and itcast12"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")

# 统计字符串中某字符串的出现次数, count
my_str = "itxiaowang and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度, len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

运行结果：

（2）字符串的特点

只可以存储字符串
长度任意
支持下标索引
允许重复字符串存在
不可以修改
遍历方法和列表相同

五、序列的切片

序列：内容连续、有序，可使用下标索引的一类数据容器。

属于序列的数据容器有：列表、元组、字符串

切片：从一个序列中，取出一个子序列

语法：序列名[起始下标:结束下标:步长]

说明：

起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
步长可以省略，省略步长为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}")

运行结果：

六、数据容器：set(集合)

（1）集合的定义

语法：

字面量：{元素1,元素2,元素3,元素4,元素5,.......}
定义变量：变量名称 = {元素1,元素2,元素3,元素4,元素5,.......}
定义空集合：变量名称 = set()

# 定义集合
my_set = {"教育", "程序员", "it", "教育", "程序员", "it", "教育", "程序员", "it"}
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)}")

运行结果：

（2）集合的操作

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

my_set = {"教育", "程序员", "it", "教育", "程序员", "it", "教育", "程序员", "it"}
# 添加新元素
my_set.add("Python")
my_set.add("教育")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("程序员")
print(f"my_set移除程序员后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"教育", "程序员", "it"}
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}个")

运行结果：

（3）集合的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是无序存储的（不支持下标索引）
不允许重复数据存在
可以修改（增加或删除元素等）
支持for循环，不支持while循环

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

运行结果：

七、数据容器：dict(字典)

（1）字典的定义

语法：

字面量：{key: value, key: value, key: value,.......}
定义变量：变量名称 = {key: value, key: value, key: value,.......}
定义空集合：变量名称 = {} 或者变量名称 = dict()

说明

键值对的Key和Value可以是任意类型（Key不可为字典）
字典内Key不允许重复，重复添加等同于覆盖原有数据
字典不可用下标索引，而是通过Key检索Value

# 定义字典
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}")
# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")

运行结果：

（2）字典的操作

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

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}个")

运行结果：

（3）字典的特点

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

八、数据容器的通用操作

（1）通用操作

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