Python基础篇四——列表，元组和字典

01学习目标

1，了解什么是列表
2，熟练掌握列表的一些常见操作
3，熟练掌握元组的一些常见操作
4，熟练掌握字典的一些常见操作

02重点难点

重点：
1，列表的增删改查
2，列表嵌套
3，元组的相关操作
4，字典的常用操作
难点：
1，列表的增删改查
2，元组的相关操作
3，字典的常用操作

03学习任务

一，列表

1，列表概述

（1）创建列表：使用中括号将所有准备放入列表中的元素给包裹起来，不同元素之间使用逗号分隔。
例如：

>>>[1, 2, 3, 4, 5]	#此时创建的这个列表是匿名的，因为没有变量名
[1, 2, 3, 4, 5]

（2）特点：兼收并蓄是列表的一大特色，也就是说，列表可以容纳多种数据类型。
例如：

A = ['ikun', 520, 111, ['like', 2]]

（3）列表的索引：列表的索引是从0开始的，我们可以通过下标索引的方式来访问列表中的值。
例如：

>>>A = ['猪猪', '猫咪', '真狗']
>>>print(A[0])
猪猪
>>>print(A[1])
猫咪

补充：
当一个列表很长很长时，访问最后一个元素：

>>>A = ['猪猪', '猫咪', '真狗']
>>>length = len(A)
>>>A[-1]
真狗

二，列表的循环遍历

1，列表循环遍历

(1)使用for循环遍历列表：

>>>namelist = ['猪猪', '猫咪', '真狗']
>>>for name in namelist:
>>>		print(name)
猪猪
猫咪
真狗

（2）使用while循环遍历：

>>>namelist = ['xiaowang', 'xiaozhang', 'xiaohua']
>>>length = len(namelist)
>>>i = 0
>>>while i < lenth:
>>>		print(namelist[i])
>>>		i += 1
xiaowang
xiaozhang
xiaohua

三，列表的常用操作

1，增：在列表中增加元素

(1) append()函数：向列表中添加一个元素（在列表的末尾添加一个指定的元素，且每次只能添加一个元素）
举个栗子~

>>>heros = ["ikun1", "ikun2"]
>>>heros.appends("ikun3")
["ikun1", "ikun2", "ikun3"]

(2) extend()函数：可直接添加一个可迭代对象。（该函数的参数必须是一个可迭代对象，新添加的内容是追加到原列表最后一个元素的后面）
举个栗子~

>>>heros = ["ikun1", "ikun2", "ikun3"]
>>>heros.extend("ikun4")
["ikun1", "ikun2", "ikun3", "ikun4"]

(3) insert()函数：可在列表的任意位置来添加元素。（该函数有两个参数，第一个参数是指定待插入的位置，第二个参数是指定待插入的元素）
举个栗子~

>>>s = [1, 3, 4, 5]
>>>s.insert(1, 2)	#此处的1是下标索引值，在下标索引值为1的位置插入元素2。
[1, 2, 3, 4, 5]

(4) 使用切片向列表中添加==
举个栗子~

>>>s = [1, 3, 4, 5]
>>>s[len(s):] = [6]		#等价于s.append(6)
[1, 3, 4, 5, 6]
>>>s[len(s):] = [7, 8]	#等价于s.extend([6, 7, 8])
[1, 3, 4, 5, 6, 7, 8]

2，删：在列表中删除元素

(1) remove()函数：将一个指定的元素删除。

>>>namelist = ['猪猪', '猫咪', '真狗', '哈士奇'，'小明']
>>>namelist.remove('小明')
['猪猪', '猫咪', '真狗', '哈士奇']
注意：
1，如果列表中存在多个匹配的元素，那么只会删除第一个。（删除的是下标索引最小的匹配的那个元素）
2，如果指定的元素不存在，程序便会报错。

(2) pop()函数：删除某个位置上的元素。（该函数的参数就是元素的下标索引值。）

>>>namelist = ['猪猪', '猫咪', '真狗', '哈士奇'，'小明']
>>>namelist.pop(1)
>>>namelist
['猪猪', '真狗', '哈士奇'，'小明']

(3) clean函数：删除所有元素，清空列表。

>>>namelist = ['猪猪', '猫咪', '真狗', '哈士奇'，'小明']
>>>namelist.clean()
>>>namelist		#此时namelist()已经变为一个空列表
[]

3，改：在列表中修改元素

列表与字符串最大的区别是：列表是可变的，而字符串是不可变的！
（1）替换列表中的元素跟访问列表类似，都是使用下标索引的方式，然后用赋值运算符就可以将新的值给替换进去了。
比如：

>>>heros = ["A", "B", "C", "D", "E"]
>>>heros[4] = "G"		#把下标索引值是4的元素修改为“G”
>>>heros
["A", "B", "C", "D", "G"]

(2) 利用切片可将多个连续的元素一步到位替换掉。
举个栗子~

>>>heros = ["A", "B", "C", "D", "E"]
>>>heros[2:] = ["W", "L"]		#第2个元素也要替换掉
>>>heros
["A", "B", "W", "L"]

4，查：在列表中查找元素

在列表中查找元素的方法包括：
in（存在）：如果存在那么结果为True,否则为Flase
not in（不存在）：如果不存在那么结果为True,否则为Flase

(1) count()函数：查找列表里的某个元素有多少个
举个栗子~

>>>nums = [5, 5, 6, 7, 2, 1, 8, 5]
>>>nums.count(5)		#查找nums列表中有几个5
3						#有三个

(2) index()函数：查找某个元素的索引值。注意：index(x, start, end)，后面的两个参数start和end是可选参数，它们分别指定的是查找的开始和结束位置（查找的依旧是下标索引值）

>>>nums = [5, 5, 6, 7, 2, 1, 8, 5]
>>>nums.index("6")
2

5，列表的排序操作

(1) sort()函数：对列表中的元素从小到大排序。

>>>nums = [6, 5, 8, 0, 1, 4, 2, 7, 3]
>>>nums.sort()
>>>nums
[0, 1, 2, 3, 4, 5, 6, 7, 8]

(2) reverse函数()：对列表中的元素从大到小排序。(原地翻转列表中的元素，也就是第一个与最后一个互换，第二个与倒数第二个互换，以此类推)

>>>nums = [6, 5, 8, 0, 1, 4, 2, 7, 3]
>>>nums.reverse()
>>>nums
[8, 7, 6, 5, 4, 3, 2, 1, 0]

四，列表的嵌套

1，列表嵌套

列表嵌套指的是在一个列表里嵌入一个新的列表。

>>>A = [[a, b, c], [d, e, f], [g, h, i]]	#创建了一个二维列表
>>>A = [[a, b, c]
		[d, e, f]
		[g, h, i]]		#这两种方法是等价的
>>>A
[[a, b, c], [d, e, f], [g, h, i]]

五，元组

1，什么是元组？

元组是一个序列，元祖既能向列表那样同时容纳多种类型的对象，也拥有和字符串一样不可变的特性。列表与元组的不同之处在于：元组使用小括号（），而列表使用中括号[ ]。
例如介样子·：

>>>tup1 = ('a', 'b', 2023, 2022)
('a', 'b', 2023, 2022)

>>>tup2 = (0, 9 , 8, 7, 6)
(0, 9 , 8, 7, 6)

>>>tup3 = "a", "b", "c", "d"
("a", "b", "c", "d")		#元组可以不用带圆括号，只需要用逗号隔开即可

2，元组的相关操作

(1) 访问元组：可以使用下标索引的来访问元组中的值

>>>tup1 = ('a', 'b', 2023, 2022)
>>>tup1[0]
a

>>>tup1[1]
b

>>>tup1[2]
2023

>>>tup1[3]
2022

>>>tup1[-4]
a

>>>tup1[-3]
b

(2) 元组不支持修改，只支持查找。

>>>tup1 = (12, 34, 56, 78)
>>>tup1[0] = 100		#在Python中这种修改元组中的元素的行为是违法的！！！

（3）元组也支持切片操作。

>>>tup1 = (12, 34, 56, 78)
>>>tup1[:3]
(12, 34, 56)

>>>tup1[2:]
(56, 78)

>>>tup1[:]
(12, 34, 56, 78)

>>>tup1[::2]
(12, 56)

>>>tup1[::-1]
(78, 56, 34, 12)

(4) 元组的查找：count()方法和index()方法

>>>nums = (3, 1, 9, 6, 8, 3, 5, 3)
>>>nums.count(3)		#查找nums这个列表中值为3的元素有几个
3						#有3个
>>>nums = ("加菲猫"， "家猫", "猫")
>>>nums.index("猫")
2

（5）元组的遍历
举个栗子

>>>a_turple = (1, 2, 3, 4, 5)
>>>for num in a_turple:
>>>		print(num, end = "")
12345

(6) 元组也可以进行拼接和复制操作
举个栗子~

>>>q = (a, b, c)
>>>w = (e, f, g)
>>>q + w 	#加法就是拼接
(a, b, c, d, e, f)
>>>q * 3	#乘法就是复制
(a, b, c, a, b, c, a, b, c)

(7) 元组的内置函数

六，字典

“字典这个数据结构活跃在所有Python程序的背后，即便你的源码里并没有直接用到它。”——A.M.Kuchling

1，字典的介绍

（1）字典是一种存储数据的容器，字典和列表一样，都可以存储多个数据。字典也是Python中唯一实现映射关系的内置类型。

class = {'name':'班主任', 'set':'f', 'address':'重庆'}	#这里是三对映射关系，冒号左边称之为字典的“键”，冒号右边称之为字典的“值”

一个关键：与序列不同，序列是通过位置的偏移来存储数据，而字典则是通过键来实现写入和读取。
（2）创建一个字典总共有六个方法：

方法一：直接使用大括号和冒号的组合，将映射关系套牢
>>>a = {'wu':'吴', 'wang':'王', 'li':'李'}

方法二：使用dict()函数生成字典。它的每一个参数就是一个对应的键值对，键与值之间直接使用等号挂钩
>>>b = dict{ikun='坤坤'， AIYANIGANMA='哎呀你干嘛', time='两年半'}	#这种写法要求不可以往键上面加引号

方法三：使用列表作为参数，而列表中的每个元素是使用元组包裹起来的键值对
>>>c = dict{[("苹果","Apple"), ("香蕉","banana"), ("栗子","Chestnut")]}

方法四：将第一种方法作为参数传递给dict()函数.
>>>d = dict({'wu':'吴', 'wang':'王', 'li':'李'})

方法五：将第一种方法和第二种方法混搭
>>>e = dict({'wu':'吴', 'wang':'王', 'li':'李'},ikun='坤坤')

方法六：把zip()函数作为参数传递给dict()函数。
（	zip()函数：创建一个聚合多个可迭代对象的迭代器）
>>>f = dict(zip(["ikun", "AIYANIGANMA", "time"],["坤坤", "哎呀你干嘛~~~", "两年半"]))

2，字典的常用操作

（1）根据键访问值

>>>info = {'name':'班长', 'id':'100', 'set':'f', 'address':'北京'}
>>>		print(info['name'])
班长
>>>		print(info['address']) 
北京

注意：如果使用的是不存在的键，那么程序就会报错！

如果我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，并且还可以修改默认值。

>>>info = {'name':'班长', 'id':'100', 'set':'f', 'address':'北京'}
>>>age = into.get('age')
>>>		print(age)			#'age'这个键不存在，所以age为None
>>>		print(type(age))
>>>age = info.get('age', 18)#若info不存在'age',返回默认值18
>>>		print(age)

(2)修改字典中的元素

>>>info = {'name':'班长', 'id':'100', 'set':'f', 'address':'北京'}
>>>newid = input('请输入新的学号')
>>>info['id']
>>>		print('修改后的id为：%d'%info['id'])

updata([other])函数：同时修改多个键值对。（可以同时给其传入多个键值对，也可以直接传入一个字典或者一个包含键值对的一个可迭代对象 ）
举个栗子~

>>>pets = {"汤姆":"猫", "杰瑞":"鼠", "主人":"男"}
>>>pets.updata(主人 = "女")
>>>pets
{"汤姆":"猫", "杰瑞":"鼠", "主人":"女"}

(3) 添加字典元素：
formkeys(iterable,[values])函数：使用iterable参数指定的可迭代对象来创建一个新的字典，并将所有的值初始化为values参数指定的值。

>>>d = dict.formkeys{"IKUN", 24}	#d现在是存放四组映射关系的一个字典（ 此方法适用于从无到有创建一个所有键的值都相同的字典，对于快速初始化一个字典非常有用）
>>>d
{'I':24, 'K':24, 'U':24, 'N':24}

>>>d['K'] = 520						#修改某个键的值
>>>d
{'I':24, 'K':520, 'U':24, 'N':24}

如果在字典中找不到对应的键，同样的操作会变为增加一个新的键值对
>>>d['A'] = 1314
>>>d
{'I':24, 'K':520, 'U':24, 'N':24, 'A':1314}

特别注意！！
序列与字典另外一个很重大的区别是：在序列中的元素是可以重复的，而字典中的键值对，一个键就对应一个值，并不会存在重复的键！

(4) 删除字典中的元素
pop(key[,default])函数
popitem()函数：删除最后一个加入字典的键值对
举个栗子~

>>>d = {1:"one", 2:"two", 3:'three', 4:"four"}
>>>d.pop(2)
two
>>>d
{1:"one", 2:"two", 3:'three', 4:"four"}

>>>d.popitem()
(4, 'four')
>>>d
{1:"one", 3:'three'}

del()函数：既可以删除整个字典（如果删除整个字典，那么字典就不就存在了，无法再根据键去访问字典的值），也可以删除一个指定的字典元素。
clear()函数:清空字典中的内容。（字典还存在，只是没有元素了）
举个栗子~

>>>a = {1:"one", 2:"two", 3:'three', 4:"four"}
>>>del a['2']	#指定要删除的键
>>>a
{1:"one", 3:'three', 4:"four"}

>>>del a	#加上字典的名字就可以删除整个字典
>>>a
......		#报错

>>>a.clear()
>>>a
{}			#此时a变量就变成了一个空字典

(5) 计算字典中键值对的个数
举个栗子~

>>>t = {'name':'Zara', 'Age':'7'}
>>>		print("Length : %d" % len(dict))

(6) 获取字典中键的列表
keys()方法：返回在字典中的所有可能的键的列表
举个栗子~

>>>dict = {'name':'Zara', 'Age':'7'}
>>>		print(dict.keys())

(7) 获取字典中值的列表
values()方法：返回在字典中的所有可能的值的列表
举个栗子~

>>>dict = {'name':'Zara', 'Age':'7'}
>>>		print(dict.values())

(8) 获取字典中键值对的列表
items()方法：返回在字典中的所有可能的键值对的列表
举个栗子~

>>>dict = {'name':'Zara', 'Age':'7'}
>>>		print("value : %s" % dict.items())

3，字典的遍历

(1) 遍历字典的键key

>>>dict = {'name':'Zara', 'Age':'7'}
>>>for key in dict.keys():
>>>		print(key)

(2) 遍历字典的值value

>>>dict = {'name':'Zara', 'Age':'7'}
>>>for value in dict.value():
>>>		print(value)

(3) 遍历字典的元素

>>>dict = {'name':'Zara', 'Age':'7'}
>>>for item in dict.items():
>>>		print(item)

(4) 遍历字典的键值对

>>>dict = {'name':'Zara', 'Age':'7'}
>>>for key,value in dict.items():
>>>		print("key = %s, value = %s" % (key, value))

04本文小结

本章主要为大家介绍了列表，元组和字典的相关操作和用法，希望大家能够通过本章的学习对这三种数据类型有个更深入的了解的思考。同时也欢迎大家在评论区和私信指出问题和指导意见，蟹蟹大家的支持~