Python-容器类型-CSDN博客

前言

容器类型是用于存储和组织数据的内置数据结构

一、列表（list）

1. 定义

可以存储各种不同类型数据（int, float, complex, str, bool, Nonetype）
有序项目集合，可以用索引取值
可变数据类型

mylist1 = [1, 'a', 1.1, True, None, 1 + 1j]
print(id(mylist1), mylist1)		# 2969956051776 [1, 'a', 1.1, True, None, (1+1j)]
print(id(mylist1[0]), mylist1[0])	   # 140710721755576 1
print(id(mylist1[1]), mylist1[1])	   # 140710721789152 a

# 依次取出列表中的所有数据
# for， while
for item in mylist1:
    print(item)
# emumerate => 生成出（index，value）格式的数据,如(1, 'a')
for item in enumerate(mylist1):
    print(item)



# 可以索引取值： 跟str的取值方式一样
# mylist1[start:end:step]
print(mylist1[:-5:-1])		# ['g', 'f', 'e', 'd']

# 列表的计算(+, *)
mylist2 = [1, 2, 3] + [4, 5, 6]
print(mylist2)	# [1, 2, 3, 4, 5, 6]

mylist3 = [1, 2, 3] * 3
print(mylist3)	# [1, 2, 3, 1, 2, 3, 1, 2, 3]

2. 可变性

mylist1[0] = 2
print(id(mylist1[0]), mylist1[0])	   # 140710721755608 2

# str -> list
mystr = "abcdefg"
mylist1 = list(mystr)
print(mylist1)	# ['a', 'b', 'c', 'd', 'e', 'f', 'g']

3. 常用方法

1. append

追加元素一个元素

mylist4 = [1, 2, 3]
mylist4.append(4)
mylist4.append([5, 6])
print(mylist4)	# [1, 2, 3, 4, [5, 6]]

# 注意
# append() 方法是用来直接修改原列表的，它的返回值是 None，而不是修改后的列表
mylist = mylist.append(4)
print(mylist4)	 # None

mystr = "abcdefg"
mystr = mystr.replace("a", "o")
print(mystr)	 # obcdefg

2. extend

扩展元素,extend的参数是一个可迭代对象（字符串，list，元组…）

mylist4.extend([7, 8, 9])
print(mylist4)	# [1, 2, 3, 4, [5, 6], 7, 8, 9]

3. remove

删除元素

mylist4.remove(7)
print(mylist4)	# [1, 2, 3, 4, [5, 6], 8, 9]

4. pop

按下标删除(默认删除最后一个)

mylist4.pop(-2)
print(mylist4)		# [1, 2, 3, 4, [5, 6], 9]

item = mylist4.pop(-2)
print(item, mylist4)	# [5, 6] [1, 2, 3, 4, 9]

5. len

统计元素个数

print(len(mylist4))	# 5

6.count

指定元素在列表中出现几次

print(mylist4.count(3))	# 1

7. index

指定元素在列表中第一次出现的下标位置（如果不存在会报错）

print(mylist4.index(3))	# 2

8.insert

在指定位置插入元素

my_list = [1, 2, 3]
my_list.insert(1, "a")   # 在索引 1 处插入 "a"
print(my_list)  		 # [1, 'a', 2, 3]

9. sort

排序(列表内部的元素类型一致，可以进行>,<比较)

mylist = [1, 5, 6, 2, 3, 7]
mylist.sort()
print(mylist)	 # [1, 2, 3, 5, 6, 7]

10.reverse

反转逆序排列

mylist4.reverse()
print(mylist4)	 #

11.clear

清空列表

mylist4.clear()
print(mylist4)		# []

二、元组（tuple）

1. 定义

元组和列表的区别，列表是可变的，元组是不可变的（防止误修改）
有顺序的项目集合
可以存储各种不同类型的对象
不可变对象

mytuple = (1, 1.1, 'a', True, None, [1, 2], (1, 1))
# 注意！！！ 元组中如果只有一个元素，必须要加一个逗号
mytuple = (1)
print(type(mytuple))	# <class 'int'>
mytuple = (1,)
print(type(mytuple))	# <class 'tuple'>

2. 不可变性

# 元组是不可变的
# TypeError: 'tuple' object does not support item assignment
# mytuple[0] = 2

# 探讨可变性
mylist = [(1, 2), 3, 4]
mylist[0] = 2
# mylist[0][1] =22
# TypeError: 'int' object does not support item assignment

mytuple = ([2, 3], 4)
# mytuple[0] = 2
# TypeError: 'tuple' object does not support item assignment
mytuple[0][1] = 22

3. 列表元组转换

list, tuple

mytuple = (1, 2)
mylist = list(mytuple)
print(mylist, type(mylist))		# [1, 2] <class 'list'>
mylist = [1, 2]
mytuple = tuple(mylist)
print(mytuple, type(mytuple))	# (1, 2) <class 'tuple'>

三、字典（dict）

1. 定义

key-value键值映射数据结构
可变对象
key：必须是可hash对象（不可变对象->基础数据+元组），不可以重复
value: 可以是任何数据

mydict = {}
mydict = dict()
print(type(mydict))	# <class 'dict'>

mydict = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
    "key4": "value4"
}
print(type(mydict))	# <class 'dict'>

userinfo = {"name": "cici", "score": [1, 2, 3, 4, 5]}

dict1 = {1: 100}
dict2 = {(2, 3): 100}
# 可hash=> 创建好之后不可以改=>不可变对象
# 不可hash=> 创建好之后可以修改=>可变对象
# TypeError: unhashable type: 'list'
# dict3 ={[2,3]:100}

2. 取值

userinfo = {"name": "cici", "score": {"yuwen": 100, "shuxue": 100}}
print(userinfo["name"])	# cici
print(userinfo['score']["yuwen"])	# 100

# KeyError:'a'
# print(userinfo["a"])
# get 方法通过key取值，如果key不存在，返回默认值
print(userinfo.get("a", 0))		# 0
print(userinfo.get("name", "nothing"))	# cici

3.修改数据

# 当key不存在时，相当于新增加一个key-value
userinfo["age"] = 20
print((userinfo))	# {'name': 'cici', 'score': {'yuwen': 100, 'shuxue': 100}, 'age': 20}
# 当key存在时，相当于修改key对应的value
userinfo["age"] = 30
print((userinfo))	# {'name': 'cici', 'score': {'yuwen': 100, 'shuxue': 100}, 'age': 30}
# 删除数据
del userinfo["age"]
print(userinfo) 	# {'name': 'cici', 'score': {'yuwen': 100, 'shuxue': 100}}

4. 判断成员关系

# 判断是否存在name这个key
print("name" in userinfo)	# True
# 判断是否存在cici这个value
print("cici" in userinfo.values())	# True

print(userinfo.values())	# dict_values(['cici', {'yuwen': 100, 'shuxue': 100}, 30])
print(userinfo.keys())	# dict_keys(['name', 'score', 'age'])
print(userinfo.items())	# dict_items([('name', 'cici'), ('score', {'yuwen': 100, 'shuxue': 100}), ('age', 30)])

5. 遍历字典

for key in userinfo:
    print(key)	# name score age
for value in userinfo.values():
    print(value)	# cici {'yuwen': 100, 'shuxue': 100} 30
for key, value in userinfo.items():
    print(key, value)	
    # name cici 
    # score {'yuwen': 100, 'shuxue': 100} 
    # age 30

四、集合（set）

1. 定义

只有key的容器，key必须是可hash对象，天生去重
{1,2,3}

s1 = {1, 2, 3, 2, 4}
print(s1, type(s1))	# {1, 2, 3, 4} <class 'set'>

# TypeError: unhashable type: 'list'
# s2 = {[1,2]}
# print(s2,type(s2))

# 去重
s3 = set("abcdabcdabcd")
print(s3, type(s3), "".join(s3))	# {'a', 'd', 'b', 'c'} <class 'set'> adbc

s4 = set([1, 2, 3, 4, 1, 1, 2, 3, 4, 6])
print(s4, type(s4), list(s4))	# {1, 2, 3, 4, 6} <class 'set'> [1, 2, 3, 4, 6]

2. 添加或删除数据

# 给集合添加数据
s4.add(8)
print(s4, type(s4))	# {1, 2, 3, 4, 6, 8} <class 'set'>

# 删除
s4.remove(4)
print(s4, type(4))	# {1, 2, 3, 6, 8} <class 'set'>

3. 运算

s1 = {1, 2, 3}
s2 = {1, 2, 4}
# 并集：
print(s1 | s2)	# {1, 2, 3, 4}

# 交集：&
print(s1 & s2)	# {1, 2}

# s1-s2:在s1中，不在s2中
print(s1 - s2)	# {3}
print(s2 - s1)	# {4}

# 对称差集
print(s1 ^ s2)	# {3,4}

总结

      容器类型是 Python 中用于存储多个元素的对象，其核心特点是支持元素存在性检查,理解容器类型的特点和适用场景，有助于高效处理数据和编写清晰的代码
      容器类型是一个更宽泛的概念，任何能判断元素是否存在的对象都可以称为容器
      序列是容器的一种特定形式，强调元素的有序性和可迭代性

练习

1. 找出最长子串

连续字符：找出字符串中最长的重复字符
如aaabbbbb => bbbbb

# 定义最长连续子串的起始字符和长度
s = input("请输入连续字符:")
max_char = s[0]
max_length = 1
current_char = s[0]
current_length = 1
# 从第二个字符开始遍历
for c in s[1:]:
    if c == current_char:
        current_length += 1
        if current_length > max_length:
            max_length = current_length
            max_char = current_char
    else:
        current_char = c
        current_length = 1
print(f"{s}的最大子串为：{max_char * max_length}")

2. 定义一个列表，找出列表中是最大值、最小值、平均值（不用函数min,max）

list = [1, 3, 6, 4, 8, 5, 9, 7, 2]
min = max = sum = list[0]
for num in list[1:]:
    if num > max:
        max = num
    elif num < min:
        min = num
    sum += num
avg = sum / len(list)
print(f"最小值:{min}, 最大值:{max}, 平均值:{avg}")

list = [1, 3, 6, 4, 8, 5, 9, 7, 2]
mylist.sort()
sum = 0
min = mylist[0]
max = mylist[-1]
for i in mylist:
    sum += i
avg = sum / len(mylist)
print(f"最小值:{min}, 最大值:{max}, 平均值:{avg}")

3. 商品管理系统

A. 打印一个选择菜单：

显示商品信息 -> 用友好的方式将商品信息打印出来
增加或删除库存 -> 要用户输入商品id,增加库存量 p001, 10
删除商品 -> 要用户输入商品id
退出

B. 用户输入选择

根据用户的输入完成对应的菜单功能
用户可以进行N次操作，直到输入4

C. 注意：

用户输入不合法
如何保证代码的健壮性

menu = (
    "输入1: 显示商品信息",
    "输入2: 增加或删除库存",
    "输入3: 删除商品",
    "输入4: 退出"
)
pro_info = {
    "p001": {"name": "苹果", "price": 5, "store": 100},
    "p002": {"name": "香蕉", "price": 4, "store": 150},
    "p003": {"name": "橘子", "price": 2, "store": 200},
}
print("\n=== 商品管理系统 ===")
print("\n".join(menu))
while True:
    try:
        option = int(input("请输入你的选择(1-4),按4退出:"))
        if option not in {1, 2, 3, 4}:
            print("请正确输入有效数字(1-4)")
    except Exception as e:
        print("请正确输入有效数字(1-4)", e)
        continue
    if option == 1:
        print("\n===商品信息===")
        print(f"商品ID  商品名   单价     库存 ")
        for item in pro_info:
            print(f"{item}    {pro_info[item]['name']}     {pro_info[item]['price']}      {pro_info[item]['store']}")
    elif option == 2:
        print("\n===增加或减少库存===")
        print("例如：增加10个p001的库存量  输入:p001,10")
        print("     减少10个p001的库存量  输入:p001,-10")
        pid = input("请输入要增加或减少库存id：")
        found = False
        if pid in pro_info:
            found = True
        if found:
            pid, pcount = input("请输入商品id,库存变更信息：").split(',')
            pcount = int(pcount)
            print(pid, pcount)
            pro_info[pid]["store"] += pcount
            print(f"商品ID  商品名   单价     库存 ")
            for item in pro_info:
                print(
                    f"{item}    {pro_info[item]['name']}     {pro_info[item]['price']}      {pro_info[item]['store']}")
        else:
            print("商品id不存在")
    elif option == 3:
        print("===删除商品===")
        pid = input("\n请输入要删除的商品id:")
        found = False
        if pid in pro_info:
            found = True
        if found:
            pro_info.pop(pid, None)
            print(f"商品ID  商品名   单价     库存 ")
            for item in pro_info:
                print(
                    f"{item}    {pro_info[item]['name']}     {pro_info[item]['price']}      {pro_info[item]['store']}")
        else:
            print("商品id不存在")
        pid = input("请输入要删除的商品id:")
    elif option == 4:
        print("欢迎下次再来~")
        break

4. 分析用户好友关系数据

以下是你的好友, 构建你与Bob的共同好友集合，计算共同好友数量
推荐可能认识的好友（好友的好友）

friends = {
    "Alice": {"Bob", "Charlie", "Cali"},
    "Bob": {"Alice", "David", "Cali"},
    "Charlie": {"Alice", "David"}
}
friend = []
for key in friends:
    friend.append(key)
    my_friends = set(friend)
print(my_friends & friends["Bob"])		# {'Alice'}
may_friends = []
for value in friends.values():
    may_friends.extend(value)	
print(set(may_friends))		# {'Cali', 'David'}

5. 分解数字的质因数

如84 => 2，2，3，7

num = input("请输入数字:")
i = 2
prime_factor = []
while num // i >= 1:
    if num % i == 0:
        prime_factor.append(i)
        num = num // i
    else:
        i += 1
print(f"质因数为：{prime_factor}")

6. 二分查找

有一个列表[1,3,5,7,9]，输出一个数，用二分查找实现查找该数

list = [1, 3, 5, 7, 9]
left = 0
right = len(list) - 1
num = input("请输入数字:")
while left <= right:
    mid = (left + right) // 2
    if num < list[mid]:
        right = mid + 1
    elif num > list[mid]:
        left = mid + 1
    elif num == list[mid]:
        print(f"该数在列表{list}的位置为:{mid}")
        break
else:
    print(f"未找到该数")

7. 冒泡排序

对列表[3, 1, 4, 2]实现冒泡排序

通过重复遍历待排序序列，比较相邻元素并交换位置，使较大的元素逐渐 “浮” 到序列末尾

list = [3, 1, 4, 2]
n = len(list)
for i in range(n-1):
    for j in range(n -1 -i):
        if list[j] > list[j+1]:
            list[j], list[j+1] = list[j+1], list[j]
print(f"冒泡排序后的列表为:{list}")	# 冒泡排序后的列表为:[1, 2, 3, 4]

8. 根据测试结果（json）文件，生成测试通过率，及最耗时的用例,并按耗时将测试用例进行排序（top10）

序号用例名耗时
1 登录测试 4.2s
2 支付测试 3.3s

with open("test_result.json","r",encoding="utf-8") as f:
    content = f.read()
    # 将 JSON 字符串解析为 Python 数据结构
    data = json.loads(content)
    # 初始的通过数，测试的结果数为0
    pass_number = 0
    test_result_number = 0
    # 初始耗时和用例为空
    times = []
    cases = []
# 计算测试通过率，及最耗时用例
for item in data:
	# 取出测试的结果，时间和用例
    test_result = item["result"]
    test_time = item["time"]
    test_case = item["case"]    
    test_result_number += 1
    # 将耗时和用例存储到times和cases
    times.append(test_time)
    cases.append(test_case)
    # 统计测试通过的个数
    if test_result == "pass":
        pass_number += 1
# 测试通过率
pass_rate = pass_number / test_result_number
# 将耗时和用例排序
for i in range(test_result_number - 1):
    for j in range(test_result_number - 1 - i):
        if times[j] < times[j + 1]:
            times[j], times[j + 1] = times[j + 1], times[j]
            cases[j], cases[j + 1] = cases[j + 1], cases[j]
print(f"测试通过率:{pass_rate}")
print(f"最耗时用例:{cases[0]},耗时{times[0]}s")
print("\n耗时测试top10")
print("序号  用例名  耗时")
for k in range(10):
    print(f"{k + 1} {cases[k]} {times[k]}s")