Python数据容器

• 一、分类
• 二、数据容器：list列表
  • 1.定义语法
  • 2.下标索引
  • 3.常用操作
  • 4.list（列表）的遍历之for循环
• 三、数据容器：str字符串
  • 1.常用操作
• 四、数据容器：dict字典
  • 1.获取字典数据
  • 2.字典的嵌套及内容获取
  • 3.常用操作
• 五、数据容器对比总结

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

一、分类

根据特点的不同分类数据容器（是否支持重复元素、是否可以修改、是否有序等）：

1. 列表（list）
2. 元组（tuple）
3. 字符串（str）
4. 集合（set）
5. 字典（dict）

二、数据容器：list列表

1.定义语法

列表的定义语法：

[元素，元素，元素，...]

元素：数据容器内的每一份数据，都称之为元素，以[]作为标识，列表内每一个元素之间用逗号“，”隔开

元素的数据类型无限制，甚至元素可以是列表，这样就定义了嵌套列表。

2.下标索引

列表的每个元素的编号称之为下标索引：

• 从前向后的方向，编号从0开始递增。
• 从后向前的方向，编号从-1开始递减。

通过下标索引取出对应位置的元素：

列表[下标]

下标索引的注意事项：

注意下标索引的取值范围，超出范围无法取出元素，并且会报错。

# 定义一个列表
my_list = ['zhangsan','lisi','ydh']
print(my_list)

print(type(my_list)) # <class 'list'>  使用type()函数打印出my_list的类型

输出结果如下：

['zhangsan', 'lisi', 'ydh']
<class 'list'>

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

print(my_list[1][1]) # 取出嵌套列表中的元素  5

输出结果为：5

my_list = ['tom','rose','jack']
# 从前向后
print(my_list[0]) # tom
print(my_list[1]) # rose

# 从后向前
print(my_list[-1]) # jack

print(my_list[-2]) # rose
 
print(my_list[3])

输出结果为：

tom
rose
jack
rose

print(my_list[3])
IndexError: list index out of range

3.常用操作

（1）清空列表内容

my_list = [1, 2, 3]

my_list.clear()
print(my_list)   # 结果： []

（2）统计列表中有多少元素

my_list = [1, 2, 3, 4, 5]

print(len(my_list))  # 结果：5

4.list（列表）的遍历之for循环

语法：for 临时变量 in 数据容器：

​ 对临时变量进行处理

下面是一个例子：

def Zk_Output(self):
    self.zk_info_list.clear() # 第一，使用列表前先清理，保证后续append时列表是空的
    self.yc_out_list.clear()
    # 存储钻孔信息到字典
    zk_info_dict = {
        'Zk_No': self.Zk_No,
        'Zk_name': self.Zk_name,
        'Zk_Yc_Count': self.Zk_Yc_Count
    }
    self.zk_info_list.append(zk_info_dict) # 将字典加到zk_info_list这个列表里

    for yc in self.yc_class_list:
        self.yc_out_list.append(yc.Yc_Output())

    data = self.zk_info_list + self.yc_out_list
    return data

for yc in self.yc_class_list: 遍历self.yc_class_list列表中的每个yc元素

self.yc_out_list.append(yc.Yc_Output())：调用yc.Yc_Output()方法，并将返回值添加到yc_out_list这个列表里去

三、数据容器：str字符串

字符串是字符的容器，一个字符串可以存放任意数量的字符

注：字符串是无法修改的数据容器，即字符串一旦被定义，无法修改里面的内容，可以给这串字符串再拼接其他字符串，但它形成的是新的字符串，已经不是原来的那个

1.常用操作

（1）字符串的分割

name = "是故无贵无贱，无长无少，道之所存，师之所存也"
name_list = name.split("，")

print(name_list)

拆分结果为：

['是故无贵无贱', '无长无少', '道之所存', '师之所存也']

（2）去前后格

my_str = " alfhuu and aklfe "

print(my_str.strip())

去除后结果为：

alfhuu and aklfe

（3）去前后指定字符串

my_str = "12alfhuu and aklfe21"

print(my_str.strip("12"))

结果为：

alfhuu and aklfe

注：传入的是"12"，但其实是按照单个字符，即：”1”和”2”都会移除

四、数据容器：dict字典

字典的定义使用{},不过存储的元素是一个个的：键值对

• 使用{}存储元素，每一个元素都是一个键值对
• 每一个键值对包含key和value（用冒号分隔）
• 键值对之间使用逗号分隔
• Key和Value可以是任意类型的数据(Key不可为字典)
• Key不可重复，重复会对原有数据覆盖

1.获取字典数据

字典不可以使用下标索引但可以通过Key值来取得对于的Value

stu_score = {"张三": 99, "周赞": 87, "李四": 90}
print(stu_score["张三"])
print(stu_score["周赞"])
print(stu_score["李四"])

2.字典的嵌套及内容获取

stu_score = {
    "张三": {"语文": 77, "数学": 86, "英语": 90},
    "周赞": {"语文": 89, "数学": 74, "英语": 85},
    "李四": {"语文": 70, "数学": 99, "英语": 79},
}
print(stu_score["张三"])
print(stu_score["周赞"]["语文"])
print(stu_score["李四"]["数学"])

3.常用操作

（1）新增元素

stu_score = {
    "张三": 77,
    "周赞": 87,
    "李四": 90
}
stu_score["王五"] = 81
print(stu_score)

语法：字典[Key] = Value，结果：字典被修改，新增了元素

（2）更新元素

stu_score = {
    "张三": 77,
    "周赞": 87,
    "李四": 90
}
stu_score["张三"] = 81
print(stu_score)

语法：字典[Key] = Value，结果：字典被修改，元素被更新

（3）获取全部的key

stu_score = {
    "张三": 77,
    "周赞": 87,
    "李四": 90
}
keys = stu_score.keys()
print(keys)

语法：字典.keys()，结果：得到字典中的全部Key

（4）遍历字典

stu_score = {
    "张三": 77,
    "周赞": 87,
    "李四": 90
}
for key in stu_score.keys():
    print(f"学生:{key}，" f"分数:{stu_score[key]}")

语法：for key in 字典.keys()，结果：得到字典中的全部Key以及对应的值

（5）字典常用操作总结

五、数据容器对比总结