python入门基础学习之数据容器对比总结

数据容器分类

数据容器可以从以下视角进行简单的分类：

①是否支持下标索引：
支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型
②是否支持重复元素：
支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型
③是否可以修改：
支持：列表、集合、字典
不支持：元组、字符串

数据容器特点对比

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

应用场景

基于各类数据容器的特点，它们的应用场景如下：

列表：一批数据，可修改、可重复的存储场景
元组：一批数据，不可修改、可重复的存储场景
字符串：一串字符串的存储场景
集合：一批数据，去重存储场景
字典：一批数据，可用Key检索Value的存储场景

数据容器的通用操作

数据容器的通用操作-遍历

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。

首先，在遍历上：
①5类数据容器都支持for循环遍历
②列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

尽管遍历的形式各有不同，但是，它们都支持遍历操作。

示例：

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
new_list = []
i = 0
while i < len(my_list):
    if my_list[i] % 2 == 0:
        new_list.append(my_list[i])
    i += 1

print(f"偶数形成的新列表：{new_list}")

运行结果：

偶数形成的新列表：[2, 4, 6, 8, 10]

数据容器的通用统计功能

除了遍历这个共性外，数据容器可以通用非常多的功能方法。

①len(容器)：统计容器的元素个数
②max(容器)：统计容器的最大元素
③min(容器)：统计容器的最小元素

示例：

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3}

# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串 元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

# max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")

# min最小元素
print(f"列表 最小元素是：{min(my_list)}")
print(f"元组 最小元素是：{min(my_tuple)}")
print(f"字符串最小元素是：{min(my_str)}")
print(f"集合 最小元素是：{min(my_set)}")
print(f"字典 最小元素是：{min(my_dict)}")

运行结果：

列表 元素个数有：5
元组 元素个数有：5
字符串 元素个数有：7
集合 元素个数有：5
字典 元素个数有：3
列表 最大的元素是：5
元组 最大的元素是：5
字符串最大的元素是：g
集合 最大的元素是：5
字典 最大的元素是：key3
列表 最小元素是：1
元组 最小元素是：1
字符串最小元素是：a
集合 最小元素是：1
字典 最小元素是：key1

小技巧：快捷键：shift+alt+拖动鼠标：可以实现一次选中多行相同位置选项进行替换等操作。

容器的通用转换功能

除了下标索引这个共性外，还可以通用类型转换。

①list(容器)：将给定容器转换为列表
②str(容器)：将给定容器转换为字符串
③tuple(容器)：将给定容器转换为元组
④set(容器)：将给定容器转换为集合

示例：

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
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)}")
# 类型转换：容器转元组
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)}")
# 类型转换：容器转字符串
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)}")
# 类型转换：容器转集合
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)}")

运行结果：

列表转列表的结果是：[1, 2, 3, 4, 5]
元组转列表的结果是：[1, 2, 3, 4, 5]
字符串转列表结果是：[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
集合转列表的结果是：[1, 2, 3, 4, 5]
字典转列表的结果是：[‘key1’, ‘key2’, ‘key3’]
列表转元组的结果是：(1, 2, 3, 4, 5)
元组转元组的结果是：(1, 2, 3, 4, 5)
字符串元组表结果是：(‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’)
集合转元组的结果是：(1, 2, 3, 4, 5)
字典转元组的结果是：(‘key1’, ‘key2’, ‘key3’)
列表转字符串的结果是：[1, 2, 3, 4, 5]
元组转字符串的结果是：(1, 2, 3, 4, 5)
字符串字符串表结果是：abcdefg
集合转字符串的结果是：{1, 2, 3, 4, 5}
字典转字符串的结果是：{‘key1’: 1, ‘key2’: 2, ‘key3’: 3}
列表转集合的结果是：{1, 2, 3, 4, 5}
元组转集合的结果是：{1, 2, 3, 4, 5}
字符串转集合结果是：{‘d’, ‘f’, ‘b’, ‘e’, ‘g’, ‘c’, ‘a’}
集合转集合的结果是：{1, 2, 3, 4, 5}
字典转集合的结果是：{‘key3’, ‘key2’, ‘key1’}

容器通用排序功能

语法：
sorted(容器, [reverse=True])：将给定容器进行排序

注意，排序后都会得到列表（list）对象，字典会丢失value。

示例：

# 进行容器的排序
my_list = [3, 5, 4, 1, 2]
my_tuple = (3, 5, 4, 1, 2)
my_str = "abcdefg"
my_set = {3, 5, 4, 1, 2}
my_dict = {"key1": 1, "key3": 3, "key2": 2}
# 正向排序
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)}")
# 反向排序
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)}")

运行结果：

列表正向排序结果是：[1, 2, 3, 4, 5]
元组正向排序结果是：[1, 2, 3, 4, 5]
字符串正向排序结果是：[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
集合正向排序结果是：[1, 2, 3, 4, 5]
字典正向排序结果是：[‘key1’, ‘key2’, ‘key3’]
列表反向排序结果是：[5, 4, 3, 2, 1]
元组反向排序结果是：[5, 4, 3, 2, 1]
字符串反向排序结果是：[‘g’, ‘f’, ‘e’, ‘d’, ‘c’, ‘b’, ‘a’]
集合反向排序结果是：[5, 4, 3, 2, 1]
字典反向排序结果是：[‘key3’, ‘key2’, ‘key1’]

容器通用功能总览

功能	描述
通用for循环	遍历容器（字典是遍历key）
max	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列，[reverse=Ture])	排序，reverse=True表示降序得到一个排好序的列表

拓展：字符串大小比较

ASCII码表：

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

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

字符串比较

1、字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大,后面就无需比较了。
示例：abc比ab大，abd比abc大。

2、单个字符之间如何确定大小？
通过ASCII码表，确定字符对应的码值数字来确定大小

示例：

# abc 比较abd
print(f"abd大于abc，结果：{'abd' > 'abc'}")
# a 比较ab
print(f"ab大于a，结果：{'ab' > 'a'}")
# a 比较A
print(f"a大于A，结果：{'a' > 'A'}")
# key1比较key2
print(f"key2大于key1，结果：{'key2' > 'key1'}")

运行结果：

abd大于abc，结果：True
ab大于a，结果：True
a大于A，结果：True
key2大于key1，结果：True