Python 学习笔记（02）
一、列表
1、创建列表
# 创建列表
list1 = []
list2 = ['python','chemistry',1997,2000]
list3 = [1,2,3,4,5]
list4 = ["a","b","c","d"]
print("list1 = ",list1) # 输出：list1 = []
print("list2[1] = ",list2[1]) # 输出：list2[1] = chemistry
print("list2[1:4]:",list3[1:4]) # 输出：list2[1:4]: [2, 3, 4]
print("list4[0]:",list4[0]) # 输出：list4[0]: a
# print("list2[1:4]:",list3[1:4]) 输出第1个 ~ 第4个元素
2、删除列表元素
可以使用 del 语句删除列表元素，示例如下：
# 删除列表元素
list1 = ['python','chemistry',1997,2000]
print("list1 = ",list1) # 输出：list1 = ['python', 'chemistry', 1997, 2000]
del list1[2] # 删除第3元素 1997
print("list1 = ",list1) # 输出：list1 = ['python', 'chemistry', 2000]
3、修改列表元素
和字符串不同的是，列表是可变的，可以在列表中指定下标的值对元素进行修改。
# 替换 (修改) 列表元素
lst = [12,13] # 定义列表 lst
lst[1] = 15 # 修改第二个元素 13 -> 15
print("lst = ",lst) # 输出：lst = [12, 15]
4、读取列表元素
元素下标表示该元素在 list 的位置，注意 list 中的元素是从 0 开始的，如第 n 个元素的下标是 n - 1。
如果超出下标读取列表元素，会报错 “列表下标超出范围”。
读取列表元素，示例如下：
# 读取列表元素
list = ["a","b","c","d"]
print('list[0] = ',list[0])
print('list[1] = ',list[1])
print('list[2] = ',list[2])
print('list[3] = ',list[3])
print('list[5] = ',list[5]) # 会报错
# 输出：
# list[0] = a
# list[1] = b
# list[2] = c
# list[3] = d
# Traceback (most recent call last):
# File "c:\Gitee\python\02_Day\List_04.py", line 8, in <module>
# print('list[5] = ',list[5]) # 会报错
# IndexError: list index out of range
Python 的列表截取与字符串操作类似，代码如下所示：
L = ['spam','Spam','SPAM']
| 表达式 | 描述 | 结果 |
|---|---|---|
| L[2] | 读取列表中第三个元素 | ‘SPAM’ |
| L[-2] | 读取列表中倒数第二个元素 | ‘Spam’ |
| L[1:] | 从第二个元素开始截取列表 | [‘Spam’,‘SPAM’] |
5、遍历列表
遍历列表可以逐个处理列表中的元素，通常使用 for 循环和 while 循环来实现。
第一种遍历方法隐藏了列表的长度，操作较为便利，示例如下：
# 用 for 循环遍历列表
lst = ['python','chemistry',1997,2000]
for item in lst:
print(item,end = ',')
# 输出：
# python,chemistry,1997,2000,
第二种方法使用 while 循环遍历列表，需要先获取列表的长度，将获得长度作为循环条件。
用 while 遍历列表，示例如下：
# 用 while 循环遍历列表
# range() 是创建一个初始值为 2，终值为 15，步长为 2的整数列表
lst = list(range(2,15,2))
i = 0
result = []
while i < len(lst): # 使用len()函数计算列表lst的长度
result.append(lst[i] * lst[i]) # 向列表result末尾添加新的元素
i += 1 # i = i + 1 很难想像一本基础教材，总喜欢把问题复杂化(可能是我不习惯)
print(result)
# 输出：
# [4]
# [4, 16]
# [4, 16, 36]
# [4, 16, 36, 64]
# [4, 16, 36, 64, 100]
# [4, 16, 36, 64, 100, 144]
# [4, 16, 36, 64, 100, 144, 196]
6、列表的方法
除了使用序号操作符操作列表，列表还有特有的方法，它们的主要功能是完成列表元素的增删改查
Python 列表操作的函数如下：
| 操作符 | 描述 |
|---|---|
| cmp(list1, list2) | 比较两个列表的元素 |
| len(list) | 列表元素个数 |
| max(list) | 返回列表元素最大值 |
| min(list) | 返回列表元素最小值 |
| list(seq) | 将元祖转换为列表 |
Python 列表操作的方法如下：
| 操作符 | 描述 |
|---|---|
| list.append(obj) | 在列表末尾添加新的对象 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| list.index(obj) | 从列表中找出某个值第一次匹配项的索引位置 |
| list.insert(index,obj) | 将对象插入列表 |
| list.pop(obj = list[-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| list.remove(obj) | 移除列表中某个值得第一个匹配项 |
| list.reverse() | 反向列表中的元素 |
| list.sort([func]) | 对列表进行排序（默认升序） |
举两个小例子：
# 增加列表元素
list = []
list = list + ['x','y']
print(list)
list.append(True)
print(list)
list.extend(['z',5])
print(list)
# 输出：
# ['x', 'y']
# ['x', 'y', True]
# ['x', 'y', True, 'z', 5]
# 计算元素出现的次数
li = [11,22,33,'aa','bb','cc','aa']
li_new = li.count("aa") # Python 定义变量不需要声明
print(li_new)
# 输出：
# 2
二、元祖
元祖是包含0个或多个元素的不可变序列类型，元祖生成后是固定的，其中任意元素都是不能被替换或删除。
Python 的元祖和列表类似，不同之处在于元祖的元素不能修改。
元祖使用小括号，列表使用方括号。元祖创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
1、创建元祖
元祖通常使用标记 “( )” 创建，创建一个空元祖，代码如下：
tup = ( ) # 创建一个空元祖
元祖中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当做运算符使用。
# 创建元祖
student = (1,"tom","2008- 05- 06",10,135.7)
num = (1,2,3,4,5,6,7)
tup = ((1,2,3),(4,5),(6,7),9) # 共有4个元素
print("student[0]: ",student[0])
print("num[1:5]: ",num[1:5])
print("tup: ",tup[1])
# 输出：
# student[0]: 1
# num[1:5]: (2, 3, 4, 5)
# tup: (4, 5)
与列表的操作方式类似，按照下标输出元素
2、删除元素
上面说过，元祖里的元素是不能被修改的，所以也不能将元祖中的某个元素删除，但是，可以将整个元祖删除。
删除元祖，示例如下：
# 删除元祖
student = (1,"tom","2008- 05 -06",10,135.7)
del student
print(student)
# 输出：
# Traceback (most recent call last):
# File "c:\Gitee\python\02_Day\Tup_02.py", line 5, in <module>
# print(student)
# NameError: name 'student' is not defined
此时，如果在调用 student，编译器将会抛出异常信息；提示该变量已经找不到了（未定义）。
3、修改元素
元祖中的元素是不允许修改的，但我们可以对元祖进行链接组合。
当元祖中有列表时，可对元祖中的列表进行修改。
修改元祖，示例如下：
# 修改元祖
tup1 = (19,78.56)
tup2 = ('ab','xy')
tup3 = (1,3,5,7,9,[1,2,3,5,7,9])
# 以下修改元祖元素操作是非法的
# tup1[0] = 100;
# 创建一个新的元祖
tup4 = tup1 + tup2
tup3[5][0] = -1 # 修改元祖中 列表中的元素
print(tup4)
print(tup3)
# 输出：
# (19, 78.56, 'ab', 'xy')
# (1, 3, 5, 7, 9, [-1, 2, 3, 5, 7, 9])
4、元祖的运算符
与字符串、列表一样，元祖之间可以使用 + 号和 * 号进行运算。
这就意味着它们可以组合和复制，运算后生成一个新的元祖。
元祖运算符如下所示：
| Python 表达式 | 描述 | 结果 |
|---|---|---|
| len((1,2,3)) | 计算元祖个数 | 3 |
| (1,2,3) + (4,5,6) | 链接 | (1,2,3,4,5,6) |
| (‘Hi!’,) * 4 | 复制 | (‘Hi!’,‘Hi!’,‘Hi!’,‘Hi!’,) |
| 3in(1,2,3) | 元素是否存在 | True |
| for x in (1,2,3): print (x,end=’ ') | 迭代 | 1 2 3 |
5、元祖与列表的转换
元祖与列表十分类似，只是元祖中的数据无法修改。如果想要修改其元素的值，可以将元祖转换为列表，修改完成后，再转换为元祖。
列表和元祖相互转换的函数是 tuple(lst) 和 list(tup) ,其中的参数分别为被转换对象。
# 元祖与列表的相互转换
tup1 = (357,'abc','python','xyz')
lst1 = list(tup1) # 将元祖转换为列表
lst1.append(246) # 向列表末尾追加元素
tup1 = tuple(lst1) # 将列表转换为元祖
print(tup1)
# 输出：
# (357, 'abc', 'python', 'xyz', 246)
三、字典
在程序设计中，存储成对的数据是十分常见的需求。例如，想要统计一片英文文章中各个单词的出现次数。在这种情况下，如果有一种数据结构，能够成对地存储单词和对应的次数，就会对完成单词次数统计的任务很有帮助。
字典正是这样的数据类型，它是 Python 中内置的映射类型。映射是通过 键值对 查找一组数据值信息的过程，由于 Key-Value 的键值对组成，通过 Key 可以找到其映射的值 Value。
1、创建字典
字典是用于存储成对的元素，在一个字典对象中，键值不能重复，用于唯一标识一个键值对，而对于值的存储则没有任何限制。
字典可以看成是由键值对构成的列表，在搜索字典时，首先查找键，当查找到键后就可以直接获取该键对应的值，这是一种高效实用的查找方法。
字典可以用标记 “{}” 创建，字典中每个元素都包含键和值两部分，键和值用冒号分开，元素之间用逗号分隔。
dict() 用于创建字典的函数，函数参数为 “键 = 值” 或 “(键,值)” ，参数中间用逗号隔开。
创建字典，示例如下：
# 创建字典
dict1 = {}
dict2 = {'yuwn':88, 'shuxue':75, 'yingyu':96}
dict3 = dict(yuwen = 88, shuxue = 75, yingyu = 96)
dict4 = dict([('yuwn',88), ('shuxue',75), ('yingyu',96)]) # 1个列表，列表有3个元素
print('dict1 = ',dict1)
print('dict2 = ',dict2)
print('dict3 = ',dict3)
print('dict4 = ',dict4)
# 输出：
# dict1 = {}
# dict2 = {'yuwn': 88, 'shuxue': 75, 'yingyu': 96}
# dict3 = {'yuwen': 88, 'shuxue': 75, 'yingyu': 96}
# dict4 = {'yuwn': 88, 'shuxue': 75, 'yingyu': 96}
- 第一行用于创建一个空的字典，该字典不包含任何元素，可以向字典中添加元素。
- 第二行是典型的创建字典的方法，是用 “{}” 括起来的键值对。
- 第三行使用 dict() 函数，通过关键字参数创建字典。
- 第四行使用 dict() 函数，通过键值对序列创建字典。
2、查找与反向查找字典元素
字典定义好后，可以通过键值对来查找值，这个操作称为“查找”。
查找字典元素，示例如下：
# 查找字典元素
d1 = dict({"id":19,"name":"Marry","city":"chongqing"})
print(d1['id'])
print(d1["name"])
# 输出：
# 19
# Marry
3、遍历字典
用循环遍历字典语句来遍历字典中的每个元素的键和值。
遍历字典元素，示例如下：
# 遍历字典
d1 = dict({"id":19,"name":"Marry","city":"chongqing"})
for key in d1.keys():
print(key,d1[key])
# 输出：
# id 19
# name Marry
# city chongqing
4、添加和修改字典元素
字典的大小和列表都是动态的，即不需要事先指定其容量大小，可以随时向字典中添加新的键—值对，或者修改现有的键所关联的值。添加或修改的方法相同，都是使用“字典变量名 [键名] = 键值” 的形式，主要区别在于字典中是否已存在该键值对，若存在则为修改，否则为添加。
添加和修改字典元素，示例如下：
# 添加和修改字典元素
dict1 = {'sex':'female','name':'Lucy','id':19,'city':'hangzhou'}
# 修改字典元素
dict1["id"] = "18"
print("dict1 = ",dict1)
# 添加字典元素
dict1["email"] = "Python@126.com"
print("dict1 = ",dict1)
# 输出：
# dict1 = {'sex': 'female', 'name': 'Lucy', 'id': '18', 'city': 'hangzhou'}
# dict1 = {'sex': 'female', 'name': 'Lucy', 'id': '18', 'city': 'hangzhou', 'email': 'Python@126.com'}
5、检索字典元素
使用 in 运算符来测试某个特定的键是否在字典中，表达式为：key in dicts
其中，dicts 是字典名，key 是键名
# 使用 in 运算符检索
d1 = {'sex':'female','name':'Lucy','id':19,'city':'hangzhou'}
if "id" in d1:
print("键id存在")
else:
print("键id不存在")
# 输出：
# 键id存在
6、字典的常用函数
字典的常用函数如下所示：
| 操作符 | 描述 |
|---|---|
| dict.keys() | 返回所有键信息 |
| dict.values() | 返回所有值信息 |
| dict.items() | 返回所有键值对 |
| dict.get(key,default) | 键存在则返回相应值，否则返回默认值 |
| dict.pop(key,default) | 键存在则返回相应值，同时删除键值对，否则返回默认值 |
| dict.popitem() | 随机从字典中取出一个键值对，以元祖（key,value）的形式返回 |
| dict.clear() | 删除所有的键值对 |
| del dict[key] | 删除字典中的某个键值对 |
| dict.copy() | 复制字典 |
| dict.update(dict2) | 将一个字典中的值更新到另一个字典中 |
举个例子：
# get() 函数
dict = {"Name":"lucy","Age":19}
print("Name is:",dict.get('Name') + "\n" + "Age is:",dict.get('Age'))
# 输出：
# Name is: lucy
# Age is: 19
四、集合
集合是0个或多个元素的无序组合，集合与元祖、列表类似，用于存储一系列的元素。可以很容易地向集合中添加或移除集合中的元素。集合中的元素只能是整数、浮点数、字符串等基本的数据类型。集合中的任何元素都没有重复的，这是集合的一个重要特点。集合与字典有一定的相似之处，但集合只是一组 Key 的集合，这些 Key 不可以重复，集合中没有 Value.
1、创建集合
使用函数 set() 可以创建一个集合。与列表、元祖、元素等数据结构不同，创建集合没有快捷方式，必须使用 set() 函数。
set() 函数最多有一个参数，如果没有参数，则会创建一个空集合。如果有一个参数，那么参数必须是可迭代的类型。例如字符串或列表，可迭代对象的元素将生成集合的成员。
创建集合，示例如下：
# 没有参数，set会创建空集
nullSet = set()
print('nullSet = ',nullSet)
# 提供一个 str 作为输入集合，创建一个 set。
a_set = set('abcd')
print('a_set = ',a_set)
# 提供一个 list 作为输入集合，创建一个 set
s = set([1,2,3])
print('s = ',s)
# 重复元素在 set 中自动被过滤
b = set([1,1,2,2,3,3])
print('b = ',b)
# 输出：
# nullSet = set()
# a_set = {'b', 'd', 'c', 'a'}
# s = {1, 2, 3}
# b = {1, 2, 3}
2、删除集合元素
删除集合元素有三种方法，具体如下：
- 一是通过 remove(key) 方法删除元素，如果删除的元素不在集合中，remove 会报错。
- 二是 discard(key) 删除元素，不同的是，如果删除的元素不在集合中，discard 不会报错 。
- 三是 clear() 删除集合中的所有元素（使它成为空集）。
代码示例如下：
# 删除集合元素
a = set(['y','Python','b','o'])
a.remove('Python') # 删除元素 'Python'
print('a = ',a)
b = set(['b','h','o','n','p','t','y'])
b.discard('h') # 删除元素 'h'
print('b = ',b)
c = set(['n','p','t','y'])
c.clear() # 清空集合
print('c = ',c)
# 输出：
# a = {'y', 'o', 'b'}
# b = {'n', 'p', 'b', 'y', 'o', 't'}
# c = set()
3、添加集合元素
集合的添加有两种常用的方式，分别是 add 和 update。可以添加元素到 set 中，能重复添加，但不会有效果。
- 一是 add 方法：是把要传入的元素作为一个整体添加到集合中。
- 二是 update方法：是把要传入的元素拆分，作为个体添加到集合中。
示例如下：
# 添加集合元素
a = set('boy')
a.add('Python')
print('a = ',a)
b = set('boy')
b.update('Python')
print('b = ',b)
# 输出：
# a = {'y', 'o', 'b', 'Python'}
# b = {'h', 'y', 'n', 't', 'P', 'o', 'b'}
4、集合的遍历
用循环遍历集合语句来遍历集合中的每个元素。
# 集合的遍历
a = set("Python")
for x in a:
print(x,end = ' ')
# 输出：
# P t n h o y
5、集合的运算
Python 中的集合运算符是特殊的符号和函数，允许您对集合执行各种操作，例如并集、交集、差集和对称差集。这些运算符提供了一种组合、比较和修改集的方法。
| 运算类型 | 运算符/方法 | 描述 | 示例（基于集合 a = {1,2,3}，b = {2,3,4}） | 结果 |
|---|---|---|---|---|
| 并集 | `a | b/a.union(b)` | 合并两个集合的所有元素（去重） | `a |
| 交集 | a & b / a.intersection(b) | 取两个集合的共同元素 | a & b 或 a.intersection(b) | {2,3} |
| 差集 | a - b / a.difference(b) | 取属于 a 但不属于 b 的元素 | a - b 或 a.difference(b) | {1} |
| 对称差集 | a ^ b / a.symmetric_difference(b) | 取仅属于 a 或仅属于 b 的元素（排除交集） | a ^ b 或 a.symmetric_difference(b) | {1,4} |
| 子集判断 | a <= b / a.issubset(b) | 判断 a 是否是 b 的子集（包含相等） | a <= b 或 a.issubset(b) | False |
| 真子集判断 | a < b | 判断 a 是否是 b 的真子集（a 包含于 b 且 a ≠ b） | a < b | False |
| 超集判断 | a >= b / a.issuperset(b) | 判断 a 是否是 b 的超集（包含相等） | a >= b 或 a.issuperset(b) | False |
| 真超集判断 | a > b | 判断 a 是否是 b 的真超集（a 包含 b 且 a ≠ b） | a > b | False |
| 是否不相交 | a.isdisjoint(b) | 判断两个集合是否没有共同元素（无交集） | a.isdisjoint(b) | False |
| 添加元素 | a.add(x) | 向集合 a 中添加单个元素 x（已存在则无操作） | a.add(4) → a 变为 {1,2,3,4} | - |
| 移除元素 | a.remove(x) | 移除集合 a 中的元素 x（不存在则报错） | a.remove(3) → a 变为 {1,2} | - |
| 移除元素 | a.discard(x) | 移除集合 a 中的元素 x（不存在则无操作） | a.discard(4) → a 仍为 {1,2,3} | - |
| 弹出元素 | a.pop() | 随机移除并返回集合中的一个元素（空集合报错） | a.pop()（示例返回 1）→ a 变为 {2,3} | 随机元素 |
| 清空集合 | a.clear() | 清空集合所有元素 | a.clear() → a 变为 set() | - |
| 更新集合 | a.update(b) | 将 b 的所有元素添加到 a 中（等价于 `a | = b`） | a.update(b) → a 变为 {1,2,3,4} |
| 差集更新 | a.difference_update(b) | 从 a 中移除所有属于 b 的元素（等价于 a -= b） | a.difference_update(b) → a 变为 {1} | - |
| 交集更新 | a.intersection_update(b) | 将 a 更新为与 b 的交集（等价于 a &= b） | a.intersection_update(b) → a 变为 {2,3} | - |
| 对称差更新 | a.symmetric_difference_update(b) | 将 a 更新为与 b 的对称差（等价于 a ^= b） | a.symmetric_difference_update(b) → a 变为 {1,4} | - |
# 集合的运算
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
# 并集
union_result = A | B # 或 A.union(B)
print(union_result)
# 结果: {1, 2, 3, 4, 5, 6}
# 交集
intersection_result = A & B # 或 A.intersection(B)
print(intersection_result)
# 结果: {3, 4}
# 差集
difference_result = A - B # 或 A.difference(B)
print(difference_result)
# 结果: {1, 2}
# 对称差集
symmetric_result = A ^ B # 或 A.symmetric_difference(B)
print(symmetric_result)
# 结果: {1, 2, 5, 6}
最后：来个总结
| 数据结构 | 是否可变 | 是否重复 | 是否有序 | 定义符号 | 备注 |
|---|---|---|---|---|---|
| 列表（list） | 可变 | 元素可重复 | 有序 | [] | 支持增、删、改、查操作 |
| 元组（tuple） | 不可变 | 元素可重复 | 有序 | () | 仅支持查询，无法修改元素 |
| 字典（dict） | 可变 | key不可重复，value可重复 | 无序（Python 3.7+ 实际有序） | {key: value} | 以键值对形式存储数据 |
| 集合（set） | 可变 | 元素不可重复 | 无序 | {} | 空集合需用 set() 定义 |
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
