Python-数据容器

一种可以容纳多份数据的数据类型

根据特点的不同，如：

是否支持重复元素

是否可以被修改

是否有序等

分为5类：列表List 元组tuple 字符串str 集合set 字典dict

列表list

列表的定义

字面量

[1,2,3,4,5]

定义变量

变量名称=[1,2,3,4]

定义空列表

变量名称=[]

变量名称=list()

列表也是有下标索引的，不同的是，py中的索引可以反向，如最后一个元素下标为-1

存在索引越界问题

常用操作

增删改查

查找某元素的下标,查不到返回ValueError

列表.index(元素)

list = [1, 2, 3, 4]
index = list.index(1)
print(index)

不存在

ValueError: 5 is not in list
 

修改下标索引的值

列表[索引]=值

插入元素

列表.insert(下标，元素)

list = [1, 2, 3, 4]
print(list)
list.insert(1,9)
print(list)

追加元素（尾插）

列表.append(元素)

list = [1, 2, 3, 4]
print(list)
list.append("111")
print(list)

如果要追加一批元素，调用extend方法

列表.extend(其他数据容器)

list = [1, 2, 3, 4]
li2=[5,6]
print(list)
list.extend(li2)
print(list)

删除元素

语法1： del 列表[索引]

语法2： 列表.pop(索引)，pop是有返回值的

list = [1, 2, 3, 4]

print(list)

del list[0]

print(list)

list.pop(0)

print(list)

删除某元素在列表的第一个匹配项

通过内容删除

语法:列表.remove(元素)

list.remove(1)
print(list)
list.remove(5)

查不到就报错

    list.remove(5)
ValueError: list.remove(x): x not in list

清空列表

列表.clear()

统计某元素在列表内的数量

列表.count(元素)

列表的长度

len(列表)

遍历列表

list = [1, 2, 3, 4, 5]

# while循环变量
i = 0
while i < len(list):
    print(list[i])
    i += 1

# for循环遍历
for i in list:
   print(list[i])

元组tuple

元组相当于只读的list，不可被修改

元组定义

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据

定义元组字面量

(1,2,3,4,5)

定义元组变量

变量名称=(1,2,3,4)

定义空元组

变量名称=（）

变量名称=tuple()

元组也支持嵌套

方法方面除了修改元组的方法不可以，其他与list一样

字符串str

一样可以通过下标取值

字符串是一个无法修改的数据容器，如果必须要做，只能得到一个新的字符串

字符串替换

字符串.replace(str1,str2)

将字符串内的全部字符串1替换为字符串2

str1="aaaaaaaaaaa"
str2="bbbbbbbbbbb"

str3 = str1.replace(str1, str2)

print(str3)

字符串的分割

字符串.split(分隔符字符串)

按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表中

str = "aaa bbb ccc ddd"
split_list = str.split(" ")
print(split_list)
# ['aaa', 'bbb', 'ccc', 'ddd']

字符串的规整操作（吃空格）

字符串.strip()

字符串.strip(字符串)

str="12weqweqwe21"
strip= str.strip()

print(strip)
# weqweqwe
str_strip = str.strip("12")
print(str_strip)
# weqweqwe

序列

内容连续，有序，可使用下标索引的一类数据容器

列表元组字符串都是序列

切片

从一个序列中取出一个子序列

语法：序列[起始下标：结束下标：步长]

步长可以为负数，倒着取

切片得到一个新的序列

# 对list切片
list = [1, 2, 3, 4, 5, 6]
list_ = list[1:4]
print(list_)
print("==============")

tuple = (1, 2, 3, 4, 5, 6, 7)
tuple_ = tuple[:]
print(tuple_)

print("===================")

集合set

可以去重，不保证顺序，不支持下标索引访问，允许修改

集合用{}

定义方式类似

添加新元素

add

移除元素

remove

随机取出元素

pop

清空集合

clear

取两个集合的差集

集合1.difference(集合2) 集合1有集合2没有的

消除2个集合的差集

集合1.difference_uppdate(集合2)

删除集合1中集合2有的元素

集合2 不变

两个集合合并

集合1.union(集合2)

得到新的集合

集合不支持下标索引，遍历只能用for循环

字典dict

生活中的字典是一个字对应一个含义

python中的字典是一个key找到所属的value

字典的定义

dict={key:value,key:value....}

d = {1: 10, 2: 20, 3: 30}
d2={}
d3=dict()

字典同样不允许重复

字典中Key value可以是任意数据，Key不可以为字典

新增元素 更新元素

字典[key]=value 

my_dict = {"sb": 99, "rz": 88, "nt": 77}

# 更新元素
my_dict["sb"] = 66

print(my_dict)

# 修改元素
my_dict["aa"]=100
print(my_dict)

删除元素

pop(Key)

返回对应的value

清空元素

clear

获取全部的Key

字典.keys()

keys = my_dict.keys()

print(keys)

遍历通过这个方法可以拿到key

for key in keys:
    print(f"{key}的分数是{my_dict[key]}")

但是如果直接对字典进行for循环，结果是一样的，也是取出key

容器之间也是可以相互转换的，跟强制类型转换一样，但是转换不了字典，因为不是键值对

通用排序功能

sorted(列表，正反序)

排序的结果统统变为列表对象

sorted(my_dict, reverse=True)

反转操作