Python数据容器(五)

news2024/12/28 21:05:28

python学习之旅（五）
👍基础语法部分笔记(一)
👍条件判断部分笔记(二)
👍循环语句部分笔记(三)
👍函数使用部分笔记(四)
👍数据容器部分笔记(五)

一.数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

  • 每一个元素，可以是任意类型的据数，如字符串、数字、布尔等
  • 根据特点的不同可分为5类:列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

请添加图片描述

二.列表(list)

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

(1) 基本格式

# 定义列表
变量名称 = [元素1, 元素2, 元素3, 元素4, 元素5]
# 定义空列表
变量名称 = []
变量名称 = list()

  • 以中括号 [] 作为标识

  • 列表内每一个元素之间用, 逗号隔开

  • 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

  • 使用示例:

my_list_1 = ["观止", 20, True, ["guanzhi", 20]]
my_list_2 = ["观止", 20, True]
print(my_list_2)
print(type(my_list_1))
# 输出
# ['观止', 20, True]
# <class 'list'>

(2) 列表的下标（索引）

我们可以使用下标索引从列表中取出特定位置的数据

  • 列表中的每一个元素，都有其对应位置下标索引
  • 要注意下标索引的取值范围(有值的位置)，超出范围(没值的位置)无法取出元素，并且会报错
  • 语法：变量 = 列表[下标索引]

(2.1) 正向索引

请添加图片描述

  • 从前向后的方向，从0开始，依次递增

  • 使用示例:

# 语法： 列表[下标索引]
my_list = ["李白", "章北海", "杜甫"]
print(my_list[0]) # 打印 李白
print(my_list[1]) # 打印 章北海
print(my_list[2]) # 打印 杜甫

(2.2) 反向索引

请添加图片描述

  • 从后向前：从**-1**开始，依次递减（-1、-2、-3…）

  • 使用示例:

my_list = ["李白", "章北海", "杜甫"]
print(my_list[-1]) # 打印 杜甫
print(my_list[-2]) # 打印 章北海
print(my_list[-3]) # 打印 李白

(2.3) 嵌套列表的索引

请添加图片描述

  • 如果列表是嵌套的列表，同样支持下标索引，且用法与上述类似

  • 使用示例:

# 语法： 列表[外层列表下标索引][内层列表下标索引]
my_list = [["李白", "章北海"], ["罗辑", "杜甫"]]
print(my_list[0][0]) # 打印 李白
print(my_list[0][1]) # 打印 章北海
print(my_list[1][0]) # 打印 罗辑
print(my_list[1][1]) # 打印 杜甫

(3) 列表的常用操作

列表提供了一系列方法：如果将函数定义为class（类）的成员，那么函数称之为：方法

使用方式作用
列表.append(元素)向列表中追加一个元素
列表.extend(容器)将数据容器的内容依次取出，追加到列表尾部
列表.insert(下标, 元素)在指定下标处，插入指定的元素
del 列表[下标]删除列表指定下标元素
列表.pop(下标)删除列表指定下标元素
列表.remove(元素)从前向后，删除此元素第一个匹配项
列表.clear()清空列表
列表.count(元素)统计此元素在列表中出现的次数
列表.index(元素)查找指定元素在列表的下标 找不到报错ValueError
len(列表)统计容器内有多少元素
  • 不需要硬记下来,有一个模糊印象，知晓有这样的用法,需要的时候，随时查阅资料即可

(3.1) 查询元素

查找某元素的下标

  • 查找指定元素在列表的下标，如果找不到，报错ValueError
  • 语法：列表.index(元素)
my_list = ["李白", "章北海", "罗辑", "杜甫"]
print(my_list.index("罗辑")) # 打印 2
print(my_list.index("观止")) # 打印 ValueError: '观止' is not in list

(3.2) 修改元素

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

  • 直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）
  • 语法一：列表[下标] = 值
my_list = ["李白", "章北海", "罗辑", "杜甫"]
my_list[0] = "观止"
my_list[-1] = "study"
print(my_list) # 打印 ['观止', '章北海', '罗辑', 'study']

(3.3) 插入元素

在指定的下标位置，插入指定的元素

  • 语法：列表.insert(下标, 元素)
my_list = ["李白", "章北海", "罗辑"]
my_list.insert(1, "观止")
print(my_list) # 打印 ['李白', '观止', '章北海', '罗辑']

(3.4) 追加元素

将指定元素，追加到列表的尾部

  • 语法一：列表.append(元素)
my_list = ["李白", "章北海", "罗辑"]
my_list.append("观止")
print(my_list) # 打印 ['李白', '章北海', '罗辑', '观止']
  • 语法一：列表.extend(其它数据容器)
  • 将其它数据容器的内容取出，依次追加到列表尾部
my_list_1 = ["李白", "章北海"]
my_list_2 = ["罗辑", "观止"]
my_list_1.extend(my_list_2)
print(my_list_1) # 打印 ['李白', '章北海', '罗辑', '观止']

(3.5) 删除元素

  • 语法一:del 列表[下标]
my_list = ["李白", "章北海", "罗辑"]
del my_list[0]
print(my_list) # 打印 ['章北海', '罗辑']
  • 语法二:列表.pop(下标)
my_list = ["李白", "章北海", "罗辑"]
my_list.pop(0)
print(my_list) # 打印 ['章北海', '罗辑']
  • 语法三:列表.remove(元素)
  • 删除某元素在列表中的第一个匹配项
my_list = ["李白", "章北海", "罗辑", "李白"]
my_list.remove("李白")
print(my_list) # 打印 ['章北海', '罗辑', '李白']

(3.6) 清空列表内容

  • 语法:列表.clear()
my_list = ["李白", "章北海", "罗辑"]
my_list.clear()
print(my_list) # 打印 []

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

  • 语法:列表.count(元素)
my_list = ["李白", "章北海", "罗辑", "李白"]
num = my_list.count("李白")
print(num) # 打印 2

(3.8) 统计列表内有多少元素

  • 语法:len(列表)
my_list = ["李白", "章北海", "罗辑", "李白"]
print(len(my_list)) # 打印 4

(4) 列表的遍历

将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

  • 可以使用循环遍历列表的元素

  • 通过列表[下标]的方式在循环中取出列表的元素

  • 循环条件为 下标值 < 列表的元素数量

(4.1) while循环遍历

  • 基本格式
index = 0
while index < len(列表):
    元素 = 列表[index]
#    对元素进行处理
    index += 1
  • 使用示例：
my_list = [1,2,3,4]
index = 0
while index < len(my_list):
    num = my_list[index]
    print(num)
    index += 1 
# 输出
# 1
# 2
# 3
# 4

(4.2) for循环遍历

  • 依次取出元素并赋值到临时变量上,在每一次的循环中，可以对临时变量（元素）进行处理。
  • 基本格式：
for 临时变量 in 数据容器:
    对临时变量（元素）进行处理
  • 使用示例：
my_list = [1, 2, 3, 4]
for x in my_list:
    print(x)
# 输出
# 1
# 2
# 3
# 4

(4.3) for与while对比

  • 在循环控制上：

    • while循环可以自定循环条件，并自行控制

    • for循环不可以自定循环条件，只可以一个个从容器内取出数据

  • 在无限循环上：

    • while循环可以通过条件控制做到无限循环

    • for循环理论上不可以，因为被遍历的容器容量不是无限的

  • 在使用场景上：

    • while循环适用于任何想要循环的场景

    • for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

(5) 列表小结

  • 列表特点:

    • 可以容纳多个元素（上限为2**63-1、9223372036854775807个）

    • 可以容纳不同类型的元素（混装）

    • 数据是有序存储的（有下标序号）

    • 允许重复数据存在

    • 可以修改（增加或删除元素等）

三.元组(tuple)

元组同列表一样,但一旦定义完成，就不可修改

(1) 基本格式

# 定义元组
变量名称 = (元素1, 元素2, 元素3, 元素4, 元素5)
# 定义只有一个元素的元组
变量名称 = (元素1,)
# 定义空元组
变量名称 = ()
变量名称 = tuple()

  • 以小括号 () 作为标识

  • 列表内每一个元素之间用, 逗号隔开

  • 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

  • 使用示例:

my_tuple_1 = ("观止", 20, True, ("guanzhi", 20))
my_tuple_2 = ("观止", 20, True)
print(my_tuple_2)
print(type(my_tuple_1))
# 输出
# ('观止', 20, True)
# <class 'tuple'>
  • 元组只有一个数据，这个数据后面要添加逗号，否则不是元组
my_tuple = ("观止")
print(type(my_tuple)) # 打印 <class 'str'>
my_tuple = ("观止",)
print(type(my_tuple))  # 打印 <class 'tuple'>
  • 嵌套元组使用:
# 获取值方式与列表一致
my_tuple = ((1, 2, 3), (4, 5, 6))
print(my_tuple[0][0]) # 打印 1

(2) 元组的常用操作

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

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

(2.1) 查询元素

  • 根据下标(索引)取出数据
  • 语法：元组[下标索引]
my_tuple = ("观止", True, 20)
print(my_tuple[0])  # 打印 观止

  • 查找特定元素的第一个匹配项

  • 语法：元组.index(元素)

my_tuple = ("观止", True, "观止")
print(my_tuple.index("观止"))  # 打印 0

(2.2) 统计操作

  • 统计某个数据在元组内出现次数
  • 语法一：元组.count(元素)
my_tuple = ("观止", True, "观止")
print(my_tuple.count("观止"))  # 打印 2
  • 统计元组内元素个数
  • 语法二：len(元组)
my_tuple = ("观止", True, "观止")
print(len(my_tuple))  # 打印 3

(2.3) 注意事项

  • 不可以修改元组的内容，否则会直接报错
my_tuple = (1, True, "观止")
my_tuple[0] = 5 # 报错 'tuple' object does not support item assignment
  • 可以修改元组内的list的内容（修改元素、增加、删除、反转等）
my_tuple = (1, True, [2, 3, 4])
my_tuple[2][0] = 5
print(my_tuple) # 打印 (1, True, [5, 3, 4])
  • 不可以替换list为其它list或其它类型
my_tuple = (1, True, [2, 3, 4])
my_tuple[2] = [1, 2, 3] # 报错

(3) 元组小结

  • 可以与列表一样使用for与while循环遍历
  • 多数特性和list一致，不同点在于不可修改的特性
  • 可以容纳多个数据
  • 可以容纳不同类型的数据（混装）
  • 数据是有序存储的（下标索引）
  • 允许重复数据存在
  • 不可以修改（增加或删除元素等）

四.字符串(str)

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

  • 同元组一样,字符串是一个无法修改的数据容器

请添加图片描述

(1) 索引取值

  • 同列表、元组一样，字符串也可以通过下标进行访问
    • 从前向后，下标从0开始
    • 从后向前，下标从-1开始
name = "guanzhi"
print(name[0])  # 打印 g
print(name[-1])  # 打印 i

(2) 字符串的常用操作

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

(2.1) 查找元素

查找特定字符串的下标索引值

  • 语法：字符串.index(字符串)
name = "guanzhi"
print(name.index("a"))  # 打印 2

(2.2) 替换元素

将字符串内的全部：字符串1，替换为字符串2

  • 语法：字符串.replace(字符串1，字符串2）
name = "guanzhi"
new_name = name_1.replace("guan", "study")
print(name)  # 打印 guanzhi
print(new_name)  # 打印 studyzhi
  • 不是修改字符串本身，而是得到了一个新字符串

(2.3) 分割元素

按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

  • 语法：字符串.split(分隔符字符串）
name = "guanzhi,study,20"
new_list = name.split(",")
print(name)  # 打印 guanzhi,study,20
print(new_list)  # 打印 ['guanzhi', 'study', '20']
print(type(new_list))  # 打印 <class 'list'>
# 字符串按照给定的,进行了分割，变成多个子字符串，并存入一个列表对象中
  • 字符串本身不变，而是得到了一个列表对象

(2.4) 规整操作

  • 去前后空格以及换行符
  • 语法一：字符串.strip()
name = "  guanzhi  "
new_name = name.strip()
print(new_name)  # 打印 guanzhi
  • 去前后指定字符串
  • 语法二：字符串.strip(字符串)
name = "20guanzhi20"
new_name = name.strip("20")
print(name)  # 打印 20guanzhi20
print(new_name)  # 打印 guanzhi
  • 字符串本身不变，而是得到了一个新字符串

(2.5) 统计操作

  • 统计字符串中某字符串的出现次数
  • 语法一：字符串.count(字符串)
name = "20guanzhi20"
print(name.count("20"))  # 打印 2
  • 统计字符串的长度
  • 语法二：len(字符串)
name = "20guanzhi 20"
print(len(name))  # 打印 12
  • 数字（1、2、3…），字母（abcd、ABCD等），符号（空格、!、@、#、$等），中文均算作1个字符

(3) 字符串小结

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

  • 特点：

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

  • 基本和列表、元组相同

    • 不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。

    • 不同于列表，相同于元组的在于：字符串不可修改

五.数据容器（序列）的切片

序列：内容连续、有序，可使用下标索引的一类数据容器

切片：从一个序列中，取出一个子序列

  • 序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求
  • 序列支持切片，即：列表、元组、字符串，均支持进行切片操作

(1) 基本格式

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

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

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

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

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

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

(2) 基本用法

  • 用法
    • 起始下标可以省略，省略从头开始
    • 结束下标可以省略，省略到尾结束
    • 步长可以省略，省略步长为1（可以为负数，表示倒序执行）
  • 用法一：
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]  # 下标1开始，下标4（不含）结束，步长1
print(new_list)  # 结果：[2, 3, 4]
  • 用法二：
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]  # 从头开始，到最后结束，步长1
print(new_tuple)  # 结果：(1, 2, 3, 4, 5)
  • 用法三：
my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]       # 从头开始，到最后结束，步长2
print(new_list)       # 结果：[1, 3, 5]
  • 用法四：
my_str = "12345"
new_str = my_str[:4:2]  # 从头开始，到下标4（不含）结束，步长2
print(new_str)  # 结果："13"
  • 用法五：
my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]  # 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)  # 打印 [4, 3]
  • 注：
    • 这个操作对列表、元组、字符串是通用的
    • 此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
    • 起始位置，结束位置，步长（正反序）都是可以自行控制的

六.集合(set)

不支持元素的重复（自带去重功能）、并且内容无序

(1) 基本格式

# 定义集合
变量名称 = {元素1, 元素2, 元素3, 元素4, 元素5}
# 定义空集合
变量名称 = set()

  • 以大括号 {} 作为标识

  • 集合内每一个元素之间用, 逗号隔开

  • 集合可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

  • 使用示例：

my_set = {"观止", True, "观止"}
print(my_set)  # 打印 {True, '观止'}
  • 去重且无序

(2) 集合的遍历

集合不支持下标索引，所以也就不支持使用while。

  • 因为集合是无序的，所以集合不支持下标索引访问
my_set = {"观止", True, "观止"}
for i in my_set:
    print(i)
# 打印
# True
# 观止

(3) 集合的常用操作

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

(3.1) 增加元素

  • 集合本身被修改，将指定元素，添加到集合内
  • 语法：集合.add(元素)
my_set = {"观止", True, "观止"}
my_set.add("study")
print(my_set)  # 打印 {'观止', True, 'study'}

(3.2) 移除元素

  • 集合本身被修改，将指定元素，从集合内移除

  • 语法一：集合.remove(元素)

my_set = {"观止", True, "观止"}
my_set.remove("观止")
print(my_set)  # 打印 {True}

  • 从集合中随机取出一个元素，同时集合本身被修改，元素被移除

  • 语法二：集合.pop()

    my_set = {"观止", True}
num = my_set.pop()
print(my_set)  # 打印 {'观止'}
print(num)  # 打印 True

  • 清空集合,集合本身被清空

  • 语法三：集合.clear()

my_set = {"观止", True}
my_set.clear()
print(my_set)  # 打印 set()

(3.3) 两集合操作

  • 取出集合1和集合2的差集（集合1有而集合2没有的)，得到一个新集合，集合1和集合2不变
  • 语法一：集合1.difference(集合2)
my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_3 = my_set_1.difference(my_set_2)
print(my_set_1)  # 打印 {1, 2}
print(my_set_2)  # 打印 {1, 3}
print(my_set_3)  # 打印 {2}

  • 对比集合1和集合2，在集合1内，删除和集合2相同的元素,集合1被修改，集合2不变

  • 语法二：集合1.difference_update(集合2)

my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_1.difference_update(my_set_2)
print(my_set_1)  # 打印 {2}
print(my_set_2)  # 打印 {1, 3}
  • 将集合1和集合2组合成新集合(去重)，集合1和集合2不变
  • 语法三：集合1.union(集合2)
my_set_1 = {1, 2}
my_set_2 = {1, 3}
my_set_3 = my_set_1.union(my_set_2)
print(my_set_1)  # 打印 {1, 2}
print(my_set_2)  # 打印 {1, 3}
print(my_set_3)  # 打印 {1, 2, 3}

(3.4) 集合长度

  • 查看集合的元素数量，统计集合内有多少元素

  • 语法四：len(集合)

my_set = {1, 3}
print(len(my_set))  # 打印 2

(4) 集合小结

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

七.字典、映射(dict)

Python中字典和生活中字典十分相像

请添加图片描述

(1) 基本格式

# 定义字典
变量名称 = {key:value, key:value, key:value}
# 定义空字典
变量名称 = {}
变量名称 = dict()
  • 使用{}存储原始，每一个元素是一个键值对
  • 每一个键值对包含Key和Value（用冒号分隔）
  • 键值对之间使用逗号分隔
  • Key和Value可以是任意类型的数据（key不可为字典）
  • Key不可重复，重复会对原有数据覆盖
  • 使用示例:
my_dict = {"观止": 99, "李白": 120, "观止": 110}
print(my_dict)  # 打印 {'观止': 110, '李白': 120}
print(type(my_dict))  # 打印  <class 'dict'>

(2) 数据的获取

  • 字典同集合一样，不可以使用下标索引取值
  • 字典可以通过Key值来取得对应的Value
my_dict = {"李白": 120, "观止": 110}
print(my_dict["李白"])  # 打印 120
  • 字典的Key和Value可以是任意数据类型（Key不可为字典）,即字典是可以嵌套的
my_dict = {
    "李白": {"语文": 110, "数学": 100}, 
    "观止": {"语文": 90, "数学": 120}
}
print(my_dict["李白"])  # 打印 {'语文': 110, '数学': 100}
print(my_dict["李白"]["语文"])  # 打印 110
  • 字典不支持下标索引，同样不可以用while循环遍历
my_dict = {"李白": 120, "观止": 110}
for name in my_dict:
    print(f"key为：{name},value为：{my_dict[name]}")
# 打印
# key为：李白,value为：120
# key为：观止,value为：110

(3) 字典的常用操作

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

(3.1) 新增元素

  • 字典被修改，新增了元素
  • 如果key不存在字典中执行上述操作，就是新增元素
  • 语法：字典[Key] = Value
my_dict = {"李白": 120, "观止": 110}
my_dict["罗辑"] = 115
print(my_dict)  # 打印 {'李白': 120, '观止': 110, '罗辑': 115}

(3.2) 更新元素

  • 字典被修改，元素被更新

  • 字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

  • 语法：字典[Key] = Value

my_dict = {"李白": 120, "观止": 110}
my_dict["李白"] = 115
print(my_dict)  # 打印 {'李白': 115, '观止': 110}

(3.3) 删除元素

  • 获得指定Key的Value，同时字典被修改，指定Key的数据被删除

  • 语法：字典.pop(Key)

my_dict = {"李白": 120, "观止": 110}
name = my_dict.pop("李白")
print(name)  # 打印 120
print(my_dict)  # 打印 {'观止': 110}

(3.4) 清空字典

  • 字典被修改，元素被清空

  • 语法：字典.clear()

my_dict = {"李白": 120, "观止": 110}
my_dict.clear()
print(my_dict)  # 打印 {}

(3.5) 获取全部的key

  • 得到字典中的全部Key

  • 语法：字典.keys()

my_dict = {"李白": 120, "观止": 110}
my_keys = my_dict.keys()
print(my_keys)  # 打印 dict_keys(['李白', '观止'])

(3.6) 计算字典内键值对数量

  • 得到一个整数，表示字典内元素（键值对）的数量
  • 语法：len(字典)
my_dict = {"李白": 120, "观止": 110}
print(len(my_dict))  # 打印 2

(4) 字典小结

  • 特点：
    • 可以容纳多个数据
    • 可以容纳不同类型的数据
    • 每一份数据是Key-Value键值对
    • 可以通过Key获取到Value，Key不可重复（重复会覆盖）
    • 不支持下标索引
    • 可以修改（增加或删除更新元素等）

八.数据容器对比总结

(1) 简单分类

  • 是否支持下标索引

    • 支持：列表、元组、字符串 - 序列类型

    • 不支持：集合、字典 - 非序列类型

  • 是否支持重复元素：

    • 支持：列表、元组、字符串 - 序列类型

    • 不支持：集合、字典 - 非序列类型

  • 是否可以修改

    • 支持：列表、集合、字典

    • 不支持：元组、字符串

(2) 特点对比

列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意Key：Value Key：除字典外任意类型 Value：任意类型
下标索引支持支持支持不支持不支持
重复元素支持支持支持不支持不支持
可修改性支持不支持不支持支持支持
数据有序是是是否否
使用场景可修改、可重复的一批数据记录场景不可修改、可重复的一批数据记录场景一串字符的记录场景不可重复的数据记录场景以Key检索Value的数据记录场景

(3) 应用场景

  • 列表：一批数据，可修改、可重复的存储场景
  • 元组：一批数据，不可修改、可重复的存储场景
  • 字符串：一串字符串的存储场景
  • 集合：一批数据，去重存储场景
  • 字典：一批数据，可用Key检索Value的存储场景
功能描述
通用for循环遍历容器（字典是遍历key）
max容器内最大元素
min()容器内最小元素
len()容器元素个数
list()转换为列表
tuple()转换为元组
str()转换为字符串
set()转换为集合
sorted(序列, [reverse=True])排序，reverse=True表示降序 得到一个排好序的列表

(4) 通用操作-遍历

  • 5类数据容器都支持for循环遍历

  • 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

(5) 通用操作-统计

(5.1)统计容器的元素个数

  • 语法：len(容器)
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(len(my_list))  # 结果 3
print(len(my_tuple))  # 结果 5
print(len(my_str))  # 结果 7

(5.2) 统计容器的最大元素

  • 语法：max(容器)
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(max(my_list))  # 结果 3
print(max(my_tuple))  # 结果 5
print(max(my_str))  # 结果 z

(5.3) 统计容器的最小元素

  • 语法：min(容器)
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4, 5)
my_str = "guanzhi"
print(min(my_list))  # 结果 1
print(min(my_tuple))  # 结果 1
print(min(my_str))  # 结果 a

(5.4) 字符串大小比较

  • ASCII码表：

请添加图片描述

  • 在程序中，字符串所用的所有字符如：大小写，英文单词，数字特殊符号(!、\、|、@、#、空格等），都有其对应的ASCII码表值

  • 每一个字符都能对应上一个：数字的码值，字符串进行比较就是基于数字的码值大小进行比较的。

  • 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大:

请添加图片描述

(6) 通用操作-排序

  • 将给定容器进行排序,排序后都会得到列表（list）对象。

  • 语法:sorted(容器, [reverse=True])

    my_list = [1, 4, 2]
my_list_asc = sorted(my_list)
print(my_list_asc)  # 结果 [1, 2, 4]
my_list_des = sorted(my_list, reverse=True)
print(my_list_des)  # 结果 [4, 2, 1]

(7) 通用操作-转换

  • 将给定容器转换为列表

  • 语法一：list(容器)

my_tuple = (1, 4, 2) 
print(type(my_tuple))  # 打印 <class 'tuple'>
my_list = list(my_tuple)
print(type(my_list))  # 打印 <class 'list'>

  • 将给定容器转换为字符串

  • 语法二：str(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_str = str(my_tuple)
print(type(my_str))  # 打印 <class 'str'>

  • 将给定容器转换为集合

  • 语法三：set(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_set = set(my_tuple)
print(type(my_set))  # 打印 <class 'set'>

  • 将给定容器转换为元组

  • 语法四：tuple(容器)

my_list = [1, 4, 2]
print(type(my_list))  # 打印 <class 'list'>
my_tuple = tuple(my_list)
print(type(my_tuple))  # 打印 <class 'tuple'>

个字符都能对应上一个：数字的码值，字符串进行比较就是基于数字的码值大小进行比较的。

  • 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大:

[外链图片转存中…(img-OBBEKbw3-1672218055750)]

(6) 通用操作-排序

  • 将给定容器进行排序,排序后都会得到列表（list）对象。

  • 语法:sorted(容器, [reverse=True])

    my_list = [1, 4, 2]
my_list_asc = sorted(my_list)
print(my_list_asc)  # 结果 [1, 2, 4]
my_list_des = sorted(my_list, reverse=True)
print(my_list_des)  # 结果 [4, 2, 1]

(7) 通用操作-转换

  • 将给定容器转换为列表

  • 语法一：list(容器)

my_tuple = (1, 4, 2) 
print(type(my_tuple))  # 打印 <class 'tuple'>
my_list = list(my_tuple)
print(type(my_list))  # 打印 <class 'list'>

  • 将给定容器转换为字符串

  • 语法二：str(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_str = str(my_tuple)
print(type(my_str))  # 打印 <class 'str'>

  • 将给定容器转换为集合

  • 语法三：set(容器)

my_tuple = (1, 4, 2)
print(type(my_tuple))  # 打印 <class 'tuple'>
my_set = set(my_tuple)
print(type(my_set))  # 打印 <class 'set'>

  • 将给定容器转换为元组

  • 语法四：tuple(容器)

my_list = [1, 4, 2]
print(type(my_list))  # 打印 <class 'list'>
my_tuple = tuple(my_list)
print(type(my_tuple))  # 打印 <class 'tuple'>

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/124059.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

kail - 扫描与爆破

kail - 扫描与爆破

数据来源 扫描技术 背景 在渗透测试过程中&#xff0c;为了节省人力和时间&#xff0c;通常采用手工和工具相结合的方式。使用工具&#xff0c;就是将一些机械性的操作自动化实现&#xff0c;用来提高渗透测试的效率。例如&#xff0c;寻找内网网段[10.10.10,20/24]所有在线主…
阅读更多...
MySQL窗口函数 和 阿里云日志15日留存率仪表盘统计脚本实现

MySQL窗口函数 和 阿里云日志15日留存率仪表盘统计脚本实现

窗口函数的官方描述&#xff1a;窗口函数对一组查询行执行类似聚合的操作。但是&#xff0c;虽然聚合操作将查询行分组为单个结果行&#xff0c;但窗口函数会为每个查询行生成一个结果&#xff0c;发生函数评估的行称为当前行&#xff0c;与发生函数评估的当前行相关的查询行构…
阅读更多...
Kubernetes证书热更新期限至100年【HA高可用集群】

Kubernetes证书热更新期限至100年【HA高可用集群】

一、问题与环境 1.为什么更新证书&#xff1f;局域网如何保障服务稳定性&#xff1f;   众所周知k8s&#xff08;Kubernetes&#xff09;有一个默认证书期限为一年不成文的规定&#xff0c;官方的解释是“最佳的做法是经常升级集群以确保安全。&#xff08;升级后集群证书自…
阅读更多...
MySQL表的增删查改

MySQL表的增删查改

目录 1、表的插入 <1> 全列插入 <2> 指定列插入 <3> 插入否则更新 <4> 替换 2、表的查找 <1>全列查询 <2>指定列查询 <3> where条件 <4> 筛选分页结果 3、表的修改 4、表的数据删除 5、查看表结构 6、插入查询结…
阅读更多...
SpringCloud微服务项目实战 - 2.App登录及网关

SpringCloud微服务项目实战 - 2.App登录及网关

如果你追求一个局部的更好甚至完美,你有可能花费巨大的资源和时间&#xff1b; 从总体上看&#xff0c;这往往意味着总体的浪费和失败&#xff0c;这是传说中的“打赢了战役打输了战争”。 系列文章目录 项目搭建App登录及网关 文章目录系列文章目录一、App登录1. 需求分析2. …
阅读更多...
2020-2021 ICPC, NERC, Southern and Volga Russian Regional Contest K. The Robot

2020-2021 ICPC, NERC, Southern and Volga Russian Regional Contest K. The Robot

翻译&#xff1a; 有一个机器人在一个没有尽头的方格场上。最初&#xff0c;机器人位于坐标为(0,0)的单元中。他将执行由一串大写拉丁字母“L”、“R”、“D”、“U”所描述的命令。当一个命令被执行时&#xff0c;机器人只是朝着相应的方向移动: “L”:向左一个单元格(当前单…
阅读更多...
【聆思CSK6 视觉AI开发套件试用】AI控制直流电机转速接口打通

【聆思CSK6 视觉AI开发套件试用】AI控制直流电机转速接口打通

本篇文章来自极术社区与聆思科技组织的CSK6 视觉AI开发套件活动&#xff0c;更多开发板试用活动请关注极术社区网站。作者&#xff1a;oxlm 背景 在访问极术社区时&#xff0c;偶然发现聆思科技的CSK6开发板的评估活动&#xff0c;看CSK6的硬件配置和技术规格&#xff0c;300M…
阅读更多...
JavaScript奇淫技巧：变速齿轮

JavaScript奇淫技巧：变速齿轮

JavaScript奇淫技巧&#xff1a;变速齿轮 在PC时代&#xff0c;曾有个名为“变速齿轮”的神奇软件&#xff0c;可以加快或减慢系统时间。 当时常用来修改游戏速度&#xff0c;可实现外挂一般的效果&#xff0c;很不可思议。 本文&#xff0c;将用JavaScript复刻这一功能&…
阅读更多...
maven在无互联网(内网)环境下打包

maven在无互联网(内网)环境下打包

Maven在内网环境打包 首先需要准备好项目所需的所有依赖包 我们可以在外网环境下&#xff0c;更改idea中Maven的local repository目录&#xff0c;然后刷新一下项目&#xff0c;将项目所需的依赖下载到更换的目录下 将新建的依赖目录和项目一起拷贝到内网环境下将依赖文件拷贝…
阅读更多...
带你学懂数据结构中的八大排序（下）

带你学懂数据结构中的八大排序（下）

✨个人主页&#xff1a; Yohifo &#x1f389;所属专栏&#xff1a; 数据结构 | C语言 &#x1f38a;每篇一句&#xff1a; 图片来源 You can avoid reality, but you cannot avoid the consequences of avoiding reality. 你可以逃避现实&#xff0c;但你无法逃避其带来的后果…
阅读更多...
《图解TCP/IP》阅读笔记（第八章 8.1~8.4）—— 概要，TELNET、FTP、SMTP、POP、IMAP协议介绍

《图解TCP/IP》阅读笔记（第八章 8.1~8.4）—— 概要，TELNET、FTP、SMTP、POP、IMAP协议介绍

前言 本篇篇幅较长&#xff0c;请耐心或者选择性阅读。 第八章 应用协议 从本篇开始&#xff0c;将介绍一些应用层协议&#xff0c;一般情况下&#xff0c;人们不太会在意网络应用程序实际上是按照何种机制正常运行的。本章旨在介绍TCP/IP中所使用的几个主要应用协议&#x…
阅读更多...
项目管理中，培养高效项目团队的6大优势

项目管理中，培养高效项目团队的6大优势

大多数项目经理知道合作会促进生产力&#xff0c;并且对不同的团队都很有效。良好的团队合作使你能够顺利地运行不同的项目&#xff0c;克服障碍并实现目标。 它也会使完成项目所需的时间减少&#xff0c;并使资源得到更好的管理。更不用说&#xff0c;高质量的团队合作将有助…
阅读更多...
第十四讲：神州交换机链路聚合配置

第十四讲：神州交换机链路聚合配置

链路聚合&#xff08;Link Aggregation&#xff09;又称Trunk&#xff0c;是指将多个物理端口捆绑在一起&#xff0c;成 为一个逻辑端口&#xff0c;以实现出/入流量在各成员端口中的负荷分担&#xff0c;交换机根据用户配置的端口负荷分担策略决定报文从哪一个成员端口发送到对…
阅读更多...
如何快速理解Python中的for循环？

如何快速理解Python中的for循环？

人生苦短&#xff0c;我用python 这次来给大家带来一点干货&#xff0c; 我们将从一组基本例子和它的语法开始&#xff0c; 还将讨论与 for 循环关联的 else 代码块的用处。 然后我们将介绍迭代对象、迭代器和迭代器协议&#xff0c; 还会学习如何创建自己的迭代对象和迭代器…
阅读更多...
微信小程序云开发之用户输入数据后excel表格导出升级版

微信小程序云开发之用户输入数据后excel表格导出升级版

大家好&#xff0c;我是csdn的小博主lqj_本人&#xff0c;最近在哔哩哔哩开始上传我的制作微信小程序的详细流程&#xff0c;大家可以关注一下哔哩哔哩&#xff1a;小淼前端 本次程序的详细视频教程已上传至哔哩哔哩&#xff1a; 腾讯云开发小程序之用户输入数据excel自动导出系…
阅读更多...
HaaS EDU物联网项目实战：微信小程序实现云养花

HaaS EDU物联网项目实战：微信小程序实现云养花

HaaS EDU K1是一款高颜值、高性能、高集成度的物联网开发板&#xff0c;板载功能强大的4核&#xff08;双核300Mhz M33双核1GHz A7&#xff09;主芯片&#xff0c;2.4G/5G双频Wi-Fi&#xff0c;双模蓝牙&#xff08;经典蓝牙/BLE&#xff09;&#xff0c;并自带丰富的传感器与小…
阅读更多...
第一章 vscode安装java环境

第一章 vscode安装java环境

要在Visual Studio Code中配置Java环境&#xff0c;需要完成以下步骤&#xff1a; 安装Java Development Kit (JDK)。首先&#xff0c;你需要安装Java Development Kit (JDK)&#xff0c;这是Java的开发环境&#xff0c;包含了Java虚拟机、Java编译器和Java库等。可以前往Oracl…
阅读更多...
Python基础知识入门（五）

Python基础知识入门（五）

Python基础知识入门&#xff08;一&#xff09; Python基础知识入门&#xff08;二&#xff09; Python基础知识入门&#xff08;三&#xff09; Python基础知识入门&#xff08;四&#xff09; 一、模块应用 模块是一个包含所有定义的函数和变量的文件&#xff0c;其后缀名…
阅读更多...
2022年「博客之星」参赛博主：（天寒雨落）在等您评价 ~

2022年「博客之星」参赛博主：（天寒雨落）在等您评价 ~

目录 评价方法 参与规则 评选规则 评分规则 活动奖品 评价方法 点击链接&#xff1a;2022年「博客之星」参赛博主&#xff1a;天寒雨落-CSDN社区 在箭头所指位置做出打星评价。 参与规则 1.本次年度评选分为「博客之星|和「博客新星:以及「社区之星|。「博客新星:只针对…
阅读更多...
Kafka — 1、基础介绍

Kafka — 1、基础介绍

1、消息队列简介 &#xff08;1&#xff09;同步&#xff1a;多个服务之间是同步完成一次请求 缺点&#xff1a; a. 性能比较差 b. 稳定性比较差&#xff0c;如果其中一个服务没有执行成功&#xff0c;则整个请求执行失败 &#xff08;2&#xff09;异步&#xff1a;加入【消息…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023