Python入门到精通(五)——Python数据容器

momo_via

已于 2024-02-02 16:28:36 修改

阅读量708

点赞数 33

分类专栏： Python学习之路文章标签： python pycharm 开发语言

于 2024-01-30 09:31:40 首次发布

本文链接：https://blog.csdn.net/momohhhhh/article/details/135864151

版权

Python学习之路专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Python数据容器

前言

1、定义：一种可以存储多个元素的Python数据类型

2、类型：list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

一、list 列表

1、定义

列表内的每一个数据，称之为元素
以 [ ] 作为标识
列表内每一个元素之间用, 逗号隔开
列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
数据是有序存储的（有下标序号）
允许重复数据存在
可以修改（增加或删除元素等）

代码示例
# 定义一个列表
my_list1 = ["momo_via", 2024, True]
print(my_list1)  # ['momo_via', 2024, True]
print(type(my_list1))  # <class 'list'>
# 定义一个嵌套的列表
my_list2 = ["CSDN", my_list1]
print(my_list2)  # ['CSDN', ['momo_via', 2024, True]]
print(type(my_list2))  # <class 'list'>

2、列表的下标索引

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

嵌套列表

代码示例
# 列表的下标索引
# 正向
print(my_list1[0])  # momo_via
# 反向
print(my_list1[-1])  # True
# 取出嵌套列表的元素
print(my_list2[-1][0])  # momo_via

3、常用操作

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

代码示例

# 列表的常用方法
# 列表的查询  列表.index(元素)
my_list = ["momo_via", 2024, True]
print(my_list.index("momo_via"))  # 0
# 修改指定位置的值
my_list[0] = "CSDN"
print(my_list)  # ['CSDN', 2024, True]
# 插入元素  列表.insert(下标，元素)
my_list.insert(1, "best")
print(my_list)  # ['CSDN', 'best', 2024, True]
# 追加单个元素（尾部） 列表.append(元素)
my_list.append("python")
print(my_list)  # ['CSDN', 'best', 2024, True, 'python']
# 追加一批元素  列表.extend(元素)
my_list3 = [1, 2, 3]
my_list.extend(my_list3)
print(my_list)  # ['CSDN', 'best', 2024, True, 'python', 1, 2, 3]
# 删除列表元素
# del 列表
del my_list[3]
print(my_list)  # ['CSDN', 'best', 2024, 'python', 1, 2, 3]
# 列表.pop(下标) 取出元素后删除
ele = my_list.pop(3)
print(f"列表元素{my_list}，被取出的元素是：{ele}")  # 列表元素['CSDN', 'best', 2024, 1, 2, 3]，被取出的元素是：python
# 删除某元素在列表中的第一个匹配项
my_list = ['CSDN', 'CSDN', 'best', 2024, 'CSDN']
my_list.remove('CSDN')
print(my_list)  # ['CSDN', 'best', 2024, 'CSDN']
# 清空列表
my_list.clear()
print(my_list)  # []
# 统计列表内某元素的数量
my_list = ['CSDN', 'CSDN', 'best', 2024, 'CSDN']
count = my_list.count('CSDN')
print(count)  # 3
# 统计列表中全部的元素数量
count = len(my_list)
print(count)  # 5

4、列表的遍历

可以使用while循环和for循环

代码示例

while 循环

# while 循环
def list_while():
    """
    使用while循环遍历列表
    :return: None
    """
    my_list = ['CSDN', 'best', 2024, 'python']
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次索引将下标变量 +1
    index = 0
    while index<len(my_list):
        ele = my_list[index]
        print(ele)
        index += 1


list_while()

for循环

# for 循环
def list_for():
    """
    使用for循环遍历列表
    :return: None
    """
    my_list = ['CSDN', 'best', 2024, 'python']
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次索引将下标变量 +1
    for index in my_list:
        print(index)

list_for()

二、tuple 元组

1、定义

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
元组只有一个数据，这个数据后面要添加逗号
元组也支持嵌套
不可以修改元组

可以修改元组内的list的内容（修改元素、增加、删除、反转等）

可以使用for循环和while循环遍历

代码示例
# 定义元祖
t1 = ("momo_via", 2024, True)
t2 = ()
t3 = tuple()
t4 = ("csdn",)  # 单个元素的元组后面要加一个逗号
print(type(t1))
print(type(t2))
print(type(t3))
print(type(t4))
# 嵌套元组
t5 = (1, 2, 3)
t6 = (t1, t5)
print(t6)  # (('momo_via', 2024, True), (1, 2, 3))
# 下标索引取内容
print(t6[0][1])  # 2024

2、常用操作

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

代码示例

# 元组的使用
t7 = ("momo_via", 2024, True, 2024, "csdn")
# index
print(t7.index(2024))  # 1
# count
print(t7.count(2024))  # 2
# len
print(len(t7))  # 5
# while 循环遍历
index = 0
while index < len(t7):
    print(t7[index])
    index += 1
# for 循环遍历
for i in t7:
    print(i)

三、str 字符串

1、定义

从前向后，下标从0开始
从后向前，下标从-1开始
无法修改，如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改
支持while循环和for循环
只可以存储字符串
允许重复字符串存在

2、常用操作

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

代码示例

my_str = "CSDN IS BEST"
# 通过下标索引取值
print(my_str[-1])  # T
# index  索引
print(my_str.index("IS"))  # 5
# replace 替换
new_my_str = my_str.replace("BEST", '最好的')
print(new_my_str)
# split 分割
print(my_str.split(' '))  # ['CSDN', 'IS', 'BEST']
# strip 规整操作
my_str = "   CSDN IS BEST   "
# 默认去除前后空格
print(my_str.strip())  # "CSDN IS BEST"
# 统计某字符出现的次数
print(my_str.count("S"))  # 3
# 统计字符串的长度
print(len(my_str))  # 18

四、容器序列的切片

内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。
序列[起始:结束:步长]

起始可以省略，省略从头开始

结束可以省略，省略到尾结束

步长可以省略，省略步长为1（可以为负数，表示倒序执行）

代码示例

# 对list进行切片，从1开始，4结束，步长为1
my_list = [0,1,2,3,4,5,6]
# 步长默认为1 可以省略不写
print(my_list[1:4]) # [1, 2, 3]
# 对tuple进行切片，从头开始，到最后结束，步长为1
my_tuple = (0,1,2,3,4,5,6)
# 起始和结束可以不写，默认头和尾，步长默认1
print(my_tuple[:])  # (0, 1, 2, 3, 4, 5, 6)
# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "01234567"
print(my_str[::2])  # 0246
# 对str进行切片，从头开始，到最后结束，步长为-1
# 等同于序列反转
print(my_str[::-1])  # 76543210
# 对列表进行切片，从3开始，到1结束，步长为-1
print(my_list[3:1:-1])  # [3, 2]
# 对元组进行切片，从头开始，到尾结束，步长为-2
print(my_tuple[::-2])  # (6, 4, 2, 0)

五、set 集合

1、定义

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

2、常用操作

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

代码示例

# 定义
my_set = {"CSDN", "python", 2024}
my_set2 = set()
# 添加新元素
my_set.add("momo_via")
print(my_set)  # {2024, 'momo_via', 'python', 'CSDN'}
# 移除元素
my_set.remove(2024)
print(my_set)  # {'python', 'momo_via', 'CSDN'}
# 随机取出一个元素
print(my_set.pop())  # CSDN
# 清空集合
print(my_set.clear())  # None
# 取两个集合的差集
my_set = {"CSDN", "python", 2024}
my_set2 = {"CSDN", "momo_via", 2024}
print(my_set.difference(my_set2))  # {'python'}
# 消除两个集合的差集
my_set.difference_update(my_set2)
print(my_set)  # {'python'}
print(my_set2)  # {2024, 'CSDN', 'momo_via'}
# 两个集合合并为一个
print(my_set.union(my_set2))  # {'python', 'CSDN', 2024, 'momo_via'}
# 统计集合元素数量
print(len(my_set))  # 1
# 集合的遍历
# 不支持下标索引，所以不能用while
for i in my_set2:
    print(i)  # 2024 CSDN momo_via

六、dict 字典、映射

1、定义

使用{ }存储原始，每一个元素是一个键值对
每一个键值对包含Key和Value（用冒号分隔）
键值对之间使用逗号分隔
Key和Value可以是任意类型的数据（key不可为字典）
可以容纳多个数据
可以通过Key获取到Value，Key不可重复（重复会覆盖）
不支持下标索引
可以修改（增加或删除更新元素等）
支持for循环，不支持while循环

代码示例

# 定义字典
my_dict = {"momo_via": 24, "csdn": 2024}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
# 基于key取value
print(my_dict["csdn"])  # 2024
# 字典的嵌套
stu_score = {
    "张三": {
        "语文": 80,
        "数学": 98,
        "英语": 92,
    },
    "李四": {
        "语文": 95,
        "数学": 88,
        "英语": 85,
    }
}
print(stu_score["张三"]["语文"])  # 80
# 新增元素
stu_score = {
    "张三": 88,
    "李四": 95
}
stu_score["王二"] = 90
print(stu_score)  # {'张三': 88, '李四': 95, '王二': 90}
# 更新元素
stu_score["王二"] = 85
print(stu_score)  # {'张三': 88, '李四': 95, '王二': 85}
# 删除元素
stu_score.pop("王二")
print(stu_score)  # {'张三': 88, '李四': 95}
# 清空元素
print(stu_score.clear())  # None
# 获取全部的key
stu_score = {
    "张三": 88,
    "李四": 95
}
keys = stu_score.keys()
print(keys)  # dict_keys(['张三', '李四'])
# 遍历字典
# 通过获取到全部的key
for i in keys:
    print(i)
    print(stu_score[i])
# for 循环
for i in stu_score:
    print(i)
    print(stu_score[i])
# 字典元素个数
print(len(stu_score))  # 2

2、常用操作

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

练习题

代码示例

# 组织字典记录数据
info_dict = {
    '王力红': {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    '周杰轮': {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    '林俊结': {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    '张雪有': {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    '刘德滑': {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    },
}
# for 循环遍历字典
for name in info_dict:
    # if 条件判断符合条件员工
    if info_dict[name]["级别"] == 1:
        # 升职加薪操作
        # 获取到员工的信息字典
        employee_info_dict = info_dict[name]
        # 修改员工的信息
        employee_info_dict["级别"] = 2  # 级别+1
        employee_info_dict["工资"] += 1000  # 工资+1000
        # 将员工的信息更新回info_dict
        info_dict[name] = employee_info_dict
# 输出结果
print(info_dict)

输出