python容器
数据容器分类：list,tuple,str,set,dict
list
1、列表的格式：
变量名称=["元素1","元素2","列表1","元素4"]
eg:name_list=["wo","xi","huan","ni","520",[1,2,3]]
#定义空变量 变量名称=[] 变量名称=list()
2、列表的索引
name_list=["tom","kali","rose"，[1,2,3]]
可以通过索引取出对应位置的元素,从左向右从0开始，从右向左从-1开始
#print(name_list[0])#结果为tom
#print(name_list[-1])#结果是[1,2,3]
#嵌套列表的下的索引
#print（name_list[-1][-1])#结果是3
3、列表常用的方法
（1）计算列表的长度
name_list=["tom","kali","rose"，[1,2,3]]
print(len(name_list))#结果为4
（2）查询某元素的下表
name_list=["tom","kali","rose"，[1,2,3]]
print(name_list("kali")#1
（3）修改特定元素的值
name_list=["tom","kali","rose"，[1,2,3]]
name_list[0]="yy"#将tom修改为yy
（4）在指定的下标位置插入元素
name_list.insert(1,"yy")#在kali后面插入yy元素
（5）在列表末尾追加元素，append()方法
name_list.append("yy")#在[1,2,3]后面添加元素yy
（6）在列表末尾追加一个列表，extend()方法
name_list=["tom","kali","rose"，[1,2,3]]
name_list1=["toms","kalis","roses"，[1,2,3s]]
name_list.extend(name_list1)#结果就是将name-list1的元素添加到name_list中
（7）删除列表元素
A=["tom","kali","rose",[1,2,3]]
del A[0]#删除了tom
A.pop(0)#删除了tom并且取出了tom，并且可以赋值给变量
A.remove("tom")#通过名称进行删除，删除相同名称的第一个元素
A.clear()#清空A整个字典
（8）统计某个元素在列表中的数量count()方法
A=["tom","kali","rose","kali","kali",[1,2,3]]
b=A.count(kali)#kali在A中出现的次数
(9)给列表中的元素进行从小到大排序sort()方法和倒置排序reversed（）方法
A=["tom","kali","rose","kali","kali",[1,2,3]]
A.sort()#给列表进行大小排序#使用sort方法时必须列表元素都是数字才可以
A.reversed()#进行倒置排序
4、列表的遍历
while循环遍历
点击查看代码
while循环遍历
def add()
list=[1,2,3,4,5,6,]
index=0
while index<len(list):
a=list[index]
print("a")
index+=1
for循环的遍历
def add():
list=[1,2,3,4,5,6]
for i in list:
print(i)
add()
def add()
list=[1,2,3,4,5,6,]
index=0
while index<len(list):
a=list[index]
print("a")
index+=1
for循环的遍历
def add():
list=[1,2,3,4,5,6]
for i in list:
print(i)
add()
tuple
1、定义
元组与列表的区别：元组和列表都是数据容器，列表可以修改数据，但是元组不可以修改数据，但是可以修改里面嵌套的列表或者元组
#元组的定义格式：元组名=（元素1，元素2，元素3，元素4）
#空元组的定义 元组名=（）
#注意点，当元组里面只有一个元素时，必须在后面加上,号，否则就不是元组类型 a=("hello",）
2、元组的常用方法
1，通过下标索引输出元素
a=(1,2,3,4,5,6,7,8,9)
print(a[0])#结果为1
2，由于元组不可修改，所以不能增删
#index()方法查看元素的下标索引
a=(1,2,3,4,5,6,7,8,9)
a.index(3)#查看3元素的下标索引
#count()查看元素在元组中出现的次数
a.count(2)#查看2在元组中的出现的次数
#len()方法查看元组的长度
len(a)#结果是9
元组的遍历
while循环 a=(1,2,3,4,5,6,7,8,9) index=0 while index<len(a): a[index]#取出元素 print(f"a元组的元素有{a[index]}") index+=1 for循环 a=(1,2,3,4,5,6,7,8,9) for i in a: print(f"a元组中的元素有{i}")
字符串
字符串的定义
字符串时字符的容器，同时支持通过下标索引查找字符，和元组一样，不允许修改字符串里面的字符
字符串的常用方法
(1)字符串的替换
通过下标索引取出相应的字符
my_str="wxhgnzyy"
print(my_str[0])#输出w字符
通过字符查找该字符的下标索引
my_str.index("y")#输出结果是6
my_str.count("y")#统计字符y在字符串中出现的次数
len(my_str)#统计字符串的长度
字符串的替换replace()方法
new my_str=my_str.replace("zyy","zbx")#输出结果是"wxhgnzbx"
(2)字符串的分割.split()方法
my_str="wx1hg1nz1yy"
my_str.split("1")#将字符串以字符1进行切分，输出结果是"wx","hg"，"nz","yy"
(3)字符串的规整操作，取出前后的空格
my_str=" wxhgnzyy "
new my_str=my_str.strip()#去除前后的空格，这里没有传入参数
new my_str=my_str.strip("yy")#取出字符串中的yy字符
(4)字符串的遍历
while循环 def str(): my_str="wx1hg1nz1yy" index=0 while index<len(my_str): a=my_str[index]#将index的设置以列表的形式输出 print(a) index+=1 print(f"字符串my_str的元素有{a}") str() for循环遍历 my_str="wx1hg1nz1yy" for i in my_str: print(f"字符串{my_str}的元素有{i}")
数据容器的切片
(1)语法:序列[起始下标：结束下标：步长]
my_list=[0,1,2,3,4,5,6,7]
a=my_list[1:4]#结果为1,2,3,不包括4
a=my_list[:]#结果为1，2，3，4，5，6，7
a=my_list[::2]#结果是0,2,4,6,
set
集合的定义
列表可以修改，支持重复元素
元组不可以修改，支持重复元素
集合可以修改，和列表的方法大同小异，集合不支持重复的元素
常见的使用方法
（1）由于集合是无序的，所以不支持下标索引查找元素
（2）添加新元素 add()方法
my_set={"aaa","bbb","ccc","ddd"}
my_set.add("eee")#添加元素"eee",如果添加相同的元素，会自动去重
add()方法只能用于集合，用于列表会出错
（3）删除元素 remove()方法 pop()方法 clear()方法
my_set=["aaa","bbb","ccc","ddd"]
my_set.remove("aaa")
print(my_set)
#my_set.pop()随机取出一个元素
my_set.clear()#清空集合
（4）取两个集合的差集，产生一个差集 difference() 消除差集difference_update()方法
set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)#输出结果为2,3,有点类似于离散数学的差集
set1.difference_update(set2)#消除和set2内相同的元素,set1发生变化,set2不发生变化
(5）两个集合的合并(自动去重）union()
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)#结果是1,2,3,5,6#会自动去重
len(sat1)#统计集合set1的元素数量
(6)集合的遍历
set1={1,2,3,4,5,6,7,8}
点击查看代码
set1={1,2,3,4,5,6,7,8}
for i in set1:
set1.add(i)
print(f"集合中的元素有{set1}")
dict
字典的定义
可以通过key找到对应的value，字典中的key不可以重复，如果重复会报错
my_dict={"zbx":"nan","zxb":"nu"}
定义空的字典
my_dict={}或者dict()
字典的常用方法
1）在字典中获取数据，不能通过下标索引，只能通过key找到value
my_dict={"zbx":"122","zqw":"123"}
a=my_dict["zbx"]#通过key(zbx)去获取它对应的value的值
(2)字典的嵌套使用（字典中的key和value)是任意数据类型（key不可为字典）
my_dit={"aa":{"语文":"66","数学":"99"}}
my_dit["aa"]["语文"]#取到了aa的语文成绩为66
(3)新增字典的元素（如果key存在，就修改，如果没有就新增）
my_dict={"zbx":"122","zqw":"123"}
my_dict["zbx":"221"]#修改zbx对应的value值，输出为221
my_dict["zyy":"122"]#新增元素
（4）删除元素 pop()方法
my_dict={"zbx":"122","zqw":"123"}
my_dict.pop("zbx")#删除zbx元素
my_dict.clear()#清空字典
my.keys()#获取字典的全部key
my_value()#获取全部的value
my_items()#获取全部的键值对
（5）字典的遍历
my_dict={"zbx":"122","zqw":"123"}
点击查看代码
my_dict={"zbx":"122","zqw":"123"}
for i in my_dict:
print(i)
#输出所有的key
容器的通用操作
1，都支持for循环遍历
2，都支持len() max() min()函数
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")
max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")
min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")
3，5种容器类型都支持相互的类型转换
转换为列表
print(f"列表转列表的结果是：{list(my_list)}")
print(f"元组转列表的结果是：{list(my_tuple)}")
print(f"字符串转列表结果是：{list(my_str)}")
print(f"集合转列表的结果是：{list(my_set)}")
print(f"字典转列表的结果是：{list(my_dict)}")
转换为元组
print(f"列表转元组的结果是：{tuple(my_list)}")
print(f"元组转元组的结果是：{tuple(my_tuple)}")
print(f"字符串转元组结果是：{tuple(my_str)}")
print(f"集合转元组的结果是：{tuple(my_set)}")
print(f"字典转元组的结果是：{tuple(my_dict)}")
类型转换: 容器转字符串
print(f"列表转字符串的结果是：{str(my_list)}")
print(f"元组转字符串的结果是：{str(my_tuple)}")
print(f"字符串转字符串结果是：{str(my_str)}")
print(f"集合转字符串的结果是：{str(my_set)}")
4，容器的通用排序
从小到大进行排序
print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")
反排序
print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")