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