python——数据容器

最新推荐文章于 2025-12-03 12:28:21 发布

原创最新推荐文章于 2025-12-03 12:28:21 发布 · 458 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#python

Python 专栏收录该内容

4 篇文章

订阅专栏

列表（List）

列表是可变的，可以存储不同类型的数据，支持嵌套。

列表可以通过索引访问元素，支持切片操作。

列表支持多种操作，如插入、删除、修改元素，以及追加和扩展列表。

列表的常用方法包括：append(), extend(), insert(), remove(), pop(), clear(), index(), count(), len()。

元组（Tuple）

元组是不可变的，一旦定义完成就不可修改。

元组可以存储不同类型的数据，支持嵌套。

元组可以通过索引访问元素，支持切片操作。

元组的元素不能修改，但元组中包含的可变对象（如列表）的内容可以修改。

字符串（String）

字符串是不可变的，不支持修改字符，但可以替换。

字符串可以通过索引访问字符，支持切片操作。

字符串的常用方法包括：index(), count(), len(), replace(), split(), strip(), lstrip()。

序列的切片操作

切片操作可以用于列表、元组和字符串，格式为 [起始:结束:步长]。

切片可以用于获取序列的一部分，支持负索引和步长。

集合（Set）

集合是无序的，不允许重复元素，可以存储不同类型的数据。

集合不支持索引访问，但支持添加、删除、清空集合。

集合的常用方法包括：add(), remove(), pop(), clear(), difference(), difference_update(), union(), symmetric_difference_update()。

集合支持集合运算，如并集、交集、差集和对称差。

字典（Dictionary）

字典是无序的（Python 3.7+保证插入顺序），键必须是不可变类型，键不能重复。

字典通过键访问值，支持嵌套。

字典支持增加、更新、删除键值对。

字典的常用方法包括：keys(), values(), items(), get(), pop(), clear(), len()。

字典的键必须是唯一的，但值可以是任何类型，包括另一个字典。

总结：

序列（列表、元组、字符串）：支持下标索引，支持重复元素，支持while循环

非序列（集合、字典）：不支持下标索引、重复、while循环

支持修改：列表、集合、字典

不支持修改：字符串（replace替换）、元组

共同：

len(容器)

max(容器)/min(容器)——字符串用字符对应ASCII码值比较（字符串、字典场景）

'''

'''
'''序列（列表、元组、字符串）:内容连续，有序（可用索引找元素）；支持切片'''
'''
1.list[]
'''
'''列表：允许存储多个不同类型的数据，支持嵌套[元素1,元素2,...]'''
list_empty=[]
lst_empty=list()
list1=["str",123,True,[4,5,6]]
print(list1)
print(type(list1))
#使用下标(索引)取数
print("使用下标(索引)取数")
print(list1[0])   #取第一个
print(list1[-1])  #取最后一个
print(list1[3][0])   #取嵌套列表中的第一个

'''功能'''

#查询下标
print("查询下标")
print("123所在位置：",list1.index(123))

#修改元素
print("修改元素")
list1[2]=False
print(list1[2])

#插入元素
print("插入元素")
list1.insert(0,"insert")
print(list1)

#尾部追加元素append
list1.append("append")
print(list1)

#追加新列表
appendlist=[7,8,9]
list1.extend(appendlist)
print(list1)

#统计数量
print("统计")
print(list1.count(7))  #单个元素
print(len(list1))   #所有元素（长度）

#删除  下标/元素值
print("删除")
del list1[2]  #仅删除
print(list1)
print(list1.pop(2))  #取出元素
print(list1)
list1.remove("insert")   #用元素值
print(list1)
print(list1.remove("append")) #————返回None
print(list1)
#清空列表
print(list1.clear())
list1.clear()
print(list1)

#遍历
print("遍历")
lst=["str",123,True,[4,5,6]]
index=0
while index<len(lst):
    print(lst[index])
    index+=1

for i in range(len(lst)):
    print(lst[i])


'''
2.tuple()
'''
'''元组：一旦定义完成就不可修改，可以存储不同类型数据(元素1,元素2,...)'''
tuple_empty1=()
tuple_empty2=tuple()
tuple1=(1,"hello",True)
#只有1个元素的元组，必须，
tpl1=(1,)
tpl2=(1)
print(type(tpl1))
print(type(tpl2))
#嵌套
t=((1,2,3),('a','b'),'a',1,'b','a')
print(t)
print(t[1][1])
print(t.index(('a','b')))
print(t.count('a'))
print(len(t))
#遍历
i=0
while i<len(t):
    print(t[i])
    i+=1

for i in range(len(t)):
    print(t[i])

#修改内容
print("修改内容")
tp=(1,"a",[1,2,'b'])
tp[2][2]=3
print(tp)   #可以修改元组中的list元素中的值
tp[1]='b'
#print(tp[1]) #不能修改元组值


'''
3.str""
'''
'''字符串:不支持修改字符,只能替换replace'''
str1="name and number"
print(str1[1])
print(str1[-2])
print(str1.index('e'))
print(str1.index("and"))
#替换
#str1[3]='m'  #不能修改
str2=str1.replace("and","or")
print(str2)
#split -----得到一个列表对象
lst=str1.split(" ")
print(lst)
print(type(str1.split(" ")))
#规整strip
str=" hello dear python ! "
print(str)
print(str.strip())
print(str.lstrip()) #去首部空格
str1="dear python!ed"
str2="dear python!e"
print(str1.strip("de"))
print(str2.strip("de")) #首位包含任意一个就去除
#统计
print(str.count("e"))
print(len(str))


'''
序列的切片操作[起始，结束，步长]
'''
lst=[0,1,2,3,4,5,6,7]
print(lst[::2])
tp=(0,1,2,3,4,5,6,7,8)
print(tp[1:-2:3])
print(tp[::-2])  #步长为-表示从后向前
str="abcdefghijk"
print(str[2:-2:2])

'''
4.set{}
'''
'''集合：无序（不支持下标索引访问），不允许重复，允许修改'''
set_empty={}
set1={"a","b","c","a","b","c"}
print(set1)
set2={"a","b",1,2}
# 添加
set2.add("c")
print(set2)
# 移除
set2.remove(1)
print(set2)
# 随机取数
print(set2.pop())
print(set2)
print(set2.pop())
# 清空
set2.clear()
print(set2)
# 差集
set1={1,2,3}
set2={2,3,4}
print(set1.difference(set2)) #1有2没有
print(set1)
print(set2)
print(set1.difference_update(set2))
print(set1)
print(set2)
# 并集
print(set1.union(set2))
print(set1)
print(set2)
# 对称差：仅存在于 set1 或 set2 中的元素
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
# 使用 symmetric_difference_update 方法更新 set1
set1.symmetric_difference_update(set2)
print(set1)

# 统计
print(len(set1))
# 不支持while循环，for循环不能用下标索引
for element in set1:
    print(element)

'''
5.dictionary{key:value} 键值对
'''
'''字典：用key取value，不能有重复key；可以嵌套，key不能为字典;不能while循环'''
dict_empty={}
dict_empty = dict()
dic={"a":1,"b":2,"c":3}
print(dic)
# dic={"a":1,"a":2,"c":3} #重复值 后覆盖前
# print(dic)
print(dic["a"]) #类似索引取值
dic1={"a":(1,2,3),"b":(4,5,6)}
print(dic1["a"])
dic2={
    "a":{"1":1,"2":2},
    "b":{"1":2,"2":4}
}
print(dic2["a"])
print(dic2["a"]["1"])
dic3={1:2,2:4,3:6}
print(dic3[1])
#增加
dic["d"]=5
print(dic)
#更新
dic["d"]=4
print(dic)
#删除
dic.pop("d")
print(dic)
#获取key值
print(dic.keys())
#遍历
for key in dic.keys():
    print(key,",",dic[key])
for key in dic:
    print(key,",",dic[key])

#统计
print(len(dic))
#清空
dic.clear()
print(dic)