Python之基础数据类型(二)

---

列表 list

1、是一个有序的项目集合
2、是可变数据类型
3、可以存放任何数据类型

初始化

lst = []	# 方式一
print(type(lst))  # 
lst2 = list()	# 方式二
print(lst2, type(lst2))  # [] 
lst3 = list("abc")  # 参数传递必须为可迭代对象，即可用for循环遍历
print(lst3)  # ['a', 'b', 'c']
1
2
3
4
5
6

切片（有序）

切片与字符串一模一样

>>> lst = ['x', "y", 1, None]
>>> print(lst[::-1])
[None, 1, 'y', 'x']
# 可以使用切片赋值，当传递的参数超过切片长度时，会自动依次添加到切片后面的位置，相当于insert()，列表长度增加；当参数长度小于切片长度时相当于替换replace()，列表长度减小
lst[0:2]="abc"
1
2
3
4
5

可变数据类型

# 使用下标或切片进行赋值都不会重新产生一个列表，列表所指向的内存空间不会改变
>>> lst=[]
>>> print(lst,id(lst))
[] 140687159259336
>>> lst[0]='a'	# 下标不能溢出，replace()
Traceback (most recent call last):
  File "", 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

存放任何数据类型

# 可以存放任何数据类型，包括函数、类
lst.append(print)  # 这里print不加（）代表加入print函数，加了括号代表返回值
print(lst)
1
2
3

常用方法

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运算

>>> 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']
1
2
3
4
5
6
7
8

底层存储（地址值的传递）

>>> 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

遍历

>>> 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

示例

对输入的字符串只保留字母和数字，然后再进行判断是否为回文

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退出")
1
2
3
4
5
6
7
8
9
10
11
12
13

对于一个已知的整数列表，给出一个整数，判断列表中是否有两个数相加与其相等

# 示例：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}")
1
2
3
4
5
6
7
8
9
10
11
12

元组 tuple

初始化

# 方式一
>>> 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')
1
2
3
4
5
6
7
8
9
10

可以存放任意数据类型

可以切片

与list的主要区别是不可变

不可变数据类型,改变任意地址值都会报错：TypeError: ‘tuple’ object does not support item assignment

>>> t3[1]=1
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
1
2
3
4

元组内存放可变数据类型时，改变可变数据类型的值是可以的，因为元组的地址值并没有改变

>>> t4 = ("x", "abc", [1, 2, 3])
>>> t4[2].append(4)
>>> print(t4)
('x', 'abc', [1, 2, 3, 4])
1
2
3
4

运算

# 运算也可以，相加会生成新元组
print(t3 + t4)
1
2

与list相互转换

lst = list(t4)
print(lst, type(lst))
t5 = tuple(lst)
print(t5, type(t5))
1
2
3
4

字典 dict

键值映射的数据结构、无序、可变数据类型

初始化

d1 = {"name": "wenyao", "age": 18}
print(d1["name"])  		# key不存在时会报错
d1["gender"] = "female"  # key不存在时新增，存在时重新赋值
d1.get("xx", 1)  		# key不存在时不会报错，默认返回值为None，也可以指定key不存在时的返回值，这里指定为 1
1
2
3
4

key 自动去重，后面的覆盖前面的

>>> d2 = {1: "a", 2: "b", 2: "c"}
>>> print(d2)
{1: 'a', 2: 'c'}
1
2
3

key必须为可hash对象，暂时理解为不可变数据类型，字符串、元组都行(但元组里的元素也得是不可变数据)，列表不行

value可以是任何值

删除

d1 = {1: "x", 2: "y"}
print(d1.pop(1))  	# pop()删除指定key，返回velue值
print(d1.popitem())  # popitem()，默认删除最后一个key，返回(key,value)
1
2
3

字典的合并

>>> 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}
1
2
3
4
5
6
7
8
9
10

in、not in、values()

>>> 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'>
1
2
3
4
5
6

遍历

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)
1
2
3
4
5
6
7
8

常见应用格式

d1 = {"root": {"passwd": "123456", "balance": 500}, "admin": {"passwd": "123456admin", "balance": 300}}
print(d1["root"]["passwd"])		# 方式一
print(d1.get("root").get("passwd"))		# 方式二
1
2
3

与列表、元组的转换

>>> 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)]
1
2
3
4
5
6
7
8

json 格式的转换

json 是一种轻量型的数据交换格式，可用于字符串与字典的转换

>>> 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"}
1
2
3
4
5
6
7
8
9
10
11
12
13

字典底层原理–空闲哈希表

参考链接：为什么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}		# 方式一
>>> s2=set()		# 方式二
>>> print(type(s1),type(s2))
<class 'set'> <class 'set'>
>>> s3={}
>>> print(type(s3))		# 使用{}初始化的数据类型是字典
<class 'dict'>
1
2
3
4
5
6
7

与list的转换

通过set()、list()函数可以相互转换

>>> lst=[1,2,3]
>>> s3=set(lst)		# 如果有重复的会去掉
>>> print(s3)
{1, 2, 3}
>>> lst2=list(s3)
>>> print(lst2)
[1, 2, 3]
1
2
3
4
5
6
7

添加、删除

>>> # 添加
... 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 "", line 1, in <module>
KeyError: 4
1
2
3
4
5
6
7
8
9
10
11
12

集合运算

#运算 -：差集，在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))#   ^
1
2
3
4
5
6
7

小结

本节文章主要讲解了python中的容器类型，包括列表、元组、字典和集合，内容包含了其特点和常用方法，帮助大家快速了解容器类型的使用和异同。如有不足之处，希望能帮忙指出，笔者会及时改正，感谢大家观看！