目录
- [列表 list](#列表 list)
- [元组 tuple](#元组 tuple)
- [字典 dict](#字典 dict)
- [集合 set](#集合 set)
列表 list
1、是一个有序的项目集合
2、是可变数据类型
3、可以存放任何数据类型
初始化
python
lst = [] # 方式一
print(type(lst)) # <class 'list'>
lst2 = list() # 方式二
print(lst2, type(lst2)) # [] <class 'list'>
lst3 = list("abc") # 参数传递必须为可迭代对象，即可用for循环遍历
print(lst3) # ['a', 'b', 'c']切片（有序）
切片与字符串一模一样
python
>>> lst = ['x', "y", 1, None]
>>> print(lst[::-1])
[None, 1, 'y', 'x']
# 可以使用切片赋值，当传递的参数超过切片长度时，会自动依次添加到切片后面的位置，相当于insert()，列表长度增加；当参数长度小于切片长度时相当于替换replace()，列表长度减小
lst[0:2]="abc"可变数据类型
python
# 使用下标或切片进行赋值都不会重新产生一个列表，列表所指向的内存空间不会改变
>>> lst=[]
>>> print(lst,id(lst))
[] 140687159259336
>>> lst[0]='a' # 下标不能溢出，replace()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
>>> lst[0:]='a' # 切片可以溢出,溢出即插入，不溢出就替换
>>> print(lst,id(lst))
['a'] 140687159259336
>>> lst[0]='b'
>>> print(lst,id(lst))
['b'] 140687159259336
# 使用"lst="赋值时会产生新的列表，相当于重定向
>>> lst=['c']
>>> print(lst,id(lst))
['c'] 140687159250760存放任何数据类型
python
# 可以存放任何数据类型，包括函数、类
lst.append(print) # 这里print不加（）代表加入print函数，加了括号代表返回值
print(lst)常用方法
python
print(dir(list)) # 查看所有方法
# 增
lst.append(['a', 'b']) # append()在末尾添加元素 这里添加了个列表
lst.insert(0, list) # insert()在指定位置插入元素 这里插入了list类
lst.extend("abc") # extend()在末尾添加列表，必须也是可迭代对象,相当于 +
# 删
lst.pop(2) # pop()删除指定位置的元素，默认最后一个
lst.remove('x') # remove()删除指定元素
lst.clear() # clear()清空列表
# 改
lst.reverse() # reverse()反转,会改变原列表值
lst = ['x', 'y', '31', '241']
lst.sort() # sort()排序,字符串通过unicode码进行排序,list和string不能同时存在,str和int也不能同时存在
# 统计(查)
print("************************")
print(len(lst))
print(lst.count("x"))
print(lst.index("x"))# 返回下标
lst=[1,2,3,4,5,6]
print(max(lst))
print(min(lst))
print(sum(lst))运算
python
>>> lst = ['x', 'y']
>>> lst2 = ['a', 'b']
>>> lst3 = lst + lst2 # 加法
>>> print(lst3, id(lst), id(lst2), id(lst3))
['x', 'y', 'a', 'b'] 140687159259336 140687159250760 140687159259400
>>> lst3 = lst * 2 # 乘法
>>> print(lst3)
['x', 'y', 'x', 'y']底层存储（地址值的传递）
python
>>> lst4 = lst3 # 这样的赋值传递的是地址值
>>> print(id(lst3), id(lst4))
140687159259656 140687159259656
# 当其中一个改变了，其他指向这个地址值的的变量也会变，
# 与string不同，string是不可变数据类型，当变量改变时，string变量底层是指向了另一个地址，原地址的值不会变
>>> lst3.append("zz")
>>> print(lst3, lst4)
['x', 'y', 'x', 'y', 'zz'] ['x', 'y', 'x', 'y', 'zz']
# 使用copy()或者切片就不会指向同一个地址
... lst5 = lst3.copy()
>>> print(id(lst3), id(lst5))
140687159259656 140687159259400
>>> lst6 = lst3[:]
>>> print(id(lst3), id(lst6))
140687159259656 140687159260168遍历
python
>>> for i in lst3: # 遍历每个元素
... print(i)
...
x
y
x
y
zz
>>> for k, v in enumerate(lst3): # 类似go的遍历，k为下标(从0开始)，v为值(类型为str)
... print(k, v)
...
0 x
1 y
2 x
3 y
4 zz示例
对输入的字符串只保留字母和数字，然后再进行判断是否为回文
python
while 1:
str1 = input(":")
if str1=="q":
break
str2 = ""
for i in str1:
if i.isalnum(): # 字符串保留字符数字
str2 += i
str2 = str2.lower() # 忽略大小写
if str2 == str2[::-1]: # 反转字符串进行比较
print("是回文")
else:
print("不是回文，请重新输入，按q退出")对于一个已知的整数列表，给出一个整数，判断列表中是否有两个数相加与其相等
python
# 示例：lst = [2,4,6,7,3,5,9,12]
# 从键盘输入一个数， 10 --》10=4+6 --》输出下标：1，2
lst=[3,5,7,11,13,17,2,1]
num=int(input("请输入一个整数："))
flag1=1
for k,v in enumerate(lst[:len(lst)-1]):
for i in lst[k+1:]:
if int(v)+int(i)==num:
print(f"{num}={v}+{i}")
flag1=0
if flag1==1:
print(f"没有两个数加起来等于{num}")元组 tuple
初始化
python
# 方式一
>>> t1 = (1) # 一个元素无法识别是元组还是括号,此时为int类型
>>> t2 = (1,) # 一个元素加个逗号就行
>>> t3 = (1, 2)
>>> print(type(t1), type(t2), type(t3))
<class 'int'> <class 'tuple'> <class 'tuple'>
# 方式二
>>> b=tuple("abc")
>>> print(b)
('a', 'b', 'c')可以存放任意数据类型
可以切片
与list的主要区别是不可变
不可变数据类型,改变任意地址值都会报错：TypeError: 'tuple' object does not support item assignment
python
>>> t3[1]=1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment元组内存放可变数据类型时，改变可变数据类型的值是可以的，因为元组的地址值并没有改变
python
>>> t4 = ("x", "abc", [1, 2, 3])
>>> t4[2].append(4)
>>> print(t4)
('x', 'abc', [1, 2, 3, 4])运算
python
# 运算也可以，相加会生成新元组
print(t3 + t4)与list相互转换
python
lst = list(t4)
print(lst, type(lst))
t5 = tuple(lst)
print(t5, type(t5))字典 dict
键值映射的数据结构、无序、可变数据类型
初始化
python
d1 = {"name": "wenyao", "age": 18}
print(d1["name"]) # key不存在时会报错
d1["gender"] = "female" # key不存在时新增，存在时重新赋值
d1.get("xx", 1) # key不存在时不会报错，默认返回值为None，也可以指定key不存在时的返回值，这里指定为 1key 自动去重，后面的覆盖前面的
python
>>> d2 = {1: "a", 2: "b", 2: "c"}
>>> print(d2)
{1: 'a', 2: 'c'}key必须为可hash对象，暂时理解为不可变数据类型，字符串、元组都行(但元组里的元素也得是不可变数据)，列表不行
value可以是任何值
删除
python
d1 = {1: "x", 2: "y"}
print(d1.pop(1)) # pop()删除指定key，返回velue值
print(d1.popitem()) # popitem()，默认删除最后一个key，返回(key,value)字典的合并
python
>>> print(d1, d2)
{1: 'x', 2: 'y'} {1: 'a', 2: 'c'}
>>> d1.update(d2) # 将d2合并到d1,d2值不变,d1值改变
>>> print(d1, d2)
{1: 'a', 2: 'c'} {1: 'a', 2: 'c'}
>>> d1 = {"a": 1}
>>> d2 = {"b": 2}
>>> d3 = dict(d2, **d1) # 将d1和d2合并成新的字典，d1 d2的值都不变,key类型必须为string,且需要符合变量名规范
>>> print(d1, d2, d3)
{'a': 1} {'b': 2} {'b': 2, 'a': 1}in、not in、values()
python
>>> print("b" in d3, 2 in d3) # 这样判断的是key
True False
>>> print(2 in d3.values()) # values()返回values列表，类型为'dict_values'
True
>>> print(type(d3.values()))
<class 'dict_values'>遍历
python
for i in d3: # 只返回key
print(i)
for i in d3.items(): # 返回（key，value），类型为元组
print(i)
for k, v in d3.items(): # 分别赋值key、value
print(f"{k}->{v}")
for i in d3.values(): # 只返回value
print(i)常见应用格式
python
d1 = {"root": {"passwd": "123456", "balance": 500}, "admin": {"passwd": "123456admin", "balance": 300}}
print(d1["root"]["passwd"]) # 方式一
print(d1.get("root").get("passwd")) # 方式二与列表、元组的转换
python
>>> lst = [("a", 1), ("b", 2)] # 只有这种列表里是元组且是键值对形式的才可以转字典
>>> d4 = dict(lst)
>>> print(d4)
{'a': 1, 'b': 2}
>>> print(list(d4)) # 得到 key 列表
['a', 'b']
>>> print(list(d4.items())) # 得到 (key,value) 列表
[('a', 1), ('b', 2)]json 格式的转换
json 是一种轻量型的数据交换格式，可用于字符串与字典的转换
python
>>> import requests
>>> result = requests.get("https://dhfmainapi.360dhf.cn/api/v2/zy-order-pay-log/real-time-overview")
>>> str1 = result.text # 得到一个json格式的字符串
>>> print(type(str1), str1)
<class 'str'> {"code":400,"data":null,"message":"请先登录"}
>>> import json
>>> d1 = json.loads(str1) # 将字符串转换成字典
>>> print(type(d1), d1)
<class 'dict'> {'code': 400, 'data': None, 'message': '请先登录'}
>>> d1["test"] = "abc"
>>> str2 = json.dumps(d1) # 将字典转换成字符串
>>> print(type(str2), str2) # 汉字会被转换为unicode编码
<class 'str'> {"code": 400, "data": null, "message": "\u8bf7\u5148\u767b\u5f55", "test": "abc"}字典底层原理--空闲哈希表
参考链接：为什么Python 3.6以后字典有序并且效率更高？ - 知乎 (zhihu.com)
对于d1={"a":1}，在空闲散列表中先加密，根据**哈希值最后一位数(或者取余)**确定存储位置，(为什么要加密？因为通过取余可以快速找到数据位置)
如果有其他元素的尾数一样(散列冲突 )，则用开放地址寻址法，使用开放地址函数，一般是向下寻找
先记住：表中存储的是key哈希值、key地址值、value地址值
indices存放元素在entries里的具体位置
hash算法：把任意长度的输入，变成固定长度的输出，单向加密算法，一种明文只对应一种密文，不过极小概率不同的明文对应同一种密文
破解：撞库（存储一些明密文的对应） --> 解决：加盐（密文长度加长）
应用：1.数据加密
2.签名摘要（防止篡改或完整性验证）：通过对整个文件加密得到哈希值，然后接收方接收后对文件进行加密验证看是否与之前一致
Linux体验之MD5，命令：echo xxx |md5sum 或者 md5sum xxx.txt可以加密语句也可以加密文件
集合 set
集合（set）可以理解为只有key的字典
因此，key唯一，无序，key得是可hash对象------------不可变
初始化
python
>>> s1={1,2,3} # 方式一
>>> s2=set() # 方式二
>>> print(type(s1),type(s2))
<class 'set'> <class 'set'>
>>> s3={}
>>> print(type(s3)) # 使用{}初始化的数据类型是字典
<class 'dict'>与list的转换
通过set()、list()函数可以相互转换
python
>>> lst=[1,2,3]
>>> s3=set(lst) # 如果有重复的会去掉
>>> print(s3)
{1, 2, 3}
>>> lst2=list(s3)
>>> print(lst2)
[1, 2, 3]添加、删除
python
>>> # 添加
... s1.add(4) # 添加到末尾
>>> s1.update("abc") # 只能添加可迭代对象，然后一个一个add
>>> # 删除
... s1.remove(4) # 删除指定元素，没有就报错
>>> s1.discard(4) # 不会报错
>>> print(s1)
{1, 2, 3, 'b', 'c', 'a'}
>>> s1.remove(4) # 删除指定元素，没有就报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 4集合运算
python
#运算 -：差集，在a不在b &:交集 |:并集，ab所有元素 ^:对称差集，只在a或者只在b
a={1,2,3}
b={2,3,4}
print(a.union(b))# |
print(a.intersection(b))# &
print(a.difference(b))# -
print(a.symmetric_difference(b))# ^小结
本节文章主要讲解了python中的容器类型，包括列表、元组、字典和集合，内容包含了其特点和常用方法，帮助大家快速了解容器类型的使用和异同。如有不足之处，希望能帮忙指出，笔者会及时改正，感谢大家观看！