一文拿捏Python基本数据类型“列表、数组和字典”
引言
Python中的 列表(英文叫list) 、 元组(英文叫tuple)和字典（dictionary） 也是
序列特性的，它们也是非常常用的数据类型。
1、列表（List）
01、概述
列表（List）对象 经常被用来 存储 数据对象。我们可以把列表想象为 一连串的储物格，就像下面这样：
其中每个储物格里面都可以存储 任何类型 的对象
注意：是任何类型的对象， 整数、小数、字符串、函数、等等 都可以。 也可以存储另一个列表对象。
Python代码中，我们可以这样定义一个空的列表，赋值给一个变量:
nameList = []
# 方括号用来表示一个列表
如果定义列表的时候，里面就存放了一些数据对象，只需要填写到方括号里面就可以了。每个对象之间用逗号隔开。比如:
a = [1, 2, 3.14, 'hello']
# 这个列表里面就包含了多种类型的对象: 整数、小数 、 字符串。
# 列表里面的每个对象，就称之为列表的一个元素。
列表中还可以包含另一个列表作为元素，如下
a = [1, 2, 3.14, 'hello', [7,8,9] ]
# 最后一个元素就是另外的一个列表对象 [7,8,9]
02、列表的sequence操作
雷彪具有序列化的特性，所以也支持sequence操作。举例如下：
可以用元素索引的方式取出里面的元素; 也可以用切片操作 截取一部分内容生成新的列表。
列表的 索引和切片操作和 字符串是 类似的。
比如上面的列表，其索引如下所示
列表每个元素的索引是从0开始的，支持正数索引，也支持负数索引
a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0] # 就是 1
a[1] # 就是 2
a[4] # 就是 [7,8,9]
a[-1] # 也是 [7,8,9]
a[-4] # 也是 2
a[-1][0] # a[-1] 是[7,8,9], a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
列表的切片也和字符串类似，想象用刀去切取其中的一部分，该在哪里下刀，就使用哪里的索引
a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0:3] # 结果是 [1, 2, 3.14]
a[:3] # 结果也是 [1, 2, 3.14]
a[3:5] # 结果是 ['hello', [7,8,9] ]
a[3:] # 结果也是 ['hello', [7,8,9] ]
a[-1][:2] # 结果是 [7,8] 采用二维数组，即访问列表中的列表
print(a)
# 结果还是 [1, 2, 3.14, 'hello', [7,8,9] ]
# 上面对a的切片操作是产生新的对象，并不会改变a指向的对象
03、修改列表的内容
和我们前面学过的其它数据类型不同，列表对象有个特点，它的内容是可以变化的，比如：
a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)
a[0] = '你好'
print(a)
执行上面的代码，可以发现，最后列表变量 a 的内容变成了:
[‘你好’, 2, 3.14, ‘hello’, [7, 8, 9]]
①列表的元素也可以填写变量，比如:
var = [7, 8, '你好']
a = [1, 2, 3.14, 'hello', var]
print(a)
结果a的值是
[1, 2, 3.14, 'hello', [7, 8, '你好']]
②列表的元素还可以填写表达式，解释器会自动计算结果，放入列表中，比如：
var = 100
a = [1, 2, var*3 + 20, 'hello', [7, 8, '你好']]
print(a)
结果a的值是
[1, 2, 320, 'hello', [7, 8, '你好']]
③如果想部分修改列表中的数据，该如何修改呢？
# 原始数据
list1 = [0, 1, 2, 3, 4, 5]
# 修改方法
list1[1:4] = ['a','b','c']
结果列表的值为
list1 = [0, ‘a’, ‘b’, ‘c’, 4, 5]
这种写法称之为 切片赋值
④列表合并，列表中要添加另外一个列表的内容很简单，用+就可
>>> a = [1,2,3]
>>> a += [4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
2、元组（Tuple）
01、概述
元组（Tuple）也是一种sequence特性的类型， 它和列表非常相似，也可以存放任何类型的数据对象，除了一点： 元组的内容是 不能改变 的
Python代码中，我们可以这样定义一个空的元组，赋值给一个变量
nameList = ()
# 圆括号用来表示一个元组。
如果定义元组的时候，里面就存放了一些数据对象，只需要填写到括号里面就可以了。每个对象之间用逗号隔开。比如:
a = (1, 2, 3.14, 'hello')
# 这个元组里面就包含了多种类型的对象: 整数、小数 、 字符串。
# 元组里面的每个对象，就称之为元组的一个元素。
甚至还可以包含另一个列表或者元组作为元素，如下:
a = (1, 2, 3.14, 'hello', [7,8,9] )
02、元组的sequence操作
元组也是有sequnce特性的。当然也支持序列化操作。
就是支持用元素索引的方式取出里面的元素; 也支持用切片操作 截取一部分内容作子列表。
元组的 索引和切片操作和 列表、字符串是 类似的。比如：
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] # 就是 1
a[1] # 就是 2
a[4] # 就是 [7,8,9]
a[-1] # 也是 [7,8,9]
a[-4] # 也是 2
a[-1][0] # a[-1] 是[7,8,9], a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
元组的切片也和字符串类似，想象用刀去切取其中的一部分，该在哪里下刀，就使用哪里的索引
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0:3] # 结果是 (1, 2, 3.14)
a[:3] # 结果也是 (1, 2, 3.14)
a[3:5] # 结果是 ('hello', [7,8,9])
a[3:] # 结果也是 ('hello', [7,8,9])
a[-1][:2] # 结果是 [7,8] 为什么？
03、元组内容不可变
和列表不同，元组对象的内容是不可以变化的，比如：
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] = '你好'
执行上面的代码，解释器会报如下错误:
Traceback (most recent call last):
File “”, line 1, in
TypeError: ‘tuple’ object does not support item assignment
这个错误是一个类型错误，提示了元组对象不支持项目赋值。
在Python中，元组是一种不可变的数据类型。这意味着一旦创建了一个元组，就不能修改其中的元素。在这个错误中，你试图对一个元组进行项目赋值操作，但是元组是不可变的，因此导致了类型错误。
要解决这个问题，你可以考虑使用列表（list）而不是元组，因为列表是可变的。或者，你可以重新设计你的代码，以不需要修改元组中的元素为前提。
04、多个变量同时赋值
我们可以像下面这样把 列表 或者 元组 中的元素直接赋值给变量
x,y = (1,2) # x 的值为 1， y 的值为 2
print(x,y)
name, age = ['李逵', 33] # name 的值为 '李逵'， age 的值为 33
print(name,age)
注意:这样赋值，变量的个数一定要和 列表/元组 中元素的个数相等。
05、函数返回列表或者元组
函数的返回值可以是一个列表或者 元组对象:
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return [age,gender]
如果有多个数据对象需要在函数里面返回的时候，就可以放到列表中。
当然也可以放到元组中返回，例如：
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return age,gender
# 因为元组的括号是可以省略的
3、字典（Dictionary）
01、概述
字典，是Python开发中非常重要的一种数据类型。字典 提供了一种特别的结构， 就是 存放 键值对 数据。这种结构使得字典，特别像 一张 表
什么是键值对？
一个会员管理系统里面会存储用户信息，系统 经常需要 查询某个会员用户的信息，比如 某个用户的等级、积分等。那么根据什么去查找该用户的信息呢？ 根据 唯一标志 该用户的属性，比如 用户登录名 或者 用户分配的ID号 等。
- 根据 登录名1 就查到 用户1 的信息
- 根据 登录名2 就查到 用户2 的信息
这样就形成了如下 的一种 从 登录名 到 用户信息数据 的映射关系
上图中，登录名1就是键（英文叫Key）， 用户1 就是值（英文叫Value）；每个对应的帐号 和 会员数据 就形成了一个键值对。要存储像这样 一对一 的映射关系的数据结构，就像一张表一样，在Python中就可以使用字典这种数据类型。
02、字典的定义
字典对象定义用花括号 {} , 字典里面的 每个元素之间用 逗号 隔开。
每个元素都是一个键值对，键和值之间用 冒号 隔开。
上面例子中，如果每个帐号的信息比较简单，比如只有等级信息，就定义成如下形式：
members = {
'account1' : 13 ,
'account2' : 12
}
上面的字典对象 键就是帐号，值就是一个数字对象，表示等级的数字。
注意:
- 字典元素的
键必须是 可进行哈希值计算 的对象， 通常是 数字 或者 字符串。- 字典元素的
值可以是任何类型的对象，包括数字、字符串、列表、元组、字典、自定义类型 等等均可。
什么是哈希值计算？
哈希值计算是指将任意长度的数据通过哈希算法转换成固定长度的连续字符序列的过程。哈希值是根据输入数据计算得出的唯一标识，具有以下特点：
- 哈希值是固定长度的：哈希算法将不同长度的输入数据转换为固定长度的输出结果，常见的哈希算法输出的哈希值长度为128位、256位或512位。
- 哈希值是唯一的：对于不同的输入数据，哈希算法应该保证计算得出的哈希值是唯一的，即不同的输入数据不会计算得到相同的哈希值。
- 哈希值是不可逆的：从哈希值无法推导出原始输入数据，即无法通过哈希值还原出原始数据。这是哈希算法的一个重要特性，保证了输入数据的安全性。
- 哈希值的变化范围很大：即使输入数据有微小的变化，哈希值也应该发生较大的变化。这是为了保证数据的完整性，即对于原始数据的任何改动，都会导致哈希值的明显变化。
哈希值计算在密码学、数据完整性校验、数据快速查找等领域有广泛应用。常用的哈希算法有MD5、SHA-1、SHA-256等。
上述例中，用户账号信息，如果复杂一些，包括 等级、点卡数，可以是这样的：
members = {
'account1' : {
'account':'account1', 'level': 13, 'point':3000} ,
'account2' : {
'account':'account2', 'level': 12, 'point':36000}
}
上面的字典对象 键就是帐号，值也是一个字典对象。 这个值字典对象中又 包含了 帐号、等级、积分信息。
字典对象的一个特点就是 ： 根据 键 去查找 值 非常的方便高效，
比如 members['account1'] 就可以得到 键为 ‘account1’ 的 元素的值
members = {
'account1' : 13 ,
'account2' : 12
}
print(members['account1'])
# 输出结果为13
-
字典对象可以存储非常多的元素。理论上 只要内存够大，字典的元素的数量是没有限制的。
-
字典对象 存储元素有特别的优化， 根据 键 查找值的效率非常高，速度非常快，特别适合查找数据这样的操作。
字典对象的键是唯一的，不可能有两个元素具有相同的键。如果我们这样定义一个字典对象：
members = {
'account1' : 13 ,
'account1' : 12
}
print(members)
输出结果为：
{‘account1’: 12}
相同的键，后面的元素会替换前面的元素。
03、字典的增删改查
①像列表对象一样，字典对象的内容是 可以改变 的。具体操作如下：
# 首先定义一个空字典
members = {
}
# 要在字典对象中添加元素非常简单，像这样
members['account1'] = 13
# members的内容就变成了如下：
{
'account1' : 13
}
# 像这样的赋值语句
var[key] = something
# 括号里面的key：
# 如果在字典中不存在，就是添加元素的的操作，
# 如果已经存在，就是重新赋值操作。 因为字典不允许有相同的key
②如果我们要删除一个元素，可以使用字典对象的pop方法。 像这样
members = {
'account1' : 13 ,
'account2' : 12
}
val = members.pop('account1')
print(members)
print(val)
pop方法还会返回参数 key 对应的 value 对象，所以上面的代码执行后，变量val 的值就是 13
而members 的内容则变成了:
members = {
'account2' : 12
}
也可以使用 del 关键字来删除一个元素，比如:
del members['account1']
③判断字典是否存在某个key
有时候，我们要检查字典的key中，是否有我们要找的元素，可以通过 in 这个关键字 ，比如
a in var
# 检查 a 是否在var 中存在，存在返回True，否则返回False
a not in var
# 检查 a 是否不在var 中，存在返回 False，否则返回 True
具体代码如下：
members = {
'account1' : 13 ,
'account2' : 12
}
if 'account1' in members:
print('account1 在字典中存在')
if 'account88' not in members:
print('account88 不在字典中')
④访问字典中所有元素
我们有时需要访问字典的每一个元素，也叫遍历字典。
比如，我们需要打印出下面 会员信息字典 中的 每个会员的等级。怎么办？
通常我们使用字典对象的items方法，像这样：
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
for account,level in members.items():
print (f'account:{
account}, level:{
level}')
items方法，返回的是一个类似列表一样的对象，其中每个元素就是 键值组成的元组
上面的字典，其items方法返回的是类似这样的对象
[('account1', 13), ('account2', 12), ('account3', 15)]
用for 循环， account level 两个变量就依次对应其中的每个元组里面的 两个元素，完成遍历
⑤清空字典
clear 方法可以清空字典对象里面的所有元素：比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members.clear()
print(members)
可能有的朋友就想，我们给字典对象重新赋值不也就等于清空字典吗？：比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members = {
}
print(members)
这两种做法，虽然最后 members 变量指向的对象 都是一个空字典。 但是最大的区别就在于
clear方法， members 变量 指向的还是原来的字典对象。
for 循环， account level 两个变量就依次对应其中的每个元组里面的 两个元素，完成遍历
⑤清空字典
clear 方法可以清空字典对象里面的所有元素：比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members.clear()
print(members)
可能有的朋友就想，我们给字典对象重新赋值不也就等于清空字典吗？：比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members = {
}
print(members)
这两种做法，虽然最后 members 变量指向的对象 都是一个空字典。 但是最大的区别就在于
clear方法， members 变量 指向的还是原来的字典对象。
而 重新赋值的方法， members 变量 指向的 就是一个新的空字典对象。 原来的字典对象呢？ 因为没有被引用，就会被Python解释器在合适的时候 从内存中清除掉。