网站建设公司发展,wordpress调用当前分类链接,店铺推广文案,网址收录目录 列表 list初始化切片#xff08;有序#xff09;可变数据类型存放任何数据类型 常用方法运算底层存储#xff08;地址值的传递#xff09;遍历示例 元组 tuple初始化与list的主要区别是不可变运算与list相互转换 字典 dict初始化删除字典的合并in、not in、values()遍… 目录 列表 list初始化切片有序可变数据类型存放任何数据类型 常用方法运算底层存储地址值的传递遍历示例 元组 tuple初始化与list的主要区别是不可变运算与list相互转换 字典 dict初始化删除字典的合并in、not in、values()遍历常见应用格式与列表、元组的转换json 格式的转换字典底层原理--空闲哈希表 集合 set初始化与list的转换添加、删除集合运算 小结 列表 list 1、是一个有序的项目集合 2、是可变数据类型 3、可以存放任何数据类型 初始化
lst [] # 方式一
print(type(lst)) # class list
lst2 list() # 方式二
print(lst2, type(lst2)) # [] class list
lst3 list(abc) # 参数传递必须为可迭代对象即可用for循环遍历
print(lst3) # [a, b, c]切片有序
切片与字符串一模一样 lst [x, y, 1, None]print(lst[::-1])
[None, 1, y, x]
# 可以使用切片赋值当传递的参数超过切片长度时会自动依次添加到切片后面的位置相当于insert()列表长度增加当参数长度小于切片长度时相当于替换replace()列表长度减小
lst[0:2]abc可变数据类型
# 使用下标或切片进行赋值都不会重新产生一个列表列表所指向的内存空间不会改变lst[]print(lst,id(lst))
[] 140687159259336lst[0]a # 下标不能溢出replace()
Traceback (most recent call last):File stdin, line 1, in module
IndexError: list assignment index out of rangelst[0:]a # 切片可以溢出,溢出即插入不溢出就替换print(lst,id(lst))
[a] 140687159259336lst[0]bprint(lst,id(lst))
[b] 140687159259336
# 使用lst赋值时会产生新的列表相当于重定向lst[c]print(lst,id(lst))
[c] 140687159250760存放任何数据类型
# 可以存放任何数据类型包括函数、类
lst.append(print) # 这里print不加代表加入print函数加了括号代表返回值
print(lst)常用方法
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))运算 lst [x, y]lst2 [a, b]lst3 lst lst2 # 加法print(lst3, id(lst), id(lst2), id(lst3))
[x, y, a, b] 140687159259336 140687159250760 140687159259400lst3 lst * 2 # 乘法print(lst3)
[x, y, x, y]底层存储地址值的传递 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 140687159259400lst6 lst3[:]print(id(lst3), id(lst6))
140687159259656 140687159260168遍历 for i in lst3: # 遍历每个元素
... print(i)
...
x
y
x
y
zzfor k, v in enumerate(lst3): # 类似go的遍历k为下标(从0开始)v为值(类型为str)
... print(k, v)
...
0 x
1 y
2 x
3 y
4 zz示例
对输入的字符串只保留字母和数字然后再进行判断是否为回文
while 1:str1 input(:)if str1q:breakstr2 for i in str1:if i.isalnum(): # 字符串保留字符数字str2 istr2 str2.lower() # 忽略大小写if str2 str2[::-1]: # 反转字符串进行比较print(是回文)else:print(不是回文请重新输入按q退出)对于一个已知的整数列表给出一个整数判断列表中是否有两个数相加与其相等
# 示例lst [2,4,6,7,3,5,9,12]
# 从键盘输入一个数 10 --》1046 --》输出下标12
lst[3,5,7,11,13,17,2,1]
numint(input(请输入一个整数))
flag11
for k,v in enumerate(lst[:len(lst)-1]):for i in lst[k1:]:if int(v)int(i)num:print(f{num}{v}{i})flag10
if flag11:print(f没有两个数加起来等于{num})元组 tuple
初始化
# 方式一t1 (1) # 一个元素无法识别是元组还是括号,此时为int类型t2 (1,) # 一个元素加个逗号就行t3 (1, 2)print(type(t1), type(t2), type(t3))
class int class tuple class tuple
# 方式二btuple(abc)print(b)
(a, b, c)可以存放任意数据类型 可以切片 与list的主要区别是不可变 不可变数据类型,改变任意地址值都会报错TypeError: ‘tuple’ object does not support item assignment t3[1]1
Traceback (most recent call last):File stdin, line 1, in module
TypeError: tuple object does not support item assignment元组内存放可变数据类型时改变可变数据类型的值是可以的因为元组的地址值并没有改变 t4 (x, abc, [1, 2, 3])t4[2].append(4)print(t4)
(x, abc, [1, 2, 3, 4])运算
# 运算也可以相加会生成新元组
print(t3 t4)与list相互转换
lst list(t4)
print(lst, type(lst))
t5 tuple(lst)
print(t5, type(t5))字典 dict 键值映射的数据结构、无序、可变数据类型 初始化
d1 {name: wenyao, age: 18}
print(d1[name]) # key不存在时会报错
d1[gender] female # key不存在时新增存在时重新赋值
d1.get(xx, 1) # key不存在时不会报错默认返回值为None也可以指定key不存在时的返回值这里指定为 1key 自动去重后面的覆盖前面的 d2 {1: a, 2: b, 2: c}print(d2)
{1: a, 2: c}key必须为可hash对象暂时理解为不可变数据类型字符串、元组都行(但元组里的元素也得是不可变数据)列表不行 value可以是任何值 删除
d1 {1: x, 2: y}
print(d1.pop(1)) # pop()删除指定key返回velue值
print(d1.popitem()) # popitem()默认删除最后一个key返回(key,value)字典的合并 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() print(b in d3, 2 in d3) # 这样判断的是key
True Falseprint(2 in d3.values()) # values()返回values列表类型为dict_values
Trueprint(type(d3.values()))
class dict_values遍历
for i in d3: # 只返回keyprint(i)
for i in d3.items(): # 返回keyvalue类型为元组print(i)
for k, v in d3.items(): # 分别赋值key、valueprint(f{k}-{v})
for i in d3.values(): # 只返回valueprint(i)常见应用格式
d1 {root: {passwd: 123456, balance: 500}, admin: {passwd: 123456admin, balance: 300}}
print(d1[root][passwd]) # 方式一
print(d1.get(root).get(passwd)) # 方式二与列表、元组的转换 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 是一种轻量型的数据交换格式可用于字符串与字典的转换 import requestsresult 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 jsond1 json.loads(str1) # 将字符串转换成字典print(type(d1), d1)
class dict {code: 400, data: None, message: 请先登录}d1[test] abcstr2 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对象————不可变
初始化 s1{1,2,3} # 方式一s2set() # 方式二print(type(s1),type(s2))
class set class sets3{}print(type(s3)) # 使用{}初始化的数据类型是字典
class dict与list的转换
通过set()、list()函数可以相互转换 lst[1,2,3]s3set(lst) # 如果有重复的会去掉print(s3)
{1, 2, 3}lst2list(s3)print(lst2)
[1, 2, 3]添加、删除 # 添加
... 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集合运算
#运算 -差集在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中的容器类型包括列表、元组、字典和集合内容包含了其特点和常用方法帮助大家快速了解容器类型的使用和异同。如有不足之处希望能帮忙指出笔者会及时改正感谢大家观看
