关于python:五Python数据容器

Python 数据容器

提醒：本文依据 b 站黑马 python 课整顿

链接指引 => 2022 新版黑马程序员 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 列表的特点

1. 能够包容多个元素（下限为 2 **63-1、9223372036854775807 个）
2. 能够包容不同类型的元素（混装）
3. 数据是有序存储的（有下标序号）
4. 容许反复数据存在
5. 能够批改（减少或删除元素等）

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)

总结

以上就是 Python 数据容器，之后会继续更新，欢送大家点赞关注呀～～