python中列表，元组和字典

合集 - Datawhale(4)

1.python变量和简单类型2023-11-25

2.python中列表，元组和字典2023-11-26

3.流程控制2023-11-294.Debug(Python)2023-12-07

收起

序列简介

python的序列

python 的常见序列类型包括字符串，列表和元组等

接下来主要介绍列表和元组，这两种类型看起来非常相似，最主要的区别在于：

元组是不可变的，元组一旦构建出来，程序就不能修改元组所包含的成员

列表是可变的，程序可以修改列表所包含的元素

创建列表和元组

• 创建列表使用方括号

  [ele1,ele2,ele3,...]
  

• 创建元组使用圆括号

  (ele1,ele2,ele3,...)
  

下面代码示范了在程序中定义列表和元组

my_list = ['crazyit',20,'python']
print(my_list)
my_tuple = ('crazyit',20,'python')
print(my_tuple)

列表和元组的通用用法

通过索引使用元素

列表和元组都可通过索引来访问元素，且都从0 开始

列表的元素相当于一个变量，程序既可以使用它的值，也可以对元素赋值

元组的元素则相当于一个常量，程序只能使用它的值，不能对它重新赋值

如下代码示范了使用列表和元组的元素

a_tuple = ('crazyit', 10, 7.8, 'fidj', -18)
print(a_tuple)
# 访问第一个元素
print(a_tuple[0])
# 访问第二个元素 
print(a_tuple[1])
# 访问倒数第一个元素
print(a_tuple[-1])
# 访问倒数第二个元素
print(a_tuple[-2])

子序列

与字符串操作类似的是，列表和元组同样也可使用索引获取中间一段，这种用法被称为slice(分片或切片)

slice 的完整格式语法如下

[start:end:step]

start, end 两个索引值都可以使用整数或负数，其中负数表示从倒数开始

下面代码示范了使用start, end 获取元组中间一段的用法

a_tuple = ('crabbhjj', 20, 8.9, 'huhih', -18)
# 访问从第二个到第四个（不包含）的所有元素
print(a_tuple[1:3])
# 访问从倒数第三个到倒数第一个（不包含）的所有元素
print(a_tuple[-3:-1])
# 访问从倒数第一个到倒数第三个（不包含）的所有元素
# print(a_tuple[-1:-3])不可以这样写

加法

列表和元组支持加法运算，加法的和就是两个列表或元组所包含的元素的总和

列表只能和列表相加；元组只能和元组相加

元组不能直接和列表相加

如下代码示范了元组和列表的加法运算

a_tuple = ('uyuuyuyu', 10, -18)
b_tuple = ('hju', 1292, 2.34, 'huio')
# 计算元组相加
sum_tuple = a_tuple + b_tuple
print(sum_tuple)
print(a_tuple)
print(b_tuple)
# 两个元组相加
print(a_tuple + (-29, 5.6))
# 下面代码报错，元组与列表不能直接相加
# print(a_tuple + [-29, 5.6])
a_list = [20, 78, -3, 100]
b_list = ['a', 'd', 'c']
# 计算列表相加
sum_list = a_list + b_list
print(sum_list)
print(a_list + ['hhuihi', 20])

注意：当元组中只有一个元素时，要加上 ','

例如元组中只有元素 a , 要写成('a',)

乘法

列表和元组可以和整数执行乘法运算

如下代码示范了列表和元组的乘法

a_tuple = ('hjhji', 10, 29)
# 执行乘法
mul_tuple = a_tuple * 3
print(mul_tuple)
a_list = [10, 'python', 2]
mul_list = 3 * a_list
print(mul_list)

可以对列表，元组同时进行加法，乘法运算

例如：把用户输入的日期翻译成英文表示形式可以通过以下代码实现

order_endings = ('st', 'nd', 'rd')\
+ ('th',) * 17 + ('st', 'nd', 'rd')\
+ ('th',) * 7 + ('st',)
day = input("请输入日期（1 - 31）：")
day_int = int(day)
print(day + order_endings[day_int - 1])

in 运算符

in 运算符用于判断列表或元素是否包含某个元素，例如如下代码

a_tuple = ('jijijjn', 29, -1.2)
print(29 in a_tuple) # True
print(1.2 in a_tuple)# False
print('s' not in a_tuple)# True

长度，最大值和最小值

python 提供了内置的 len() , max(), min() 全局函数来获取元组或列表的长度，最大值和最小值

由于max(), min()要对元组，列表中的元素比较大小，因此程序要求传给max(), min() 函数的元组，列表的元素必须是相同类型且可以比较大小

例如如下代码

# 元素都是数值的元组
a_tuple = (20, 19, -2, 15.2, 10)
# 计算最大值
print(max(a_tuple))
# 计算最小值
print(min(a_tuple))
# 计算长度
print(len(a_tuple))
# 元素都是字符串的列表
b_list = ['qwer', 'rtyu', 'uiop', 'python']
# 计算最大值
print(max(b_list))
# 计算最小值
print(min(b_list))
# 计算长度
print(len(b_list))

序列封包和序列解包

python还提供了序列封包和序列解包的功能

• 程序把多个值赋给一个变量时，python会自动将多个值封装成元组。这种功能被称为序列封包

• 程序允许将序列（元组或列表）直接赋值给多个变量，此时序列的各元素会被依次赋值

如下代码示范了序列封包和序列解包功能

#序列封包：将10， 20， 30封装成元组赋值给vals
vals = 10, 20, 30
print(vals)
print(type(vals))
# 序列解包
a_tuple = tuple(range(1, 10, 2))
a, b, c, d, e = a_tuple
print(a, b, c, d, e)
a_list = ['gghghi', 'python']
a_str, b_str = a_list
print(a_str, b_str)

如果在赋值中同时运用了序列封包和序列解包机制，就可以让赋值运算符支持同时将多个值赋值给多个变量

例如如下代码

x, y, z =10, 20, 30
print(x, y, z)# 10, 20, 30

上面代码实际上相当于如下执行过程

# 先执行序列封包
xyz = 10, 20, 30
# 再执行序列解包
x, y, z = xyz

使用这种语法也可以实现交换变量的值，例如如下代码

x, y, z = 10, 20, 30
x, y, z = y, z, x
print(x, y, z)

在序列解包时也可以只解出部分变量，剩下的依然使用列表变量保存

为了使用这种解包方式，python允许在左边被赋值的变量之前添加“ * ”， 那么该变量就代表一个列表，可以保存多个集合元素

例如如下代码

first, second, *rest = range(10)
print(first)
print(second)
print(rest)
*begin, last = range(10)
print(begin)
print(last)
first, *middle, last = range(10)
print(first)
print(middle)
print(last)

使用列表

创建列表

除前面介绍的使用方括号语法创建列表之外，python还提供了一个内置的list()函数来创建列表

list()函数可用于将元组，区间(range)等对象转化为列表

例如如下代码

a_tuple = ('qwerty', 'ghjkl')
# 将元组转化成列表
a_list = list(a_tuple)
print(a_list)
# 使用range()函数创建区间(range)对象
a_range = range(1, 5)
# 将区间转化成列表
b_list = list(a_range)
print(b_list)
c_list = list(range(4, 20, 3))
print(c_list)

增加列表元素

为列表增加元素可调用列表的append()方法，该方法会把传入的参数追加到列表的最后面

append()方法即可以接收单个值，也可以接收元组，列表等，

但该方法只是把元组，列表当成单个元素，这样就会形成在列表中嵌套列表，元组的情形

如下

a_list = ['asdfgh', 'python']
a_list.append('like')
print(a_list)
# 追加元组
a_tuple = ('asdf', 'dfghjkl')
a_list.append(a_tuple)
print(a_list)
# 追加列表
b_list = ['sdfghjk', 'wet']
a_list.append(b_list)
print(a_list)

如果希望不将被追加的列表当成一个整体，而只是追加列表中的元素，

可以使用列表的extend()方法

如下代码

a_list = list(range(1,5))
print(a_list)
# a_list.extend(10)不能用来直接追加单个元素
a_list.extend((-2, -29, -99))
print(a_list)
a_list.extend([5.6, 3.3, 55.99])
print(a_list)

删除列表元素

• 用 del 语句

  del 语句既可以删除列表中的单个元素，也可以删除变量

  a_list = [10, 20, 30, 40, 'python', 'bilibili']
  print(a_list)
  del a_list[1]
  print(a_list)
  del a_list[1:3]
  print(a_list)
  

  name = 'python'
  print(name)
  del name
  print(name)
  

• 用remove()

  该方法不是根据索引来删除元素，而是根据元素本身来执行删除操作

• clear()清空列表所有元素

  a_list = list(range(1,5))
  print(a_list)
  a_list.clear()
  

修改列表元素

列表的元素相当于变量，因此程序可以对列表的元素赋值

如下代码

a_list = [1, 3, 4, 6, 'python', 'bilibili', 23]
print(a_list)
# 对第三个元素赋值
a_list[2] = 'like'
print(a_list)
# 对倒数第二个元素赋值
a_list[-2] = 67890
print(a_list)

程序也可通过slice语法对列表其中一部分赋值

这个操作不要求新赋值的元素个数与原来的元素个数相等

这就意味着通过这种方式即可为列表增加元素，也可为列表删除元素

b_list = list(range(1, 5))
print(b_list)
#  将第2个到第4个元素赋值为新列表的元素
b_list [1:3] = ['a', 'b']
print(b_list)

对列表中空的slice赋值，就变成为列表插入元素

b_list = list(range(1, 5))
print(b_list)
b_list[2:2] = ['x', 'y']
print(b_list)

插入还可以使用insert()

fruits = ['apple', 'banana', 'cherry']
# 在第1位插入
fruits.insert(1,'orange')
print(fruits)

将列表其中一段赋值为空列表，就变成从列表中删除元素

c_list = list(range(1, 5))
print(c_list)
c_list[2:5] = []
print(c_list)

如果使用字符串赋值，python会自动把字符串当成序列处理，

其中每一个字符都是一个元素

在使用slice语法赋值时若指定step参数，则要求所赋值的列表元素与所替换的列表元素个数相等

列表的其他常用方法

在交互解释器中输入 dir(list) 即可看到列表包含的所有内容

以下为部分未介绍的 ：

• count() : 用于统计列表中某个元素出现的次数
• index() : 用于判断某个元素在列表中出现的位置
• pop() : 用于将列表当成"栈"使用，实现元素出栈功能
• reverse() : 用于将列表中的元素反向存放
• sort() : 用于对列表元素排序

使用字典

字典入门

为了保存具有映射关系的数据，python提供了字典，

字典相当于保存了两组数据，其中一组数据是关键数据，被称为 Key

另一组数据可通过 Key 访问，被称为 value

字典中 Key 不允许重复

创建字典

程序既可以使用花括号语法来创建字典

或使用 dict() 函数来创建字典

实际上，dict 是一种类型，即python中的字典类型

scores = {'语文': 89, '数学': 92, '英语': 77}

empty_dict = {}

dic2 = {(10, 29): 'good', 30: 'bad'}

元组可以作为dict 的key,但列表不能

在使用dict()函数创建字典时，可以传入多个列表或元组参数作为key-value对

这些列表或元组都只能包含两个元素

vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
dict3 = {vegetables}
print(dict3)

通过为dict指定关键字参数创建字典，此时字典的key不允许使用表达式

dict4 = dict(spinach = 1.39, cabbage = 2.78)
print(dict4)

字典的基本用法

• 通过key 访问value
• 通过key 添加key-value对
• 通过key 删除key-value对
• 通过key 修改key-value对
• 通过key判断指定key-value对是否存在

通过key访问value使用的也是方括号语法

如下代码

scores = {'语文': 89}
# 通过key访问value
print(scores['语文'])

添加，为不存在的key赋值即可

scores = {'语文': 89}
# 通过key访问value
print(scores['语文'])
# 对不存在的key 赋值
scores['数学'] = 99
scores['英语'] = 98
print(scores)

删除，使用del语句

scores = {'语文': 89}
# 通过key访问value
print(scores['语文'])
# 对不存在的key 赋值
scores['数学'] = 99
scores['英语'] = 98
print(scores)
# 删除key-value对
del scores['语文']
del scores['数学']
print(scores)

对dict存在的key-value对赋值，新的value会覆盖，即可改变dict中的key-value对

cars = {'BMW': 8.6, 'HkUT': 8.3, 'YDGI': 7.9}
# 对存在的key-value对赋值
cars['BWM'] = 4.3
cars['HKUT'] = 4.1
print(cars)

判断字典是否包含指定的key,可使用in 或 not in运算符

字典的常用方法

• clear() : 清空字典中所有的key-value对

• get() : 就是根据key 来获取value,它相当于方括号语法的加强版

  当方括号语法访问并不存在的key时，字典会引发KeyError错误

  但是使用get()方法会简单的返回None,不会导致错误

• update() :

  cars = {'BMW': 8.6, 'HkUT': 8.3, 'YDGI': 7.9}
  cars.update({'BMW': 4.5, 'GyRSW': 9.7})
  print(cars)
  

• items(), keys(), values() 可通过list()把他们==它们转换成列表

• pop() : 获取指定key对应的value,并删除该key-value对