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

文章目录

- 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 列表下标索引

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

元素	元素	元素	元素	元素
0	1	2	3	4
-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(下标, 元素)	在指定的位置，插入指定的元素。
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	删除某元素在列表中的第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计某元素在列表中的数量
9	列表.index(元素)	查找指定某元素的下标
10	len(列表)	统计列表元素个数

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}")

在这里插入图片描述

总结：

1	index(元素)	查找某个数据对应的下标，不存在就报错
2	count(元素)	统计某个数据在当前元组所出现的次数
3	len(元组)	统计元组内元素的数量

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(字符串)	统计某字符串中某字符串出现的次数
7	len(字符串)	统计字符串的字符个数

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个集合不变。
8	len(集合)	统计集合元素数量

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
6	len(字典)	统计字典内的元素数量

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.函数