初识python容器

数据容器

1，数据容器：一种可以容纳多份数据的数据类型，数据成为元素，数据可以是任意类型的数据，如字符串，数字，布尔等
2，数据容器有哪些数据容器
list(列表) tuple(元组) str(字符串) set(集合) dict(字典)

列表

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）函数len()计算的列表的长度

name_list=["tom","kali","rose"，[1,2,3]]   
print(len(name_list))#结果为4

(2)查询某元素的下标 index()方法

name_list=["tom","kali","rose"，[1,2,3]]   
A=name_list.index("tom) 
print(f"tom在列表中的下标索引为{A})#结果为0
#print(name_list.index(111))#结果会报错，列表中不存在111的元素

（3）修改特定位置的元素值

name_list=["tom","kali","rose"，[1,2,3]]
name_list[0]="yy"#将tom修改为yy
name-list[0][2]=[11,22,33]#将tom,kali,rose修改为11,22,33

(4)在指定的下标位置插入元素 ，insert(）方法

name_list=["tom","kali","rose"，[1,2,3]]   
name_list.insert(1,"yy")#在kali后面插入yy元素

(5)在列表末尾追加元素，append()方法

name_list=["tom","kali","rose"，[1,2,3]]   
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）删除列表中元素的删除 del关键字方法 pop()方法 remove()方法

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、列表的循环遍历

（1）while和for循环遍历

#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()

元组

1、元组的定义

1,元组与列表的区别：元组和列表都是数据容器，列表可以修改数据，但是元组不可以修改数据，但是可以修改里面嵌套的列表或者元组

2，元组的定义

#元组的定义格式：元组名=（元素1，元素2，元素3，元素4）
#空元组的定义 元组名=（）
#注意点，当元组里面只有一个元素时，必须在后面加上,号，否则就不是元组类型 a=("hello",）

3，元组内元素和列表一样不受类型的限制，可以嵌套元组，列表

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

3、元组的遍历

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、字符串的定义

字符串时字符的容器，同时支持通过下标索引查找字符，和元组一样，不允许修改字符串里面的字符

2、字符串的常用方法

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

3、数据容器的切片

(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,

集合

1、集合的定义

1，列表list[]，元组()，集合{}三种的关系

列表可以修改，支持重复元素

元素不可以修改，支持重复元素

元素可以修改，和列表的方法大同小异，集合不支持重复的元素

my_set={"aaa","bbb","ccc","ddd"}
#空集合的定义,步允许重复，内容是无序
a=set()或者a={}

2、集合常用的使用方法

（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的元素数量

3、集合的遍历

set1={1,2,3,4,5,6,7,8}
for i in set1:
    set1.add(i)
print(f"集合中的元素有{set1}")

字典

1、字典的定义

1，可以通过key找到对应的value

2,字典中的key不可以重复，如果重复会报错

（1）使用{}来定义，但是与集合不同的是，集合内放的是单个数据，但是字典中放的是{key:value}的键值对

my_dict={"zbx":"nan","zxb":"nu"}
#定义空的字典
my_dict={}或者dict()

2、字典的常用方法

（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"}
for i in my_dict:
    print(i)
#输出所有的key

数据容通用操作

（1）通用操作
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)}")