Python期末系统梳理（二）：内置数据结构

几种数据结构的比较

• 列表：由一系列按特定顺序排列的元素组成，使用方括号[ ]表示，逗号分割其中的元素，==可修改
• 元组：理解为不可修改的列表即可，使用圆括号（）表示
• 集合：无序且不重复的元素序列，使用大括号{ }表示
• 字典：一系列键值对，每个键和一个值关联，可使用键访问值，无序

再梳理

· 列表有序序列小括号，元组有序不可更改序列中括号，集合无序不重复序列大括号
· 字典一对一对，大括号，无序，键不变值可变

列表

示范：

bicycle = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycle)

也可使用list

# 使用list()函数从元组创建列表
tup = (1, 2, 3)
my_list = list(tup)
print(my_list)  # 输出: [1, 2, 3]

# 使用list()函数从集合创建列表
my_set = {4, 5, 6}
my_list = list(my_set)
print(my_list)  # 输出: [4, 5, 6]

# 使用list()函数从字典创建列表，只包含键
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_list = list(my_dict)
print(my_list)  # 输出: ['a', 'b', 'c']

# 使用list()函数复制一个已存在的列表
original_list = [1, 2, 3]
copy_list = list(original_list)
print(copy_list)  # 输出: [1, 2, 3]

访问元素

使用索引的方式，索引可理解为编号
如：

print(bicycle[0])

即访问列表bicycle中的第一个元素trek
· 注意，索引从0而不是从1开始，即第一元素的索引为0

常用方法

append():将元素添加到列表末尾
insert(n,element):将元素添加到n位置
pop():删除末尾元素（当传入参数n，即可删除n索引对应元素）
remove():根据值删除元素，但只删除第一个对应值
*del语句：删除索引对应元素，如:del bicycle[0]
sort():按字母顺序排列
sorted():按字母顺序排列,但临时生效
reverse():反转列表，永久生效
len():返回列表长度

遍历列表

一般使用for循环遍历列表

bicycle = ['trek', 'cannondale', 'redline', 'specialized']
for bic in bicycle:
    print(bic)

bic可以是任何变量
将输出列表中所有元素

使用列表的一部分（切片）

索引访问时，在中括号内用形如[m,n]访问m到n索引的元素（不包括n）

示范：

bicycle = ['trek', 'cannondale', 'redline', 'specialized']
print(bicycle)
print(bicycle[0:2])

即访问索引为0,1，2的元素
如果给第三个元素，代表每多少个访问一次

print(bicycle[0:3:2])

即访问索引为0,2的元素

一些特殊用法

· 可省略冒号前/后的索引值，代表从索引0/索引末尾开始/结束
· 都省略即代表全部访问
· 负数索引代表从后往前，如-1即代表最后一个，-2代表到数第二个（一般用于访问倒数n个元素）

复制列表

使用一个全部的切片（这是一种常见的浅拷贝方式）
示范：

# 原始列表
original_list = [1, 2, 3, 4, 5]

# 使用切片操作符复制列表
copy_list1 = original_list[:]
print(copy_list1)  # 输出: [1, 2, 3, 4, 5]

注意

直接将列表赋给另一个列表不可行，这样做的结果是两个列表名指向同一个列表而非创建副本（我们称之为引用赋值而非复制）

一些其他复制方法

浅拷贝

# 使用list()函数复制列表
copy_list2 = list(original_list)
print(copy_list2)  # 输出: [1, 2, 3, 4, 5]

# 使用copy()方法复制列表
copy_list3 = original_list.copy()
print(copy_list3)  # 输出: [1, 2, 3, 4, 5]

深拷贝

import copy
original_list = [[1, 2, 3], [4, 5, 6]]
deep_copy = copy.deepcopy(original_list)  # 深拷贝
original_list[0][0] = 'a'
print(deep_copy)  # 输出: [[1, 2, 3], [4, 5, 6]]

*浅拷贝创建一个新的对象，但只复制原始对象的引用，不复制引用的对象。这意味着，如果原始对象是一个可变对象（如列表或字典），并且改变了这个可变对象的内容，那么浅拷贝的对象也会受到影响。
*深拷贝创建一个新的对象，并递归复制原始对象的所有元素，包括所有子元素。这意味着，即使原始对象是一个可变对象，并且改变了这个可变对象的内容，深拷贝的对象也不会受到影响。

元组

可以使用圆括号 () 或者 tuple() 函数来创建元组。

# 使用圆括号创建元组
my_tuple = (1, 2, 3)

# 使用tuple()函数创建元组
my_tuple = tuple([1, 2, 3])

修改元组变量

元组的元素虽然不能修改，但可以给存储元组的变量赋值

# 创建一个元组
tup = (1, 2, 3)
print(tup)  # 输出: (1, 2, 3)

# 给元组变量重新赋值
tup = (4, 5, 6)
print(tup)  # 输出: (4, 5, 6)

集合

集合（Set）是一个无序的不重复元素序列，可以进行关系测试，删除重复数据，计算交集、差集、并集等。

创建集合

使用大括号 {} 或者 set() 函数创建集合，
>注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。

访问集合的值

由于集合是无序的索引，所以我们不能为集合创建索引或执行切片操作，也没有键(keys)可用来获取值，但是可以判断一个元素是否在集合中。

# 检查元素是否在集合中
print('b' in my_set)  # 输出: True

常用方法

add()：为集合添加元素
remove() 或 discard()：删除集合中的元素
clear()：清空集合
pop()：随机删除集合中的一个元素
copy()：复制一个集合
difference()：返回多个集合的差集
intersection()：返回集合的交集
union()：返回两个集合的并集

集合的计算

交集

交集是两个集合中共有的元素。在Python中，可以使用 intersection() 方法或 & 运算符来获取两个集合的交集。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.intersection(set2))  # 输出: {2, 3}
# 或者
print(set1 & set2)  # 输出: {2, 3}

并集

并集是两个集合所有的元素。在Python中，可以使用 union() 方法或 | 运算符来获取两个集合的并集。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.union(set2))  # 输出: {1, 2, 3, 4}
# 或者
print(set1 | set2)  # 输出: {1, 2, 3, 4}

差集

差集是从一个集合中移除所有属于另一个集合的元素后的结果。在Python中，可以使用 difference() 方法或 - 运算符来获取两个集合的差集。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.difference(set2))  # 输出: {1}
# 或者
print(set1 - set2)  # 输出: {1}

对称差集

对称差集是两个集合的并集减去他们的交集。也就是只属于其中一个集合，而不属于另一个集合的元素组成的集合。在Python中，可以使用 symmetric_difference() 方法或 ^ 运算符来获取两个集合的对称差集。

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.symmetric_difference(set2))  # 输出: {1, 4}
# 或者
print(set1 ^ set2)  # 输出: {1, 4}

列表和集合的转换

在某些情况下，我们可能需要将列表转换为集合，例如，当我们需要删除列表中的重复元素时。反之，我们也可能需要将集合转换为列表。

# 列表转集合
my_list = [1, 2, 2, 3, 4, 4, 5, 5]
my_set = set(my_list)
print(my_set)  # 输出: {1, 2, 3, 4, 5}

# 集合转列表
my_list = list(my_set)
print(my_list)  # 输出: [1, 2, 3, 4, 5]

字典

使用大括号 {} 或者 dict() 函数创建字典，键不可变，值可变

访问字典的值

可以通过键名来访问字典中的值。

# 访问元素
print(my_dict['name'])  # 输出: Alice

常用方法

keys()：返回一个包含字典所有键的列表
values()：返回一个包含字典所有值的列表
items()：返回一个包含所有 (键, 值) 元组的列表
get(key)：返回指定键的值，如果键不存在于字典中，则返回默认值
update(dict2)：把字典参数 dict2 的 key:value对 更新到字典 dict 里
clear()：删除字典内所有元素
del dict[key]：删除字典给定键 key 所对应的值。
pop(key)：删除字典给定键 key 所对应的值，返回值为被删除的值。如果键不存在，则返回 default 值。
popitem()：随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。