【python】五个容器

一只自律的鸡

1327人浏览 · 2025-09-29 20:01:43

一只自律的鸡 · 2025-09-29 20:01:43 发布

一 list容器

(1) list的定义

示例代码
# #  list 字面量
# ["元素1", "元素2", "元素3", ...]

# #  list 定义list变量
# a = ["元素1", "元素2", "元素3", ...]

# #  定义空list
# b = []
# c = list()

# # 嵌套list变量
# a = [[], []]

# list的下标是可以添加正负号的
list1 = ["杨博涛是帅哥", "帅哥是杨博涛", "杨博涛真的很帅"]

print("第一次叫杨博涛帅哥：")
for i in range(0, len(list1)):
    print(list1[i])

print("第二次叫杨博涛帅哥：")
index = 0
while index != -3:
    print(list1[index])
    print(index)
    index -= 1

# 一一对应着对应的元素
# 正序:
# 0 1 2 3 4
# 负序:
# -3 -2 -1 -0

# 打印结果

# 第一次叫杨博涛帅哥：
# 杨博涛是帅哥
# 帅哥是杨博涛
# 杨博涛真的很帅
# 第二次叫杨博涛帅哥：
# 杨博涛是帅哥
# 0
# 杨博涛真的很帅
# -1
# 帅哥是杨博涛
# -2
list的定义格式很简单
(1)list的格式
list ( ) 和 [ ]都是可以定义空的列表的，当然在 [ ] 里面加元素就不是空的列表了

(2)list构造二维数组
这个list，平时练习的时候，有的时候有些系统是没有导入numpy的，这个时候就要用到list来进行构造二维数组了，构造这个二维数组来存数据

(2) list的操作集

增删改查

1. 查找指定下标元素
方法：index( 元素 ) 输出：当前元素的下标，没找到则直接报valueerror

示例代码
a = ["list", "queue", "stack"]

# 1. 查询指定元素的下标
# 当查找不到的时候，会报Valueerror的错误
print(a.index("list"))
# print(a.index("I love you"))

# 发生异常: ValueError
# 'I love you' is not in list
#   File "D:\py学习\4.第四节\2.list的操作集.py", line 6, in <module>
#     print(a.index("I love you"))
#           ~~~~~~~^^^^^^^^^^^^^^
# ValueError: 'I love you' is not in list
2. 修改元素
方法：变量名[下标] = 修改值

示例代码
# 2. 修改元素
a[0] = "I love you"
print(a[0])
修改元素

3. 追加和插入元素
方法：.append(追加的元素) 用处：追加到末尾
方法：.extend(追加的元素列表) 用处：追加一个列表到末尾
方法：.insert(插入的下标，插入的元素) 用处：插入到对应的下标位置，其他往后面移
示例代码
# 3. 插入元素
# 在指定元素的下标位置，插入指定的元素
# insert(下标, 元素)
a.insert(2, "Do you love me?")
print(f"插入后的链表的元素为：{a}")


# 4.追加单个元素(尾部)
# append(元素)
a.append("我爱你")
print(f"追加单个元素后：{a}")


# 5.追加一批元素
# extend(容器)
b = [1,2,3,4,5]
a.extend(b)
print(f"追加一批元素后：{a}")
4 删除元素和弹出元素
方法：del a[ 删除元素下标] 用处：用于删除元素，在原列表不保留
方法：pop a [弹出元素下标] 用处：用于删除元素，并且获取弹出元素
示例代码
# 6.删除元素无返回值
# del a[下标]
#   删除元素有返回值
# a.pop[下标]
del a[1]
a.pop(2)
print(f"删除之后的列表为：{a}")
5 元素个数，计算list长度和清空元素
# 7.统计一个元素在在列表里面出现了几次
print(f"I love you 在列表出现了: {a.count("I love you")} 次")

# 8.判断列表有几个元素
print(f"列表里面有 {len(a)} 个元素")

# 8.清除列表
a.clear();
print(f"清空列表的列表为：{a}")

二二元组

(1) 二元组的定义

示例代码
#  元组一旦被定义就不可以被修改

t1 = ()
t2 = tuple()
t3 = (1,2,3,4)

#  在定义单个元素的元组的时候，后面要加","
t5 = ("hello", )
t6 = ("hello")

print(f"t5的类型是{type(t5)}")
print(f"t6的类型是{type(t6)}")
二元组的定义是用()的，然后如果二元组只想存一个元素的时候，后面一定，，要不然就成字符串了

二元组一旦定义了就不可以更改，所以就没有a[0] = b 这种写法，但是可以通过下标进行访问
  File "d:\py学习\4.第四节\3.元组.py", line 14, in <module>
    t5[0] = "hello1"
    ~~^^^
TypeError: 'tuple' object does not support item assignment
这个是将二元组进行更改之后的报错信息

(2) 二元组的方法

统计一个元素的个数，计算该二元组的长度，查找一个元素的位置
示例代码
# 方法
t7 = (1,2,3,4,4,5,6,7)
print(f"t7的下标记是{t7.index(7)}")
print(f"t7的长度是{len(t7)}")
print(f"t7里面的4元素个数是{t7.count(4)}")
为什么只有这几种方法，因为二元组在定义之后不可以进行更改了

三字符串

(1) 字符串的定义

示例代码
# 字符串被定义后不可以更改

str1 = "it heitllo world it it"
字符串一旦定义成功是不可以进行更改的

(2) 字符串的方法

由于字符串的是不可以进行更改的，由此可知，后续的方法进行修改都是获取一个新的新的字符串赋值给一个新的变量

1 找到对应的元素的起始位置和获取对应的元素
方法：a[ 0 ] 用处：修改这个元素
方法：.index() 用处：获得该元素的起始位置
示例代码
# 根据特定下标找到特定字符
str1_temp1 = str1[1]
print(f"下标为1的特定字符为{str1_temp1}")


# 查找特定字符的对应下标,字符串为第一个字符的下标
str1_index1 = str1.index("world")
print(f"world的起始下标为{str1_index1}")
2 修改原始的字符串，赋值给新的变量
方法：.replace(字符串1，字符串2 ) 用处：替换字符串1为字符串2
示例代码
#  使用replace替换(不修改原字符串) 获得新的字符串
new_str1 = str1.replace("it", "love")
print(f"替换后的新的字符串为{new_str1}")
3 格式化
方法：split(分隔元素) 用处：根据这个分割元素进行分割，然后转换为列表
方法：strip(元素) 用处：根据这个元素，去在头部和尾部寻找，然后进行删除
#  使用split按照特定的字符串进行分隔，转换为列表
str1_list = str1.split(" ")  # 按照空格进行分隔
for i in range(1, 4 + 1):
    print(f"第{i}个元素是{str1_list[i]}")

#  使用strip()去首尾特定字符串和空格
new_str1_strip = str1.strip("it")
print(f"移除it后的新的字符串为{new_str1_strip}")
4 元素个数等方法
#  统计一个字符出现的次数
print(f"it出现的次数{str1.count("it")}")

#  字符串的长度
print(f"字符串的长度为{len(str1)}")
改查和字符串的格式化，由于改不可能改动原来的字符串，所以就是直接赋值给一个新的变量

四集合

(1) 集合的定义

示例代码
#  集合的定义
#  集合是去除重复的部分,但是无法确保里面元素的顺序
my_set = {"杨博涛","杨博涛是帅哥","杨博涛是大帅哥"}
print(f"初始化集合{my_set}")
这个是用{ }进行框住，然后就是集合了，集合的好处就是不会有重复的元素，但是里面的元素是无序的性质的

(2) 集合的操作集

1. 增删改查
示例代码
方法：remove() 用处：删除一个元素
方法：add() 用处：在末尾添加一个元素
方法：pop() 用处：弹出这个元素，然后获取这个元素
# remove()删除一个元素
my_set.remove("杨博涛")
print(f"my_set删除一个元素：{my_set}")

# add()添加函数
# my_set.add("杨博涛")
my_set.add("杨博涛喜欢一个人")
print(f"myset增加一个元素：{my_set}")

# pop()随机取出一个元素
element = my_set.pop()
print(f"取出来的元素{element}")
print(f"my_set取出元素后：{my_set}")
2. 两个集合之间的操作集
方法：集合1.difference(集合2) 用处：如果集合1的元素在集合2没有出现过，则赋值到集合3
方法：集合1.difference_update(集合2) 用处：如果集合1的元素在集合2出现过则删除
方法：集合1.union(集合2) 用处：将两个集合联立起来

代码示例
# 获取一个集合的差元素集合, 不改变之前的集合
set1 = {1,2,3}
set2 = {1,4,6}
set3 = set1.difference(set2)
# 取出基于set1的在set2里面查找不重复的元素,然后打印set1的元素
print(set1)
print(set2)
print(set3)

# 不获取一个新的元素，删除一个集合的重复的元素
set1.difference_update(set2)
print(set1)

# 联合两个集合,赋值给新的集合
set1 = {1,2,3}
set2 = {1,4,6}
set3 = set1.union(set2)
print(set3)
通过集合的定义可知，增删改查，还有两个集合之间操作

五字典

(1) 字典的定义

示例代码

#  字典的定义
#  根据key值取寻找vlaue值
#  定义方式{key: value, key: value, key: value, ...}
#         my_dict = dict()

my_dict1 = {"mike": 88, "jon":99, "jay":100}
print(f"打印my_dict1的mike的成绩：{my_dict1["mike"]}")

#  当遇到重复的元素时, 后面的会把前面的覆盖掉
my_dict2 = {"mike": 88, "mike":99, "jay":100}
print(f"打印my_dict1的mike的成绩：{my_dict2["mike"]}")

#  嵌套字典
my_dict3 = {
    "mike": 
{
    "数学":99,
    "英语":100,
    "语文":88
}, "jon":
{
    "数学":89,
    "英语":90,
    "语文":81
}, "jay":
{
    "数学":93,
    "英语":89,
    "语文":60
}}

print(f"打印mike的数学成绩：{my_dict3["mike"]["数学"]}")

1. 字典的定义格式
利用{ }花括号，然后里面有key值和value值，一一对应，可以利用list的知识点，字典[ key ] = value这个知识点，就可以输出这个value值了
2. 嵌套的字典
就是利用字典的value里再弄一个字典，这样就实现了二维字典

(2) 字典的操作集合

1. 增删改查
示例代码
增加直接利用list的那样的赋值操作，自动添加
修改的话也是，删除直接pop()

my_dict1 = {"mike": 88, "jon":99, "jay":100}

# 增加key和value
my_dict1["joun"] = 90
print(my_dict1)

# 修改一个key的value
my_dict1["jay"]  = 80
print(my_dict1)

# 删除一个key
ele = my_dict1.pop("jay")
print(f"删除的一个元素是{ele}")
print(my_dict1)

# 清空一个字典
my_dict1.clear()
print(my_dict1)

2. 获取全部的key
方法：.key() 用处：可以获取全部的key，然后用于for循环

# 获取全部的key
my_dict1 = {"mike": 88, "jon":99, "jay":100}
keys = my_dict1.keys()
print(keys)

(3) 循环的使用

示例代码

# for循环
for key in keys:
    print(my_dict1[key])





#  嵌套字典
my_dict2 = {
    "mike": 
{
    "数学":99,
    "英语":100,
    "语文":88
}, "jon":
{
    "数学":89,
    "英语":90,
    "语文":81
}, "jay":
{
    "数学":93,
    "英语":89,
    "语文":60
}}


keys1 = my_dict2.keys()
print(keys1)

for key1 in keys1:
    key2s = my_dict2[key].keys()
    for key2 in key2s:
        print(f"{key1}的{key2}的成绩为：{my_dict2[key1][key2]}")