一文带你搞懂Python中的数据容器

一、数据容器：list(列表)

列表内的每一个数据，称之为元素

• 以 [] 作为标识
• 列表内每一个元素之间用, 逗号隔开

定义语法：

[元素1, 元素2, 元素3, ......]

例：

list = ['iii', 666, '你好']

1.1 list取出元素

列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增或者递减

语法：列表[下标]，即可取出

1.2 列表的常用操作（方法）

1.2.1 列表的查询功能（方法）

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

1.2.2 列表的修改功能（方法）

修改特定位置（索引）的元素值：

语法：列表[下标] = 值

可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

插入元素：

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

追加元素:

语法：列表.append(元素)，将指定元素，追加到列表的尾部

追加元素方式2：

语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部

删除元素：

• 语法1：del 列表[下标]
• 语法2：列表.pop(下标)

删除某元素在列表中的第一个匹配项:

语法：列表.remove(元素)

清空列表内容:

语法：列表.clear()

统计某元素在列表内的数量

语法：列表.count(元素)

1.2.3 列表的查询功能（方法）

统计列表内，有多少元素

语法：len(列表)

可以得到一个int数字，表示列表内的元素数量

list = [21, 25, 21, 23, 22, 20]

list.append(31)
list.extend([29, 33, 30])
listone = list.pop()
idx = list.index(31)
print(idx)

1.3 列表的特点

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

1.4 列表的遍历

1.4.1 列表的遍历 - while循环

def while_list():
    list = [11, 12, 13]
    index = 0
    while index < len(list):
        el = list[index]
        print(f'元素：{el}')

        index += 1

while_list()

1.4.2 列表的遍历 - for循环

def for_list():
    list = [1, 2, 3, 4, 5]
    for v in list:
        print(f'元素：{v}')

for_list()

练习案例：取出列表内的偶数

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
index = 0
new_list = []
while index < len(list):
    if list[index] % 2 == 0:
        new_list.append(list[index])

    index += 1

for val in list:
    if val % 2 == 0:
        new_list.append(val)

print(new_list)

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

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

元组一旦定义完成，就不可修改

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

元组也可以被遍历，同列表一样。

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

t1 = (1, 11)
print(f'{t1}, type:{type(t1)}')
num = t1.index(11)

元组的特点:

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

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

3.1 字符串的下标（索引）

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

同元组一样，字符串是一个：无法修改的数据容器。

所以：

• 修改指定下标的字符 （如：字符串[0] = “a”）
• 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
• 追加字符等 （如：字符串.append()）
• 均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

3.2 字符串常用操作汇总

3.3 字符串的遍历

同列表、元组一样，字符串也支持while循环和for循环进行遍历

str = '小小叮当'
index = 0
while index < len(str):
    print(str[index])
    index += 1


for v in str:
    print(v)

3.4 字符串的特点

作为数据容器，字符串有如下特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持for循环

四、数据容器（序列）的切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列

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

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

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

• 步长1表示，一个个取元素
• 步长2表示，每次跳过1个元素取
• 步长N表示，每次跳过N-1个元素取
• 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

my_list = [1, 2, 3, 4, 5]
print(my_list[1:4:2])

my_tuple = (0, 1, 2, 3, 4, 5, 6)
print(my_tuple[0:6:2])
str = 'ay，呀当叮小来，nohtyP学'
new_str = str[::-1]
# print(new_str)
list = new_str.split('，')
print(list[1].replace('来', ''))

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

集合的定义：

# 定义集合字面量
{元素,元素, ..., 元素}
# 定义集合变量
变量名称 = {元素, 元素, ..., 元素}
# 定义空集合 
变量名称 = set()

集合的特点：

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

例：

my_list = ['111', '222', '333', '111', '333', 'itit', 'hehe', 'itit']
new_set = set()

for val in my_list:
    new_set.add(val)

print(new_set)

六、数据容器：dict(字典、映射)

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

注意：

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

提示：

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

dic = {
    '王': {
        '部门': '科技部',
        '工资': 3000,
        '级别': 1
    },
    '周': {
        '部门': '市场部',
        '工资': 5000,
        '级别': 2
    },
    '林': {
        '部门': '市场部',
        '工资': 7000,
        '级别': 3
    },
    '张': {
        '部门': '科技部',
        '工资': 4000,
        '级别': 1
    },
}

for key in dic:
    if dic[key]['级别'] == 1:
        dic[key]['级别'] += 1
        dic[key]['工资'] += 1000

print(dic)