列表与字典

列表

1. 定义

数据类型 list 是 Python 内置的一种高级数据类型；

list 是一种有序的集合，基于链表实现，在 Python 中应用很广泛；

2. 列表的创建

2.1 通过方括号创建

names = ['james', 'michael', 'emma', 'emily']
print('names的数据类型: ', type(names))
print(names)

# 输出:
names的数据类型:  <class 'list'>
['james', 'michael', 'emma', 'emily']

2.2 通过全局函数 list() 创建

lst = list([1, 2, 3, 4, 5])
lst1 = list("Python")
print(lst)
print(lst1)

# 输出:
[1, 2, 3, 4, 5]
['P', 'y', 't', 'h', 'o', 'n']

2.3 创建空列表

lst2 = []
lst3 = list()
print(lst2, len(lst2))
print(lst3, len(lst3))

# 输出:
[] 0
[] 0

2.4 列表推导式

示例一：

# 普通方法构建 1 - 10 的平方
lst = []
for i in range(1, 11):
    lst.append(i ** 2)
print(lst)

# 列表推导式
lst1 = [i ** 2 for i in range(1, 11)]
print(lst1)

# 输出:
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

示例二：

# 100 以内能被 7 整除的数字
lst2 = [i for i in range(101) if i % 7 == 0]
print(lst2)

# 输出:
[0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]

示例三：

# 获取长度大于 5 的元素大写后的列表
fruits = ['apple', 'orange', 'pear', 'banana', 'strawberry']
new_fruits = [fruit.upper() for fruit in fruits if len(fruit) > 5]
print(new_fruits)

# 输出:
['ORANGE', 'BANANA', 'STRAWBERRY']

3. 列表的增删改查

3.1 增

方法	内置方法（列表）	作用	示例	结果
列表拼接	否	将两个列表拼接在一起，不改变原先的两个列表	[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]
append（）	是	在列表后面添加一个元素，注意，append 方法返回值为 None	[1, 2].append([“A”, “B”])	[1, 2, [‘A’, ‘B’]]
insert()	是	在列表指定索引处插入元素，注意，该方法返回值为 None	[‘Amy’, ‘Matlab’].insert(0, “C#”)	[‘C#’, ‘Amy’, ‘Matlab’]
extend()	是	在列表后面添加另一个列表的元素，即列表合并，返回值为 None	[1, 2, 3].extend([4, 5, 6]）	[1, 2, 3, 4, 5, 6]

3.2 删

方法	内置方法（列表）	作用	示例	结果
pop()	是	默认删除列表最后一个，也可以删除指定索引，返回值为删除的元素	被删元素 = lst.pop(1)
remove(）	是	按照元素内容删，参数为要删除的元素内容，返回值为 None	lst.remove(“A”)
clear()	是	清空列表元素，将列表变为一个空列表，但是列表仍然存在，返回值为 None	lst.clear()	[]
del	否	什么都可以删，但是一旦删除，就是从内存中抹除	del lst

3.3 改

方法	内置方法（列表）	作用	示例	结果
通过索引修改	否	将指定索引的元素修改	lst[0] = “Mike”
修改某个切片	否	将列表某个切片的元素修改
sort()	是	将列表元素排序，默认从小到大，指定参数 reverse=True 则从大到小排序，返回值为 None	lst2.sort(reverse=True)
reverse()	是	将列表元素翻转，会对列表造成改变，如果不想影响原列表，可以使用步长 -1 翻转	lst.reverse()

补充：

对列表的切片进行修改

name_lst = ["Amy", "Bob", "Mike", "John", "Jacky"]

name_lst[1:4] = "Python", "Java", "Matlab"
print(name_lst)

name_lst[1:4] = ["Matlab", "Java", "Python"]
print(name_lst)

# 输出:
['Amy', 'Python', 'Java', 'Matlab', 'Jacky']
['Amy', 'Matlab', 'Java', 'Python', 'Jacky']

对不可变数据类型字符串的修改

字符串是不可变数据类型；列表是可以变数据类型；

因此可以先把字符串转换为一个列表，然后对列表进行修改，最后再拼接为字符串

str1 = "python"
lst = list(str1)
print(lst)
lst[0] = "P"
print(lst)
str1 = "".join(lst)
print(str1)

# 输出:
['p', 'y', 't', 'h', 'o', 'n']
['P', 'y', 't', 'h', 'o', 'n']
Python

3.4 查

方法	内置方法（列表）	作用	示例	结果
type()	否	返回列表类型	type([“Mike”, “John”, “Amy”])	<class ‘list’>
len()	否	返回列表长度	len([“A”, “B”, “C”, [“D”, “E”]])	4
lst[0]	否	查看列表中指定索引的元素	lst = [“Mike”, “John”, “Amy”]	Mike
遍历	否	循环遍历列表元素	while 循环、for 循环
切片	否	查看列表的某个切片
in 关键字	否	判断某个元素是否在列表中	“1” in [1, 2, 3, 4, 5]	False
index()	是	返回对应元素的索引	[ ‘Matlab’, ‘Java’, ‘Python’].index(‘Java’)	1
count()	是	返回某元素出现的个数	[“aaa”, “bbb”, “ccc”, “aaa”, “aaa” ].count(“aaa”)	3

补充：

通过索引访问列表元素

names = ['james', 'michael', 'emma', 'emily']
print(names[0])
print(names[-1])
print(names[-2])
print(names[len(names) - 2])

# 输出:
james
emily
emma
emma

for 循环遍历列表

names = ['james', 'michael', 'emma', 'emily']

for name in names:
    print(name, end=" ")
print()

for i in range(len(names)):
    print(names[i], end=" ")
print()

# 输出:
james michael emma emily 
james michael emma emily 

while 循环遍历列表

index = 0

while index < len(names):
    print(names[index])
    index += 1
    
# 输出:
james michael emma emily 

列表的切片

a=['egg', 'fish', 'cake', 'tomato', 'james', 'ava', 'michael', 'emma', 'emily']
print(a[1:3]) 		# 按下标 0 开始，不包括最右边的 3
print(a[1:]) 		# 1 以及之后的全部
print(a[:3]) 		# 3 之前的但不包括 3
print(a[:]) 		# 所有
print(a[::2])		# start 和 end 为空的时候，默认是全选，step 为空时默认是 1,这个表示的是从索引为 0 开始，以步长为 2 来选择元素
print(a[1:3:2])		# 以索引为 1 开始，索引 3 结束，步长为 2 来选择元素
print(a[::-1])		# 当 step 为 -1 时，将列表进行了逆序排序
print(a[::-2])		# 当步长为正数时，是从左到右以该步长来获取列表中的元素，当步长为负数时，是从右边到左以该步长的绝对值来获取的元素
print(a[0, 1, 3])	# 不可以通过离散的索引值来获取

字典

1. 定义

• Python 字典是另一种可变容器模型，可存储任意类型对象，如字符串、数字、元组等其他容器模型；
• 因为字典是无序的，所以不支持索引和切片；
• 元素以键值对存在 key(键值) : value(实值)
• 键是唯一的，且必须是不可变数据类型

2. 字典的创建

2.1 通过花括号创建

dict1 = {"name": "Jarvis", "age": 21, "gender": "Male"}
print(type(dict1))
print(dict1)

# 输出:
<class 'dict'>
{'name': 'Jarvis', 'age': 21, 'gender': 'Male'}

2.2 创建空字典

dict2 = {}
print(dict2)

# 输出:
{}

2.3 使用 dict 类的方法创建字典

# 使用 dict 类的方法创建字典
course = ["chinese", "math", "science", "english"]
dict2 = dict.fromkeys(course, 60)
print(dict2)

# 输出:
{'chinese': 60, 'math': 60, 'science': 60, 'english': 60}

3. 字典的增删改查

3.1 增

方法	内置方法（字典）	作用	示例	结果
新键赋值	否	给字典的一个新键赋值，这个新的键原先没有	dict1[“ID”] = “2021216432”	字典中多出新的键值对
update()	是	给字典添加新的键值对，传入的参数也是一个字典，返回值为 None	dict1.update({“height”: 172, “weight”: 110})	字典中多出新的键值对

3.2 删

方法	内置方法（字典）	作用	示例	结果
del	否	删除字典中的键值对	del dict1[“gender”]	字典中对应的键值对被删除
pop(）	是	根据参数传入的键，删除对应的键值对，返回值为键对应的值	a = dict1.pop(“gender”)

3.3 改

方法	内置方法（字典）	作用	示例	结果
根据键修改	否	根据键，修改对应的值	dict1[“name”] = “Python”
update()	是	对字典中指定键的值进行修改，传入的参数也是一个字典，返回值为 None	dict1.update({“weight”: 109})

3.4 查

方法	内置方法（字典）	作用	示例	结果
根据键查找	否	根据键，查找对应的值，返回对应的值	dict1[“name”]	Jarvis
len()	否	返回字典的长度（键值对的个数）	len(dict1)
in 关键字	否	判断键是否在字典中，返回真或假	“age” in dict1	True
遍历键	否	依次取出字典中的每一个键 Key，如果你想取到值，只需要 dict1[Key]	for Key in dict
get()	是	根据输入的键，查找并返回对应的值；如果键不存在，则返回 None	n = dict1.get(“name”)	Jarvis
get() 两个参数	是	第一个参数为键，根据输入的键在字典中查找并返回对应的值；如果键不存在，返回第二个参数	name = dict1.get(“nameTMD”, 5128340)	5128340
keys()	是	返回一个迭代器，里面的元素是字典中的每个键，有点像列表，类型为 dict_keys	Keys = dict1.keys()	dict_keys([‘name’, ‘age’, ‘gender’])
values()	是	返回一个迭代器，里面的元素是字典中的每个键对应的值，类型为 dict_values	values = dict1.values()	dict_values([‘Jarvis’, 21, ‘Male’]
items()	是	返回一个迭代器，里面的元素是字典中的每个键值对组成的小元组，类型为 dict_items	items = dict1.items()	dict_items([(‘name’, ‘Jarvis’), (‘age’, 21)]
list()	否	可以用来将 dict_keys 类型或者 dict_values 类型或者dict_items 类型的迭代器对象转换为一个真正的列表	Keys = list(dict1.keys())	[‘name’, ‘age’, ‘gender’]
遍历 dict1.items()	否	以小元组的形式，依次取出字典中的每个键值对	for item in dict1.items(): print(item)	(‘name’, ‘Jarvis’)
两个参数遍历dict1.items()	否	序列的解包，第一个参数对应元组中的键，第二个参数对应元组中的值	for key, value in dict1.items():	key 即每一个键 value 即对应的值

变量的赋值方式（补充）

方法一：直接赋值

a = 10
b = True
c = 2 + 3
print(a, b, c)

# 输出:
10 True 5

方法二：多个变量同时赋值

a, b, c, d = 1, False, 3.141592, True
print(a, b, c, d)

# 输出:
1 False 3.141592 True

方法三：使用变量接收序列对象的值

# 要保证两边个数相同
a, b, c, d = [1, 3.1412, True, False]   # 列表
print(a, b, c, d)
a, b, c, d = ("aaa", "bbb", "ccc", "ddd")   # 元组
print(a, b, c, d)

# 输出:
1 3.1412 True False
aaa bbb ccc ddd