关于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 += 1while_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 = 0new_list = []while index < len(list):    if list[index] % 2 == 0:        new_list.append(list[index])    index += 1for 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 = 0while index < len(str):    print(str[index])    index += 1for 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]['工资'] += 1000print(dic)

总结

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