python 容器化 python存放数据的容器

文章目录

• 一、数据容器

• 数据容器特点对比

• 二、序列
• 三、列表(list)

• 3.1、列表定义：
• 3.2、列表下标索引
• 3.3、列表常用方法：
• 3.4、list遍历

• 四、元组(tuple)

• 4.1、元组定义
• 4.2、元组的常用方法
• 4.3、元组的遍历

• 五、字符串(str)

• 5.1、字符串定义
• 5.2、常用方法
• 5.3、字符串遍历

• 六、序列切片

• 语法
• 示例：

• 七、集合(set)

• 7.1、集合定义
• 7.2、常用方法
• 7.3、遍历集合

• 八、字典(dict)

• 8.1、字典定义
• 8.2、常用方法
• 8.3、遍历字典

• 九、容器通用常用功能

一、数据容器

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

数据容器特点对比

	列表(list)	元组(tuple)	字符串(str)	集合(set)	字典(dict)
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	k:v
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
是否支持while循环	是	是	是	否	否
使用场景	可修改、可重复	不可修改、可重复	一串字符	不可重复	以key检索value

二、序列

序列是指：内容连续、有序，可以使用下标索引的一类数据容器
列表(list)、元组(tuple)、字符串(str)均可以视为序列。

如上图，序列的典型特征就是：有序可用下标索引，字符串、元组、列表均满足这个要求

三、列表(list)

3.1、列表定义：

# 字面量
["tai", "bai", "python"]
# 定义变量
name = ["tai", "bai", "python"]
# 定义空列表
name = []
name = list()
# 嵌套列表
message = [[1, 2, 3], ["tai", "bai", "python"], [21, 22, 25]]

3.2、列表下标索引

列表的每一个元素，都有编号称之为下标索引
从前向后的方向，编号从0开始递增
从后往前的方向，编号从-1开始递减

通过下标获取对应位置的元素

列表[下标]

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 通过下标索引去除数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

注意：

要注意下标索引的取值范围，超出范围无法取出元素，并且会报错（IndexError: list index out of range）

3.3、列表常用方法：

方法	作用
列表.append(元素)	向列表中追加一个元素
列表.extend(容器)	将数据容器的内容依次去除，追加到列表尾部
列表.insert(下标, 元素)	在指定下标出，插入指定的元素
del 列表[下标]	删除列表指定下标元素
列表.pop(下标)	删除列表指定下标元素（返回删除的元素）
列表.remove(元素)	从前向后，删除此元素第一个匹配项
列表.clear()	清空列表
列表.count(元素)	统计此元素在列表中出现的次数
列表.index(元素)	查找指定元素在列表的下标（找不到报错ValueError）
len(列表)	统计容器中有多少元素

示例：

# 1.1 查找某元素在列表内的下标索引
index = name.index("tai")
print(f"tai在list的下标为{index}")

# 1.2 如果被查找的元素不存在，会报错   ValueError: 'li' is not in list
# index = name.index("li")
# print(f"li在list的下标为{index}")

# 2、修改特定下标索引的值
name[1] = "libai"
print(name)

# 3、在指定下标位置插入新元素
name.insert(1, "li")
print(name)

# 4、在列表的尾部追加  单个  新元素
name.append("bai")
print(name)

# 5、在列表的尾部追加  一批  新元素
name.extend(["java", "mysql"])
print(name)
# 6、 删除指定下标的元素 （两种方法）
# 6.1 方式1：del 列表[下标]
del name[2]
print(name)
# 6.2 方式2：列表.pop(下标)
element = name.pop(2)
print(f"通过pop取出元素后列表内容为：{name}，取出的元素为{element}")

# 7、删除某元素在列表中的第一个匹配项
name.remove("tai")
print(name)

# 8、清空列表
# name.clear()
# print(name)
# 9、统计列表内某元素的数量
count = name.count("bai")
print(f"bai在列表中出现了{count}次")
# 10、统计列表中全部的元素数量
len = len(name)
print(f"name一个有{len}个元素")

3.4、list遍历

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list = ["li", "tai", "bai"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件： 下标索引变量 < 列表的元素数量

    # 定义一个变量用来标记列表的下标
    index = 0           # 初始值的下标为0
    while index < len(my_list):
        print(my_list[index])
        index += 1

# list_while_func()
def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return: None
    """
    my_list = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for i in my_list:
        print(i)

四、元组(tuple)

4.1、元组定义

# 定义元组字面量
("taibai", 666, True)
# 定义元组变量
t1 = ("taibai", 666, True)
# 定义空元组
t2 = ()
t3 = tuple()
# 嵌套元组
t5 = ((1, 2, 3), (4, 5, 6))

4.2、元组的常用方法

在上述数据容器的描述中，已描述元组是不可修改的，所以并没有 增删改的操作

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

示例：

# 元组的操作： index查找方法
t6 = ("tai", "bai", "python", "python")
index = t6.index("bai")
print(f"bai出现在元组的下标为{index}")

# 元组的操作：count统计方法
count = t6.count("python")
print(f"python在元组中出现了{count}次")

# 元组的操作： len函数统计元祖元素数量
len = len(t6)
print(f"t6元组一共有{len}个元素")

4.3、元组的遍历

t6 = ("tai", "bai", "python", "python")
def tuple_while_func():
    i = 0
    while i < len:
        print(t6[i])
        i += 1

# 元组的遍历： for
def tuple_for_func():
    for i in t6:
        print(i)

五、字符串(str)

尽管字符串看起来并不像列表、元组那样，看起来存放了许多数据的容器
但不可否认，字符串也是数据容器的一员
并且字符串也是一个无法修改的数据容器，每次修改只是得到了一个新的字符串

5.1、字符串定义

# 字面量
'taibai'
"taibai"
# 定义变量
name = 'taibai'
name = "taibai"
name = """taibai"""
# 定义空字符串
str1 = ''
str2 = ""
str3 = """"""
str4 = str()

5.2、常用方法

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

示例：

my_str = "My name is taibai"
# 通过下标索引取值
value = my_str[5]
value2 = my_str[-4]
print(f"从字符串{my_str}取下标为5得值为：{value}，取下标为-4的值为：{value2}")
# index方法
value = my_str.index("is")
print(value)
# replace方法
my_str1 = my_str.replace("taibai", "taibai_yuan")
print(my_str1)
# split方法
my_list = my_str.split(" ")
print(my_list)
# strip方法 不添加参数去除前后空格 添加参数去除前后参数
my_str = "  My name is taibai  "
my_aa = my_str.strip()
print(my_aa)
my_str = "123My name is taibai321"
my_bb = my_str.strip("123")
print(my_bb)
# 统计字符串中某字符串的出现次数
count = my_str.count("a")
print(f"在{my_str}中a出现了{count}次")
# 统计字符串的长度
num = len(my_str)
print(f"{my_str}长度为{num}")

5.3、字符串遍历

my_str = "My name is taibai"

# 使用while循环遍历
index = 0
while index < len(my_str):
    print(my_str[index])
    index += 1

# 使用for循环遍历
for i in my_str:
    print(i)

六、序列切片

语法

序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次去除元素，到指定位置结束，得到一个新的序列

• 起始下标：表示从何处开始，可以不写，不写表示从头开始
• 结束下标：表示从何处结束，可以不写，不写表示截取到结尾
• 步长：表示依次取元素的间隔（可以为负数，表示倒序执行）

注意：

此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

示例：

# 对list进行切片，从1开始，4结束，步长为1
my_list = [0, 1, 2, 3, 4, 5, 6]
result = my_list[1:4]       # 步长默认为1，可以不写
print(result)

# 对tuple进行切片，从头开始，到最后结束，步长为1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result1 = my_tuple[:]       # 起始和结束不写，表示从头到尾  步长默认为1，也可以不写
print(result1)

# 对str进行切片，从头开始，到最后结束，步长为2
my_str = "0123456"
result2 = my_str[::2]
print(result2)
# 对str进行切边，从头开始，到最后结束，步长为-1
result3 = my_str[::-1]
print(result3)

# 对列表进行切片，从3开始，到1结束，步长为-1
result4 = my_list[3:1:-1]
print(result4)
# 对元组进行切片，从头开始，到尾结束，步长为-2
result5 = my_tuple[::-2]
print(result5)

七、集合(set)

7.1、集合定义

# 定义集合字面量
{"my", "name", "taibai", "python"}
# 定义集合变量
my_set = {"my", "name", "taibai", "python"}
# 定义空集合
my_set1 = set()

使用下列代码结果可看为 去重且无序

my_set = {"my", "name", "taibai", "python", "python", "python", "python"}
my_set1 = set()
print(my_set)

7.2、常用方法

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

示例：

my_set = {"my", "name", "taibai", "python"}
# 添加新元素
my_set.add("taibai_yuan")
print(my_set)
# 移除元素
my_set.remove("my")
print(my_set)
# 随机取出一个元素
string = my_set.pop()
print(string)
print(my_set)
# 清空集合
my_set.clear()
print(my_set)
# 取2个集合的差集
set1 = {"tai", "bai", "yuan"}
set2 = {"my", "name", "tai", "yuan"}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)
# 消除两个集合的差集
set1.difference_update(set2)
print(set1)
print(set2)
# 2个集合合并为1个
set1 = {"tai", "bai", "yuan"}
set2 = {"my", "name", "tai", "yuan"}
set3 = set1.union(set2)
print(set3)

# 统计集合元素数量
count = len(set1)
print(count)

7.3、遍历集合

由于集合无序，不可使用下标。所以不能使用while进行循环遍历

# 集合遍历
for i in set1:
    print(i)

八、字典(dict)

8.1、字典定义

# 定义字典字面量
{"taibai": 21, "yuan": 19, "libai": 30, "zhangsan": 10}
# 定义字典变量
my_dict = {"taibai": 21, "yuan": 19, "libai": 30, "zhangsan": 10}
# 定义空字典
my_dict1 = dict()
my_dict2 = {}

注意：

• 每一份数据都是k-v键值对
• 可用于通过key获取value，key不可重复（重复会覆盖）

8.2、常用方法

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

示例：

my_dict = {"张三": 99, "李四": 88, "王五": 77}
# 获取指定key对应的value值
value = my_dict["张三"]
# 新增元素
my_dict["太白"] = 100
print(my_dict)
# 更新元素
my_dict["太白"] = 150
print(my_dict)
# 删除元素
value = my_dict.pop("张三")
print(value)
print(my_dict)
# 清空元素
my_dict.clear()
print(my_dict)

# 获取全部的key
my_dict = {"张三": 99, "李四": 88, "王五": 77}
dict_set = my_dict.keys()
print(dict_set)

8.3、遍历字典

# 遍历字典
# 方式一：获取到所有的key来遍历key获取dict的元素
for i in dict_set:
    print(f"{i}:{my_dict[i]}")
# 方式二：直接使用for循环就可以获取到dict的key
for i in my_dict:
    print(f"{i}:{my_dict[i]}")

九、容器通用常用功能

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

注意：

• 字典转换为字符串并不会又影响
• 字典转换为列表会将value丢失
• 字典转换为元组会将value丢失
• 字典转换为集合会将value丢失
• 其余容器转字典，由于其余数据容器并无键值对，所以无法转字典

示例：

my_list = [3, 1, 2, 8, 0]
my_tuple = (3, 1, 2, 8, 0)
my_str = "cdiracl"
my_set = {3, 1, 2, 8, 0}
my_dict = {"key1": 1, "key3": 3, "key2": 2}

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

# 类型转换：容器转列表
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)}")

# 转字典，由于其余数据容器并无键值对，所以无法转字典


# sorted 排序   将内容排序放入列表之中
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)}")