python – 数据容器

五种数据容器

1.list（列表） 2.tuple（元组） 3.str（字符串） 4.set（集合） 5.dict（字典）

一.list（列表）

定义空列表可以使用[] 列表中的元素的是有上限的,只是比较大基本上都可以满足日常使用,并且列表中可以存放不同类型的元素 基础示例：

# 1.定义一个列表
name = ["li","se","tom"]
# 取出第一个元素,从0开始
msg = name[0]
print(f"第一个元素为：{
msg}
")
#取出最后一个元素,-1表示最后一个-2表示倒数第二
msg = name[-1]
print(f"最后一个元素为：{
msg}
")


# 2.定义嵌套列表
name = [[1,2,3],[4,5,6]]
#取出第一个元素,从0开始
msg = name[0][1]
print(f"第一个元素中第二个元素为：{
msg}
")
#取出最后一个元素,-1表示最后一个-2表示倒数第二
msg = name[-1][2]
print(f"最后一个元素中第3个元素为：{
msg}
")

list常用操作

# 1.列表.index(元素) - 查询元素在列表中的下标,（注意未找到会报错）
list = [[1,2,3],[4,5,6]]
msg  = list.index(1)
print(f"1在列表中的下标为 - {
msg}
")


# 2.list[0][0] - 修改指定元素值
list = [[1,2,3],[4,5,6]]
msg  = list[0][0]
print(f"当前值为 - {
msg}
")
list[0][0] = 0
print(f"修改后的值为 - {
msg}
")


# 3.列表.insert - 指定下标插入指定元素
list = [1,2,3]
msg  = list[1]
print(f"当1号下标为 - {
msg}
")
list.insert(1,0)
print(f"修改后的1号下标为 - {
msg}
")


# 4.列表.append - 在列表尾部新增一个新的元素
list = [1,2,3]
print(f"当前列表为 - {
list}
")
list.append(4)
print(f"新增后的列表为 - {
list}
")


# 5.列表.extend - 在列表尾部新增一批元素
list1 = [1,2,3]
print(f"批量新增前的列表为 - {
list1}
")
list2 = [4,5,6]
list1.extend(list2)
print(f"批量新增后的列表为 - {
list1}
")


# 6.del 列表.[0] - 删除指定下标的元素
list = [1,2,3]
print(f"list删除前的列表为 - {
list}
")
del list.[0]
print(f"list删除后的列表为 - {
list}
")


# 7.列表.pop[0] - 删除指定下标的元素,与del不同的是,pop在删除的时候会将删除的内容返回
list = [1,2,3]
print(f"pop删除前的列表为 - {
list}
")
list.pop[0]
print(f"pop删除后的列表为 - {
list}
")


# 8.列表.remove(匹配内容) - 删除元素在列表中的第一个匹配项
list = [1,2,3,1,2,3]
print(f"remove删除前的列表为 - {
list}
")
list.remove(1)
print(f"remove删除后的列表为 - {
list}
")


# 9.列表.clear() - 清空列表
list = [1,2,3,1,2,3]
print(f"clear清空前的列表为 - {
list}
")
list.clear()
print(f"clear清空后的列表为 - {
list}
")


# 10.列表.count(元素) - 统计指定元素在列表中的数量
list = [1,2,3,1,2,3]
msg = list.count(1)
print(f"1在当前的列表数量为 - {
msg}
")


# 11.len(列表) - 统计列表中的元素数量
list = [1,2,3,1,2,3]
msg = len(list)
print(f"当前的列表元素数量为 - {
msg}
")

while遍历list

list = [1,2,3]
i = 0
while i  len(list):
  print(f"第{
i+1}
个元素为{
list.[i]}
"
      i += 1

for遍历list

i = 0
list = [1,2,3]
for msg in list:
      i += 1
      print(f"第{
i}
个元素为{
msg}
")

tuple（元组）

元组与列表的使用大同小异基本上,但是元组具有不可修改性,定义的方式为()

# 1.空元组定义
num = ()
num = tuple()
print(num)


# 2.带参元组定义
num = (1,2,3)
print(num)


# 3.嵌套元组定义
num = ((1,2,3),(4,5,6)
print(num)

元组常用操作

# 1.tuple.index(元素) - 查询元素在元组中的下标,（注意未找到会报错）
tuple = ((1,2,3),(4,5,6))
msg  = tuple.index(1)
print(f"1在元组中的下标为 - {
msg}
")


# 2.tuple.count(元素) - 统计指定元素在元组中的数量
tuple = [1,2,3,1,2,3]
msg = tuple.count(1)
print(f"1在当前的元组数量为 - {
msg}
")


# 3.len(tuple) - 统计元组中的元素数量
tuple = [1,2,3,1,2,3]
msg = len(tuple)
print(f"当前的tuple元素数量为 - {
msg}
")

str（字符串）

字符串其实也是一个个元素组成的一个数据容器 直接看基础操作

# 1.通过下标取出值
msg = "Hello"
print(f"msg字符串的第一个元素为{
msg[0]}
")
print(f"msg字符串的最后一个元素为{
msg[-1]}
")


# 2.str.index(元素) - 查询元素在字符串中的下标,（注意未找到会报错）
str = ((1,2,3),(4,5,6))
msg  = str.index(1)
print(f"1在字符串中的下标为 - {
msg}
")


# 3.str.replace(元素) - 字符串替换
msg  = "HELLO"
print(f"当前msg为 - {
msg}
")
msg.replace("ELLO,ello")
print(f"替换后的msg为 - {
msg}
")


# 4.str.split(元素) - 字符串分割
msg  = "HELLO 你好哇 我是lin"
print(f"分割前的msg为 - {
msg}
")
new_msg = msg.split(" ")
print(f"分割后的msg为 - {
new_msg}
")

# 5.str.strip(元素) - 字符串规整
#str.strip(元素)为空时表示去除首尾空格
msg  = " HELLO "
print(f"strip前的msg为 - {
msg}
")
new_msg = msg.strip()
print(f"strip后的msg为 - {
new_msg}
")


# 6.str.strip(元素)不为空时表示去除首尾指定元素
msg  = "01HELLO10"
print(f"strip前的msg为 - {
msg}
")
new_msg = msg.strip("01")
print(f"strip后的msg为 - {
new_msg}
")
# 注意该操作会把01和10都给去除,因为它会将字符串进行分割,只要满足任意一项就会去除该元素


# 7.str.count(元素) - 统计指定元素在字符串中的数量
str = [1,2,3,1,2,3]
msg = str.count(1)
print(f"1在当前的字符串中数量为 - {
msg}
")


# 8.len(str、) - 统计元组中的元素数量
str = [1,2,3,1,2,3]
msg = len(str)
print(f"字符串str元素数量为 - {
msg}
")


# 9.isdigit() - 判断字符转是否为纯数字

msg.isdigit()

数据容器的切片

大概的意思就是将字符串或者列表/元组里的元素分为一个个小块,取出指定的一部分元素

"""
str = "123456789"
str[1:7:2]
1表示从第几个元素开始切,示例为2开始,为空表示第一个元素开始
7表示从在几个元素前结束,示例为8结束,为空表示最后一个元素结束
2表示跨步元素数量,比如1取完就跳过2取3,为空表示不跳过
"""

# 1.正向切片示例
str = "123456789"
msg = str[1:7:2]
print(f"正向切片后的msg为 - {
msg}
")


# 2.反向切片示例
str = "123456789"
msg = str[1:7:-2]
print(f"反向切片后的msg为 - {
msg}
")


# 3,字符串反转示例
str = "123456789"
msg = str[::-1]
print(f"反转后的msg为 - {
msg}
")

set（集合）

集合和列表等的不同主要在集合自带去重功能,并且集合为无序

# 1.空集合定义
# 空集合不能使用{
}
来定义,{
}
被字典占用了
set = set()


# 2.去重测试
set = {
1,2,3,4,5,6,1,2,3,4,5,6,1,2,3,4,5,6}

print(f"set的去重测试结果为 - {
set}
")


# 3.set.add(元素) - 添加集合
set = {
1,2,3}

print(f"添加前的set为 - {
set}
")
set.add(4)
print(f"添加后的set为 - {
set}
")


# 4.set.remove(元素) - 删除集合
set = {
1,2,3}

print(f"删除前的set为 - {
set}
")
set.remove(3)
print(f"删除后的set为 - {
set}
")


# 5.set.pop(元素) - 随机取出一个集合元素,取出后就不存在集合中了
set = {
1,2,3}

print(f"随机取出前的set为 - {
set}
")
set.pop(3)
print(f"随机取出后的set为 - {
set}
")


# 6.set.clear() - 清空集合
set = {
1,2,3}

print(f"清空前的set为 - {
set}
")
set.clear()
print(f"清空后的set为 - {
set}
")


# 7.set.difference() - 消除两个集合的差集,就是在集合1中将集合2和集合1的共同元素去除,返回一个新的集合
set1 = {
1,2,3}

set2 = {
1,4,5}

msg = set1.difference(set2)
print(f"取差集后的set为 - {
msg}
")
# 结果为 - {
2,3}



# 8.set.union() - 合并两个集合,将集合1有的但是集合2中没有的合并,得到一个新的集合
set1 = {
1,2,3}

set2 = {
1,4,5}

msg = set1.union(set2)
print(f"合并集后的set为 - {
msg}
")
# 结果为 - {
1, 2, 3, 4, 5}



# 9.len(set) - 统计集合元素数量
set = {
1,2,3}

print(f"set的元素数量为 - {
len(set)}
")


# 10.len(set) - 统计集合元素数量
set = {
1,2,3}

print(f"set的元素数量为 - {
len(set)}
")

# 11.集合的遍历操作
# 因为集合不支持下标索引所以集合不能使用while进行遍历,只能使用for
set = {
1,2,3}

for msg in set:
  print(f"集合的元素有 - {
msg}
")

dict（字典）

字典的话就是具有可查找性,可以通过指定的key找到所需要的value,重复的key会取最后一个key为返回结果

# 1.字典定义
dict = {
}

dict = dict()
dict = {
1:"a",2:"b",3:"c"}



# 2.字典的基础使用
dict = {
1:"a",2:"b",3:"c"}

print(f"dict中key1的value是 - {
dict[1]}
")
# 输出结果为 - dict中key1的value是 - a


# 3.字典的嵌套使用
dict = {
1:{
"a":"123"}
,2:{
"b":"456"}
,3:{
"c":"789"}
}

msg = dict[1]["a"]
print(f"dict嵌套取值为 - {
msg}
")


# 4.dict[key] = value - 字典新增元素
dict = {
}

dict[1] = "123"
msg = dict
print(f"dict新增后的值为 - {
msg}
")
dict[1]= "456"
msg = dict
print(f"dict修改后的值为 - {
msg}
")


# 5.dict.pop(key) - 字典移除元素
dict = {
1:"a",2:"b",3:"c"}

msg = dict
print(f"dict移除前的值为 - {
msg}
")
dict.pop(1)
msg = dict
print(f"dict移除后的值为 - {
msg}
")


# 6.dict.clear() - 清空字典元素
dict = {
1:"a",2:"b",3:"c"}

dict.clear()
msg = dict
print(f"dict已被清空 - {
msg}
")


# 7.dict.keys() - 获取字典内的全部key,主要用于for循环遍历中
dict = {
1:"a",2:"b",3:"c"}

msg = dict.keys()
print(f"dict中的key有 - {
msg}
")


# 8.for遍历dict
dict = {
1:"a",2:"b",3:"c"}


for key in dict.keys():

    print(f"当前key为{
key}
,value为{
dict[key]}
")


# 9.len(dict) - 取出字典的元素数量
dict = {
1:"a",2:"b",3:"c"}

print(f"dict中的元素数量为 - {
len(dict)}
    ")

数据容器的通用操作

max() – 取出数据容器中的最大元素 min() – 取出数据容器中的最小元素 sorted() – 对容器进行排序默认从小到大,排序的结果为列表,如果需要从大到小则改为sorted(,reverse=Ture)

list() – 将其它类型容器转换为列表容器 str() – 将其它类型容器转换为字符串容器 tuple() – 将其它类型容器转换为元组容器 set() – 将其它类型容器转换为集合容器

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！