Python基础入门 --- 6.数据容器

news2024/11/13 9:31:10

文章目录

    • Python基础入门
    • 第六章：
      • 6.数据容器
        • 6.1 列表
          • 6.1.1 列表下标索引
          • 6.1.2 列表常用操作
            • 查找指定某元素的下标
            • 修改指定位置的元素值
            • 插入元素
            • 追加元素方式1
            • 追加元素方式2
            • 删除元素
            • 删除某元素在列表中的第一个匹配项
            • 清空列表
            • 统计某元素在列表中的数量
            • 统计列表元素个数
            • **总结**：
          • 6.1.3 列表的特点
          • 6.1.4 列表的遍历 --- while循环
          • 6.1.5 列表的遍历 --- for循环
          • 6.1.6 while循环与for循环的区别
        • 6.2 元组
          • 6.2.1元组相关操作
            • 总结：
          • 6.2.2 元组的遍历 --- while循环
          • 6.2.3 元组的遍历 --- for循环
          • 6.2.4 注意事项
          • 6.2.5 元组的特点
        • 6.3 字符串
          • 6.3.1 下标索引
          • 6.3.2 常用操作
            • 查找特定字符串的下标索引值
            • 字符串的替换
            • 字符串的分割
            • 字符串的规整操作
            • 统计某字符串中某字符串出现的次数
            • 统计字符串的字符个数
            • 总结：
          • 6.3.3 字符串的遍历 - while循环
          • 6.3.4 字符串的遍历 - for循环
          • 6.3.5 特点
        • 6.4 序列
          • 6.4.1 序列常用操作 - 切片
        • 6.5 集合
          • 6.5.1 常用操作
            • 添加新元素
            • 移除元素
            • 从集合中随机取出元素
            • 清空集合
            • 取出2个集合的差集
            • 消除2个集合的差集(交集)
            • 2个集合合并
            • 统计集合元素数量
            • 集合的遍历
            • 总结：
          • 6.5.2 特点
        • 6.6 字典
          • 6.6.1 定义
            • 数据的获取
            • 嵌套
          • 6.6.2 常用操作
            • 新增元素
            • 更新元素
            • 删除元素
            • 清空字典
            • 获取全部的Key
            • 字典的遍历
            • 统计字典内的元素数量
          • 6.6.3 特点
        • 6.7 数据容器分类
          • 6.7.1 总结
        • 6.8 数据容器的通用操作
          • 6.8.1 遍历
          • 6.8.2 统计容器的元素个数
          • 6.8.3 统计容器的最大元素
          • 6.8.4 统计容器的最小元素
        • 6.9数据容器的通用转换功能
          • 6.9.1 给定容器转换为列表
          • 6.9.2 给定容器转换为字符串
          • 6.9.3 给定容器转换为元组
          • 6.9.4 给定容器转换为集合
        • 6.10 数据容器的通用排序功能
        • 6.11 通用功能总结

Python基础入门

第六章：

6.数据容器

定义：一种可容纳多份数据的数据类型，容纳的每一份数据称为1个元素，每个元素，都可是任意类型的数据。

作用：一个容器可以容纳多份数据。

分为5类：

  • 列表(list)

  • 元组(tuple)

  • 字符串(str)

  • 集合(set)

  • 字典(dict)

6.1 列表

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

语法结构：

# 字面量
[元素1, 元素2, 元素3, ....]

# 定义变量
变量名 = [元素1, 元素2, 元素3, ....]

# 定义空列表
变量名 = []
变量名 = list()

  • 以[]为标识

  • 列表内的每一个元素之间用逗号分隔

name_list1 = ['hello', 100, False]
print(name_list1)
print(type(name_list1))
name_list2 = [[1, 2, 3], [4, 5, 6]]
print(name_list2)
print(type(name_list2))))

在这里插入图片描述

补充：列表可以依次存储多个数据，可以是不同的数据类型，支持嵌套使用。

6.1.1 列表下标索引

作用：从列表出取出特定位置的数据。

元素元素元素元素元素
01234
-5-4-3-2-1

正向索引：从前到后的方向，从0开始，依次递增。

反向索引：从后到前的反向，从-1开始，依次递减。

name_list1 = ['hello', 100, False]
print(name_list1[0])
print(name_list1[1])
print(name_list1[2])

print(name_list1[-1])
print(name_list1[-2])
print(name_list1[-3])

name_list2 = [[1, 2, 3], [4, 5, 6]]
print(name_list2[0][1])
print(name_list2[1][2])
print(name_list2[1][1])

在这里插入图片描述
9YA-1710927932866)

6.1.2 列表常用操作

功能：

  • 插入元素

  • 删除元素

  • 修改元素

  • 统计元素个数

  • 清空列表

查找指定某元素的下标

语法结构：列表.index(元素)

name_list = ["he", "ll", "o"]
index = name_list.index("ll")
print(f"ll在列表中的下标索引值为：{index}")
# 输出：ll在列表中的下标索引值为：1
修改指定位置的元素值

语法结构：列表[下标] = 值

name_list = ["he", "ll", "o"]
name_list[1] = "he"
print(f"列表中的下标1的值被改后，结果是：{name_list}")
# 输出：列表中的下标1的值被改后，结果是：['he', 'he', 'o']
插入元素

说明：在指定的位置，插入指定的元素。

语法结构：列表.insert(下标, 元素)

name_list = ["he", "ll", "o"]
name_list.insert(1, "ha")
print(f"列表中的下标1的位置被插入指定元素后，结果是：{name_list}")
# 输出：列表中的下标1的位置被插入指定元素后，结果是：['he', 'ha', 'll', 'o']
追加元素方式1

说明：将指定元素，追加到列表的尾部。

语法结构：列表.append(元素)

name_list = ["he", "ll", "o"]
name_list.append("hehe")
print(f"列表追加了元素后，结果是：{name_list}")
# 输出：列表追加了元素后，结果是：['he', 'll', 'o', 'hehe']
追加元素方式2

说明：将其他数据容器的内容取出，依次追加到列表尾部。

语法结构：列表.extend(其他数据类型)

name_list = ["he", "ll", "o"]
name_list.extend(["wo", "r", "ld"])
print(f"列表追加了元素后，结果是：{name_list}")
# 输出：列表追加了元素后，结果是：['he', 'll', 'o', 'wo', 'r', 'ld']
删除元素

语法结构1：del 列表[下标]

语法结构2：列表.pop(下标)

# 方法1
name_list = ["he", "ll", "o"]
del name_list[1]
print(f"列表被删除元素后，结果是：{name_list}")
# 输出：列表被删除元素后，结果是：['he', 'o']

# 方法2
name_list = ["he", "ll", "o"]
name_list.pop(1)
print(f"列表被删除元素后，结果是：{name_list}")
# 输出：列表被删除元素后，结果是：['he', 'o']
删除某元素在列表中的第一个匹配项

语法结构：列表.remove(元素)

name_list = ["he", "ll", "o", "he"]
name_list.remove("he")
print(f"列表被移除元素后，结果是：{name_list}")
# 输出：列表被移除元素后，结果是：['ll', 'o', 'he']
清空列表

语法结构：列表.clear()

name_list = ["he", "ll", "o", "he"]
name_list.clear()
print(f"列表被清空后，结果是：{name_list}")
# 输出：列表被清空后，结果是：[]
统计某元素在列表中的数量

语法结构：列表.count(元素)

name_list = ["he", "ll", "o", "he"]
print(f"列表中he的数量是：{name_list.count("he")}")
# 输出：列表中he的数量是：2
统计列表元素个数

语法结构：len(列表)

name_list = ["he", "ll", "o", "he"]
print(f"列表中的元素个数有：{len(name_list)}")
# 输出：列表中的元素个数有：4
总结：
编号使用方法作用
1列表.append(元素)在列表中追加一个元素到尾部
2列表.extend(容器)其他数据容器内容取出，依次追加到列表尾部。
3列表.insert(下标, 元素)在指定的位置，插入指定的元素。
4del 列表[下标]删除列表指定下标元素
5列表.pop(下标)删除列表指定下标元素
6列表.remove(元素)删除某元素在列表中的第一个匹配项
7列表.clear()清空列表
8列表.count(元素)统计某元素在列表中的数量
9列表.index(元素)查找指定某元素的下标
10len(列表)统计列表元素个数
6.1.3 列表的特点

  • 可容纳多个元素

  • 可容纳不同类型的元素

  • 有序存储数据

  • 允许重复数据

  • 可修改

6.1.4 列表的遍历 — while循环

语法结构：

index = 0
while index < len(列表):
    元素 = 列表[index]
    元素的处理
    index += 1

name_list = ["he", "l", "l", "0", "!"]
index = 0
while index < len(name_list):
    element = name_list[index]
    print(f"列表下标为{index}的元素是{element}")
    index += 1

在这里插入图片描述

6.1.5 列表的遍历 — for循环

语法结构：

for 临时变量 in 数据容器:
    临时变量的处理

name_list = ["he", "l", "l", "0", "!"]
index = 0
for element in name_list:
    print(f"列表元素有{element}")

在这里插入图片描述

6.1.6 while循环与for循环的区别

循环控制：

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

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

无限循环：

  • while循环可通过相应的条件使条件控制无限循环

  • for循环不可通过相应的条件使条件控制无限循环，因为被遍历的容器容量不是无限的

使用场景：

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

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

6.2 元组

作用：可以封装多个、不同类型的元素在内，一旦定义成功，就不可修改。

语法结构：

# 定义元组字面量
(元素, 元素, 元素, ...., 元素)
# 定义元组变量
变量名称 = (元素, 元素, ...., 元素)
# 定义空元组
变量名称 = ()       #方式1
变量名称 = touple() #方式2

# 定义元组
t1 = (123, "he", False)
t2 = ()
t3 = tuple()
print(f"t1的数据类型是：{type(t1)}，内容是：{t1}")
print(f"t2的数据类型是：{type(t2)}，内容是：{t2}")
print(f"t3的数据类型是：{type(t3)}，内容是：{t3}")

# 定义1个元素的元组
t4 = ("he", )
print(f"t4的数据类型是：{type(t4)}，内容是：{t4}")

# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))
print(f"t5的数据类型是：{type(t5)}，内容是：{t5}")

# 通过下标索引取出元组中的元素
num = t5[0][1]
print(f"num从t5[0][1]中取出的元素是{num}")

在这里插入图片描述

6.2.1元组相关操作

  • 查找方法：index

  • 统计方法：count

  • 统计元组元素数量：len

# 查找方法
t1 = ("he", "l", "l", "0", "!")
index = t1.index("0")
print(f"t1元组中的元素o的下标是：{index}")

# 统计方法
t2 = ("he", "l", "l", "l", "o", "!")
num = t2.count("l")
print(f"t2元组中的元素l的数量有：{num}")

# 统计元组元素数量
t3 = ("he", "l", "l", "o", "!")
num = len(t3)
print(f"t3元组的元素的数量有：{num}")

在这里插入图片描述

总结：
1index(元素)查找某个数据对应的下标，不存在就报错
2count(元素)统计某个数据在当前元组所出现的次数
3len(元组)统计元组内元素的数量
6.2.2 元组的遍历 — while循环
t1 = ("he", "l", "l", "0", "!")
index = 0
while index < len(t1):
    element = t1[index]
    print(f"元组t1的元素有：{element}")
    index += 1

在这里插入图片描述

6.2.3 元组的遍历 — for循环
t1 = ("he", "l", "l", "0", "!")
index = 0
for element in t1:
    print(f"元组t1的元素有：{element}")

在这里插入图片描述

6.2.4 注意事项
  • 不可修改元组的内容，否则直接报错
t1 = (1, 2, 3, 4, 5)
t1[0] = 6 #报错TypeError: 'tuple' object does not support item assignment
  • 可修改元组内list的内容
t1 = (1, 2, 3, ["he", "ha"])
t1[3][1] = "llo"
print(f"修改后的内容为：{t1}") # 修改后的内容为：(1, 2, 3, ['he', 'llo'])
6.2.5 元组的特点

  • 可容纳多个数据

  • 可容纳不同类型的数据

  • 数据有序存储

  • 允许重复数据存在

  • 不可修改

  • 支持for循环

6.3 字符串
6.3.1 下标索引

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

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

name_str = "hello"
print(name_str[0])  # h
print(name_str[-1]) # o

# 修改数据
name_str[0] = "l"  # 报错：TypeError: 'str' object does not support item assignment
6.3.2 常用操作
查找特定字符串的下标索引值

语法结构：字符串.index(字符串)

names_str = "Hello"
print(names_str.index("o")) # 4
字符串的替换

语法结构：字符串.replace(字符串1, 字符串2)

作用：字符串1替换字符串2，字符串内的全部。

字符串的分割

语法结构：字符串.split(分隔符字符串)

作用：按指定的分隔符字符串，划分为多个字符串存入列表对象中。

字符串的规整操作
  • 去前后空格

语法结构：字符串.strip()

name_str = " he l l o  "
print(name_str.strip()) # "he l l o"
  • 去前后指定字符串

语法结构：字符串.strip(字符串)

name_str = "hellooeh"
print(name_str.strip('he')) # "llo"

传入的是”he“,其实"h"和"e"都会被移除，按照单个字符。

统计某字符串中某字符串出现的次数

语法结构：字符串.count(字符串)

name_str = "hello"
count = name_str.count("l")
print(f"l在字符串{name_str}中出现的次数是{count}") # l在字符串hello中出现的次数是2
统计字符串的字符个数

语法结构：len(字符串)

num = len(name_str)
print(f"字符串{name_str}的长度是：{num}") # 字符串hello的长度是：5
总结：
1字符串[下标]据下标索引取出特定位置的字符
2字符串.index(字符串)查找特定字符串的下标索引值
3字符串.replace(字符串1, 字符串2)字符串1替换字符串2，字符串内的全部。
4字符串.split(分隔符字符串)按指定的分隔符字符串，划分为多个字符串存入列表对象中。
5字符串.strip() 字符串.strip(字符串)移除首尾的空格或指定字符串
6字符串.count(字符串)统计某字符串中某字符串出现的次数
7len(字符串)统计字符串的字符个数
6.3.3 字符串的遍历 - while循环
str = "hello"
index = 0
while index < len(str):
    print(str[index])
    index += 1
6.3.4 字符串的遍历 - for循环
str = "hello"
index = 0
for i in str:
    print(i)
6.3.5 特点

  • 只可存储字符串

  • 长度任意

  • 支持下标索引

  • 允许重复字符串存在

  • 不可修改

  • 支持for循环

6.4 序列

定义：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串均可视为序列。

6.4.1 序列常用操作 - 切片

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

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

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

  • 起始下标表示的是从哪开始，可以留空，留空视为从头开始

  • 结束下标表示从哪结束，可以留空，留空视为到结尾结束

  • 步长表示，依次取出元素的间隔，如步长1表示一个个取出元素，步长2表示每次跳过一个元素取，步长为负数时，反向取元素。

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret1 = num_list[1:5]   # 步长可省略不写，默认为1
print(f"结果1为{ret1}")

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
ret2 = num_list[:]
print(f"结果2为{ret2}")

num_str = "12345678910"
ret3 = num_list[::2]
print(f"结果3为{ret3}")

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
ret4 = num_list[::-1]   # 步长可省略不写，默认为1
print(f"结果4为{ret4}")

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
ret5 = num_list[3:1:-1]
print(f"结果5为{ret5}")

num_str = "12345678910"
ret6 = num_str[::-2]
print(f"结果6为{ret6}")

在这里插入图片描述

6.5 集合

集合是无序的，不支持下标索引访问。

语法结构：

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

my_set = {"ha", "he", "he"}
my_set_empty = set()
print(f"my_set的内容是{my_set}, 类型是{type(my_set)}")
print(f"my_set_empty的内容是{my_set_empty}, 类型是{type(my_set_empty)}")

在这里插入图片描述

6.5.1 常用操作
添加新元素

语法结构：集合.add(元素)

结果：将指定元素添加到集合内，集合本身被修改，添加了新元素。

my_set = {"hello", "world"}
my_set.add("hahe")
print(f"my_set添加元素后的结果是{my_set}") # my_set添加元素后的结果是{'hahe', 'hello', 'world'}
移除元素

语法结构：j集合.remove(元素)

**结果：**将指定元素从集合内移除，集合本身被修改，移除了元素。

my_set = {"hello", "world"}
my_set.remove("hello")
print(f"my_set移除元素后的结果是{my_set}") # my_set移除元素后的结果是{'world'}
从集合中随机取出元素

语法结构：集合.pop()

结果：从集合中随机取出一个元素，会得到一个元素的结果，集合本身被修改，元素被移除。

my_set = {"hello", "world"}
element = my_set.pop()
print(f"my_set被随机移除{element}后结果是{my_set}") # my_set被随机移除world后结果是{'hello'}
清空集合

语法结构：集合.clear()

结果：清空集合，集合本身被清空。

my_set = {"hello", "world"}
my_set.clear()
print(f"my_set被清空后的结果是{my_set}") # my_set移除元素后的结果是{'world'} # my_set被清空后的结果是set()
取出2个集合的差集

语法结构：集合1.difference(集合2)

结果：取出集合1和集合2的差集(集合1有集合2没有的元素)，得到一个新集合，集合1和集合2不变。

set1 = {1, 3, 4}
set2 = {1, 2, 3}
set3 = set1.difference(set2)
print(set1) # {1, 3, 4}
print(set2) # {1, 2, 3}
print(set3) # {4}
消除2个集合的差集(交集)

语法结构：集合1.difference_update(集合2)

结果：在集合1中，删除和集合2相同的元素，集合1被修改，集合2不变。

set1 = {1, 3, 4}
set2 = {1, 2, 3}
set1.difference_update(set2)
print(set1) # {4}
print(set2) # {1, 2, 3}
2个集合合并

语法结构：集合1.union(集合2)

结果：将集合1和集合2组合成新集合，得到一个新集合，集合1和集合2不变。

set1 = {1, 3, 4}
set2 = {1, 2, 3}
set3 = set1.union((set2))
print(set1) # {1, 3, 4}
print(set2) # {1, 2, 3}
print(set3) # {1, 2, 3, 4}
统计集合元素数量

语法结构：len(集合)

set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
num = len(set1)
print(f"set1统计集合元素数量是{num}") # set1统计集合元素数量是10
集合的遍历

语法结构：for 临时变量 in 集合:{}

# 集合不支持下标索引，所以不能使用while循环
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
for element in set1:
    print(f"set1中的元素有{element}")
总结：
编号操作功能
1集合.add(元素)集合内添加一个元素
2集合.remove(元素)移集合内指定的元素
3集合.pop()从集合中随机取出一个元素
4集合.clear()集合清空
5集合1.difference(集合2)取出集合1和集合2的差集(集合1有集合2没有的元素)，得到一个新集合，集合1和集合2不变。
6集合1.difference_update(集合2)在集合1中，删除和集合2相同的元素，集合1被修改，集合2不变。
7集合1.union(集合2)2个集合合并，得到1个新集合，原有的2个集合不变。
8len(集合)统计集合元素数量
6.5.2 特点

  • 可容纳多个数据

  • 可容纳不同类型的数据

  • 数据是无序存储的

  • 不允许重复数据存在

  • 可修改

  • 支持for循环

6.6 字典
6.6.1 定义

作用：可通过Key，取到对应的Value。

语法结构：

# 定义字典字面量
{key: value, key: value, .......,key: value}
# 定义字典常量
my_dict = {key: value, key: value, ......, key: value}
# 定义空字典
my_dict = {}
my_dict = dict()

my_dict1 = {"小明": 18, "小红": 19, "小王": 20}
my_dict2 = {}
my_dict3 = dict()
print(f"mydict1字典的内容是{my_dict1},类型是{type(my_dict1)}")
print(f"mydict2字典的内容是{my_dict2},类型是{type(my_dict2)}")
print(f"mydict3字典的内容是{my_dict3},类型是{type(my_dict3)}")

# 重复Key的字典
my_dict4 = {"小明": 18, "小明": 20, "小红": 19}
print(f"重复Key的my_dict4的内容是{my_dict4}")

在这里插入图片描述

数据的获取

语法结构：字典[Key]

my_dict = {"小明": 18, "小红": 19, "小王": 20}
print(my_dict["小明"]) # 18
print(my_dict["小红"]) # 19
print(my_dict["小王"]) # 20
嵌套

字典中的Key和Value可以是任意数据类型，Key不可为字典。

score_dict = {"小明": {"语文": 80, "数学": 90, "英语": 81},
             "小红": {"语文": 85, "数学": 88, "英语": 83},
             "小王": {"语文": 87, "数学": 80, "英语": 87}}
print(f"考试信息是：{score_dict}")
Xiaohong_English_score = score_dict["小红"]["英语"]
print(f"小红的英语成绩是{Xiaohong_English_score}")

在这里插入图片描述

6.6.2 常用操作
新增元素

语法结构：字典[Key] = Value

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score["小李"] = 84
print(student_score) # {'小明': 80, '小红': 90, '小王': 88, '小李': 84}
更新元素

语法结构：字典[Key] = Value

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score["小明"] = 84
print(student_score) # {'小明': 84, '小红': 90, '小王': 88}
删除元素

语法结构：字典.pop(Key)

student_score = {"小明": 80, "小红": 90, "小王": 88}
delete_score = student_score.pop("小明")
print(delete_score)  # 80
print(student_score) # {'小红': 90, '小王': 88}
清空字典

语法结构：字典.clear()

student_score = {"小明": 80, "小红": 90, "小王": 88}
student_score.clear()
print(student_score) # {}
获取全部的Key

语法结构：字典.Keys()

student_score = {"小明": 80, "小红": 90, "小王": 88}
obtain_value = student_score.keys()
print(obtain_value) # dict_keys(['小明', '小红', '小王'])
字典的遍历
student_score = {"小明": 80, "小红": 90, "小王": 88}
obtain_value = student_score.keys()
for key in obtain_value:
    print(f"Key：{key}")
    print(f"Value：{student_score[key]}")
# Key：小明
# Value：80
# Key：小红
# Value：90
# Key：小王
# Value：88
统计字典内的元素数量

语法结构：len(字典)

student_score = {"小明": 80, "小红": 90, "小王": 88}
num = len(student_score )
print(num) # 3

总结：

编号操作说明
1字典[Key] = Value新增元素
2字典[Key] = Value更新元素
3字典.pop(Key)删除元素
4字典.clear()清空字典
5字典.Keys()获取字典内全部的Key
6len(字典)统计字典内的元素数量
6.6.3 特点

  • 可容纳多个数据

  • 可容纳多个不同类型的数据

  • 每份数据是Key与Value值对应

  • 可通过Key去获取Value，Key不可重复

  • 不支持下标索引

  • 可修改

  • 支持for循环

6.7 数据容器分类

是否支持下标索引：

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

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

是否支持重复元素：

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

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

是否可修改：

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

  • 不支持：元组、字符串

6.7.1 总结
特点列表元组字符串集合字典
元素数量支持多个支持多个支持多个支持多个支持多个
元素类型任意任意仅字符任意Key：除字典外任意类型 Value：任意
重复元素支持支持支持不支持不支持
可修改性支持不支持不支持支持支持
数据有序是是是否否
使用场景可修改、可重复的一批数据不可修改、可重复的一批数据一串字符不可重复的数据以Key检索Value的数据
6.8 数据容器的通用操作
6.8.1 遍历

5类数据容器都支持for循环遍历。列表、元组、字符串支持while循环，集合、字典不支持。

6.8.2 统计容器的元素个数

语法结构：len(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(len(my_list))  # 10
print(len(my_tuple)) # 5
print(len(my_str))   # 5
print(len(my_set))   # 5
print(len(my_dict))  # 3
6.8.3 统计容器的最大元素

语法结构：max(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(max(my_list))  # 10
print(max(my_tuple)) # 5
print(max(my_str))   # o
print(max(my_set))   # 5
print(max(my_dict))  # key3
6.8.4 统计容器的最小元素

语法结构：min(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(min(my_list))  # 1
print(min(my_tuple)) # 1
print(min(my_str))   # e
print(min(my_set))   # 1
print(min(my_dict))  # key1
6.9数据容器的通用转换功能
6.9.1 给定容器转换为列表

语法结构：list(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转列表：{list(my_list)}")
print(f"元组转列表：{list(my_tuple)}")
print(f"字符串转列表：{list(my_str)}")
print(f"集合转列表：{list(my_set)}")
print(f"字典转列表：{list(my_dict)}")

在这里插入图片描述

6.9.2 给定容器转换为字符串

语法结构：str(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转字符串：{str(my_list)}")
print(f"元组转字符串：{str(my_tuple)}")
print(f"字符串转字符串：{str(my_str)}")
print(f"集合转字符串：{str(my_set)}")
print(f"字典转字符串：{str(my_dict)}")

在这里插入图片描述

6.9.3 给定容器转换为元组

语法结构：tuple(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转元组：{tuple(my_list)}")
print(f"元组转元组：{tuple(my_tuple)}")
print(f"字符串转元组：{tuple(my_str)}")
print(f"集合转元组：{tuple(my_set)}")
print(f"字典转元组：{tuple(my_dict)}")

在这里插入图片描述

6.9.4 给定容器转换为集合

语法结构：set(容器)

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_tuple = (1, 2, 3, 4, 5)
my_str = "hello"
my_set =  {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}
print(f"列表转集合：{set(my_list)}")
print(f"元组转集合：{set(my_tuple)}")
print(f"字符串转集合：{set(my_str)}")
print(f"集合转集合：{set(my_set)}")
print(f"字典转集合：{set(my_dict)}")

在这里插入图片描述

6.10 数据容器的通用排序功能

语法结构：sorted(容器, [reverse=True])

my_list = [7, 5, 9, 4, 2, 6, 1, 10, 3, 8]
my_tuple = (3, 5, 1, 4, 3)
my_str = "afedcb"
my_set =  {5, 3, 2, 4, 1}
my_dict = {"key3": 1, "key2": 2, "key1": 3}
print(f"列表排序后：{sorted(my_list)}")
print(f"元组排序后：{sorted(my_tuple)}")
print(f"字符串排序后：{sorted(my_str)}")
print(f"集合排序后：{sorted(my_set)}")
print(f"字典排序后：{sorted(my_dict)}")

在这里插入图片描述

my_list = [7, 5, 9, 4, 2, 6, 1, 10, 3, 8]
my_tuple = (3, 5, 1, 4, 3)
my_str = "afedcb"
my_set =  {5, 3, 2, 4, 1}
my_dict = {"key3": 1, "key2": 2, "key1": 3}
print(f"列表反向排序后：{sorted(my_list, reverse = True)}")
print(f"元组反向排序后：{sorted(my_tuple,reverse = True)}")
print(f"字符串反向排序后：{sorted(my_str,reverse = True)}")
print(f"集合反向排序后：{sorted(my_set,reverse = True)}")
print(f"字典反向排序后：{sorted(my_dict,reverse = True)}")

在这里插入图片描述

6.11 通用功能总结
功能描述
for循环遍历容器
len(容器)统计容器的元素个数
max(容器)统计容器的最大元素
min(容器)统计容器的最小元素
list(容器)给定容器转换为列表
str(容器)给定容器转换为字符串
tuple(容器)给定容器转换为元组
set(容器)给定容器转换为集合
sorted(容器, [reverse=True])排序

下一章：Python基础入门 — 5.函数

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

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

相关文章

【Redis】Redis常见原理和数据结构

【Redis】Redis常见原理和数据结构

Redis 什么是redis redis是一款基于内存的k-v数据结构的非关系型数据库&#xff0c;读写速度非常快&#xff0c;常用于缓存&#xff0c;消息队列、分布式锁等场景。 redis的数据类型 string&#xff1a;字符串 缓存对象&#xff0c;分布式ID&#xff0c;token&#xff0c;se…
阅读更多...
RAGGED: Towards Informed Design of Retrieval Augmented Generation Systems阅读笔记

RAGGED: Towards Informed Design of Retrieval Augmented Generation Systems阅读笔记

论文链接&#xff1a;https://arxiv.org/abs/2403.09040 Github链接&#xff1a;GitHub - neulab/ragged: Retrieval Augmented Generation Generalized Evaluation Dataset 最近RAG&#xff08;retrieval-augmented generation&#xff09;真的好火&#xff0c;这不CMU的发了…
阅读更多...
vscode用SSH远程开发c语言

vscode用SSH远程开发c语言

vscode配置远程 这里我使用虚拟机进行展示&#xff0c;首先需要你的虚拟机安装好ssh 没安装好就执行下面的命令安装并开启服务 sudo apt-get install ssh sudo service ssh start ps -e | grep sshvscode安装 remote-ssh扩展 点击左下角的远程连接&#xff0c;我这里已经连接…
阅读更多...
电脑小白入门｜Windows系统下只要记住这几点，你就能流畅使用！

电脑小白入门｜Windows系统下只要记住这几点，你就能流畅使用！

前言 前段时间发现有很多小伙伴在使用电脑这个问题上遇到了很大的难题&#xff1a;到底什么时候该用鼠标左键单击、什么时候该双击&#xff1b;电脑的快捷键那么多怎么记得住等等的问题。 今天小白就稍微来讲解一下&#xff0c;这个帖子适合Windows电脑都不会使用的小伙伴。 …
阅读更多...
流畅的 Python 第二版（GPT 重译）（四）

流畅的 Python 第二版（GPT 重译）（四）

第二部分&#xff1a;函数作为对象 第七章&#xff1a;函数作为一等对象 我从未认为 Python 受到函数式语言的重大影响&#xff0c;无论人们说什么或想什么。我更熟悉命令式语言&#xff0c;如 C 和 Algol 68&#xff0c;尽管我将函数作为一等对象&#xff0c;但我并不认为 Py…
阅读更多...
iframe动态操作标签分享

iframe动态操作标签分享

前言 分享一个近期工作中遇到的关于IFrame的需求&#xff0c;以及解决方案。 需求大致是说在我们系统中嵌套了另一个文档页面&#xff0c;这个文档页面是爬取的&#xff0c;并且页面是原先使用后端渲染实现的&#xff0c;取到的css和script标签都是相对路径比如: "./mia…
阅读更多...
【文件操作和IO】

【文件操作和IO】

文件操作和IO 1.文件2. 硬盘上文件的目录结构3. 文件路径4. 文件重要分类&#xff1a;5. Java中操作文件5.1 Java对于文件操作的API5.2 Java中使用File类来进行文件操作5.3 File类属性5.4 构造方法5.5 方法&#xff1a; 6. 文件内容的读写 -- 文件流&#xff08;数据流&#xf…
阅读更多...
32.768K晶振X1A000141000300适用于无人驾驶汽车电子设备

32.768K晶振X1A000141000300适用于无人驾驶汽车电子设备

科技的发展带动电子元器件的发展电子元器件-“晶振”为现代的科技带来了巨大的贡献&#xff0c;用小小的身体发挥着大大的能量。 近两年无人驾驶汽车热度很高&#xff0c;不少汽车巨头都已入局。但这项技术的难度不小&#xff0c;相信在未来几年里&#xff0c;无人驾驶汽车这项…
阅读更多...
改进粒子群优化算法||粒子群算法变体||Improved particle swarm optimization algorithm

改进粒子群优化算法||粒子群算法变体||Improved particle swarm optimization algorithm

粒子群算法&#xff08;Particle Swarm Optimization&#xff0c;PSO&#xff09;是一种基于群体智能的优化算法&#xff0c;其思想来源于鸟群寻食和鱼群捕食等自然现象。PSO算法通过模拟群体智能的行为&#xff0c;以一种启发式的方式寻找最优解&#xff0c;因此具有全局搜索能…
阅读更多...
数学建模（熵权法 python代码 例子）

数学建模（熵权法 python代码 例子）

目录 介绍&#xff1a; 模板&#xff1a; 例子&#xff1a;择偶 极小型指标转化为极大型&#xff08;正向化&#xff09;&#xff1a; 中间型指标转为极大型&#xff08;正向化&#xff09;&#xff1a; 区间型指标转为极大型&#xff08;正向化&#xff09;&#xff1a…
阅读更多...
【Web应用技术基础】HTML(4)——表单类的标签

【Web应用技术基础】HTML(4)——表单类的标签

目录 题目1&#xff1a;文本框 题目2&#xff1a;密码框 题目3&#xff1a;单选框 题目4&#xff1a;多选框 题目5&#xff1a;单选框选中 题目6&#xff1a;禁用disabled 题目7&#xff1a;lable标签 题目8&#xff1a;下拉框 题目9&#xff1a;textarea 题目10&…
阅读更多...
【Java之老话常谈】学习Java可以用来做什么？

【Java之老话常谈】学习Java可以用来做什么？

对于很多新手来说，刚开始接触Java会很迷惘，不知道Java可以做什么。其实Java 可以做的东西太多了，手机游戏、中间件、软件、网站，电脑游戏，以及现在流行的安卓手机app等，都是由java语言编写的。由于Java拥有很高的安全性、平台移植性等，所以受到广大程序员的喜爱。 java…
阅读更多...
接口测试、postman、测试点提取【主】

接口测试、postman、测试点提取【主】

接口测试是测试系统组件间接口的一种测试 接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点 测试的重点是要检查数据的交换&#xff0c;传递和控制管理过程&#xff0c;以及系统间的相互逻辑依赖关系 文章目录 HTTP接口 & Web Service接口RESTful接口…
阅读更多...
ubuntu10.04 apache2.2开启tls1.2的支持，使现代的edge和firefox浏览器能正常访问https

ubuntu10.04 apache2.2开启tls1.2的支持，使现代的edge和firefox浏览器能正常访问https

最近发现自己ubuntu10.04服务器上的apache https无法通过win11上的edge和firefox浏览器访问&#xff0c;但xp下的ie6和ie8没有问题。 firefox的错误提示为“此网站可能不支持TLS 1.2协议,而这是Firefox支持的最低版本”。 经过检查发现&#xff1a; IE6访问https所需的版本是SS…
阅读更多...
virtualBox镜像复制

virtualBox镜像复制

镜像复制 有一个镜像后&#xff0c;图方便&#xff0c;想直接使用这个vdi文件&#xff0c;但vdi有个uuid值&#xff0c;同一个虚拟机中不能同时存在两个同样的uuid的介质的&#xff0c;普通的复制文件所得到的uuid是一样的 &#xff0c;所以需要用到自带的方法复制vdi文件&…
阅读更多...
隐私计算实训营学习二：隐私计算开源如何助力数据要素流通

隐私计算实训营学习二：隐私计算开源如何助力数据要素流通

文章目录 一、数据要素流转与数据内外循环二、数据外循环中的信任焦虑三、数据要素流通对隐私计算的期望四、隐私计算开源助力数据要素流通 一、数据要素流转与数据内外循环 数据要素流转过程(从数据采集加工->到数据价值释放)&#xff1a; 链路主要包括采集、存储、加工、…
阅读更多...
计算机网络面经-什么是IPv4和IPv6？

计算机网络面经-什么是IPv4和IPv6？

前言 Internet协议&#xff08;IP&#xff09;是为连接到Internet网络的每个设备分配的数字地址。它类似于电话号码&#xff0c;是一种独特的数字组合&#xff0c;允许用户与他人通信。IP地址主要有两个主要功能。首先&#xff0c;有了IP&#xff0c;用户能够在Internet上被识别…
阅读更多...
JUnit5的条件测试、嵌套测试、重复测试

JUnit5的条件测试、嵌套测试、重复测试

条件测试 JUnit5支持条件注解&#xff0c;根据布尔值判断是否执行测试。 自定义条件 EnabledIf和DisabledIf注解用来设置自定义条件&#xff0c;示例&#xff1a; Test EnabledIf("customCondition") void enabled() { // ... } Test DisabledIf("cust…
阅读更多...
动态规划课堂6-----回文串问题

动态规划课堂6-----回文串问题

目录 引言&#xff1a; 例题1&#xff1a;回文子串 例题2&#xff1a;回文串分割IV 例题3&#xff1a;分割回文串II 例题4&#xff1a;最长回文子序列 例题5&#xff1a;让字符串成为回文串的最小插入次数 引言&#xff1a; 回文字符串 是正着读和倒过来读一样的字符串。…
阅读更多...
Sora后时代文生视频的探索

Sora后时代文生视频的探索

一、写在前面 按常理&#xff0c;这里应该长篇大论地介绍一下Sora发布对各行业各方面产生的影响。不过&#xff0c;这类文章已经很多了&#xff0c;我们今天主要聊聊那些已经成熟的解决方案、那些已经可以“信手拈来”的成果&#xff0c;并以此为基础&#xff0c;看看Sora发布…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023