一、列表

• 列表是 Python 中最常用的数据结构之一，它是一个有序的集合，可以包含任何数据类型的元素，如整数、浮点数、字符串等。
• 列表使用方括号 [ ] 表示，各元素之间用逗号 , 分隔。
• 列表中的元素可以通过索引访问，并且列表是可变的，即可以修改、添加或删除其中的元素。

列表的创建

在Python中，列表可以通过以下方式来创建：

# 创建一个空列表
my_list = []

# 创建一个带有初始元素的列表
my_list = [1, 2, 3, 4, 5]

my_list = [1, 'a', 2.3]   # 一个包含整数、字符串和浮点数的列表

# 创建一个包含其他列表的列表（嵌套列表）
nested_list = [[1, 2], [3, 4], [5, 6]]

多维列表

• 多维列表通常被称为嵌套列表，它是列表中包含其他列表的列表。
• 这种嵌套结构使得 Python 的列表能够灵活地表示多维数据结构，例如矩阵、数组等。

# 创建一个二维列表（3x3矩阵）
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]

# 访问列表元素
print(matrix[0][0])  # 输出：1
print(matrix[1][2])  # 输出：6
print(matrix[2][1])  # 输出：8

# 修改列表元素
matrix[1][1] = 10
print(matrix[1][1])  # 输出：10

# 添加新的列表
new_row = [11, 12, 13]
matrix.append(new_row)
print(matrix)  # 输出：[[1, 2, 3], [4, 10, 6], [7, 8, 9], [11, 12, 13]]

列表的访问和修改

• 访问列表中的元素可以使用索引，索引从0开始，可以使用负数索引从末尾开始计数。

my_list = [1, 2, 3, 4, 5]

# 访问列表元素
print(my_list[0])  # 输出: 1
print(my_list[-1])  # 输出: 5

# 修改列表元素
my_list[0] = 10
print(my_list)  # 输出: [10, 2, 3, 4, 5]

列表的添加和删除

• 向列表中添加元素可以使用 append() 方法，删除元素可以使用 remove() 方法或 pop() 方法。
  

my_list = [1, 2, 3, 4, 5]

# 添加元素
my_list.append(6)
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

# 删除元素
my_list.remove(3)  # 删除值为3的元素
print(my_list)  # 输出: [1, 2, 4, 5, 6]

popped_element = my_list.pop(2)  # 删除索引为2的元素
print(popped_element)  # 输出: 4
print(my_list)  # 输出: [1, 2, 5, 6]

列表的遍历

使用 for 循环遍历

my_list = [1, 2, 3, 4, 5]
for item in my_list:
    print(item)

使用 while 循环遍历

my_list = [1, 2, 3, 4, 5]
index = 0
while index < len(my_list):
    print(my_list[index])
    index += 1

同时遍历索引和元素

有时候可能需要同时访问元素和其索引，可以使用 enumerate() 函数来实现：

my_list = [1, 2, 3, 4, 5]
for index, item in enumerate(my_list):
    print(index, item)

列表推导式

列表推导式是一种更为简洁的方式来遍历列表和对列表进行操作：

my_list = [1, 2, 3, 4, 5]
# 将每个元素加倍
doubled_list = [item * 2 for item in my_list]
print(doubled_list)

---

常用的列表函数

len()

len() 函数返回列表中元素的个数。

my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # 输出: 5

sort()

sort() 方法用于对列表进行排序。

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
my_list.sort()
print(my_list)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

reverse()

reverse() 方法用于颠倒列表中的元素顺序。

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  # 输出: [5, 4, 3, 2, 1]

index()

index() 方法用于返回指定元素的索引。

my_list = ['apple', 'banana', 'cherry', 'apple']
print(my_list.index('banana'))  # 输出: 1

count()

• count() 方法用于返回指定元素在列表中出现的次数。

my_list = [1, 2, 2, 3, 3, 3]
print(my_list.count(3))  # 输出: 3

extend()

• extend() 方法用于将另一个列表的元素添加到当前列表。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # 输出: [1, 2, 3, 4, 5, 6]

clear()

• clear() 方法用于清空列表中的所有元素。

my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)  # 输出: []

---

二、元组

• 元组（tuple）类似于列表，但是元组是不可变的，意味着一旦创建，其内容就不能被修改、添加或删除。
• 元组用圆括号 () 来表示。

创建元组

可以使用逗号 , 将多个元素组合在一起来创建元组，也可以使用圆括号 () 将元素括起来来创建元组。

# 使用逗号
my_tuple = 1, 2, 3, 4, 5
print(my_tuple)  # 输出: (1, 2, 3, 4, 5)

# 使用圆括号
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)  # 输出: (1, 2, 3, 4, 5)

访问元组元素

可以使用索引来访问元组中的元素，索引从0开始。

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])  # 输出: 1
print(my_tuple[2])  # 输出: 3

元组的不可变性

元组是不可变的，这意味着你不能修改元组中的元素，也不能向元组中添加或删除元素。

my_tuple = (1, 2, 3)
my_tuple[0] = 5  # 会抛出 TypeError: 'tuple' object does not support item assignment

元组的优点

• 不可变性（Immutable）：元组的内容在创建后不能被修改，这样可以保证数据的安全性和稳定性。
• 性能：由于元组的不可变性，Python 可以对元组进行一些优化，使其在某些情况下比列表更快。

元组的应用场景

• 函数返回值：函数可以返回多个值，这些值可以使用元组来返回。
• 不可变的键：元组可以作为字典的键，而列表不能，因为字典的键必须是不可变的。

# 函数返回值
def get_point():
    return 10, 20

x, y = get_point()
print(x, y)  # 输出: 10 20

# 不可变的键
my_dict = {(1, 2): 'value'}
print(my_dict[(1, 2)])  # 输出: value

元组是一种简单但强大的数据结构，可以用于安全地存储和传递数据，特别是在需要不可变性和性能方面。

---

三、字典

• 字典（dictionary）是一个无序、可变、以键值对形式存储数据的集合。
• 每个键值对都由一个键和一个与之相关联的值组成。
• 在字典中，键必须是唯一的，而值可以是任意类型的对象。
• 字典用花括号 {} 来表示，每个键值对之间使用逗号 , 分隔。

创建字典

# 创建空字典
my_dict = {}

# 创建带有初始键值对的字典
my_dict = {'name': 'yushifu', 'age': 23, 'city': 'Beijing'}

访问字典元素

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

my_dict = {'name': 'yushifu', 'age': 25, 'city': 'Beijing'}
print(my_dict['name'])  # 输出: yushifu
print(my_dict['age'])   # 输出: 23

添加或修改元素

可以通过给指定的键赋值的方式向字典中添加新的键值对，如果该键已经存在，则会修改对应的值。

my_dict = {'name': 'yushifu', 'age': 23, 'city': 'Beijing'}
my_dict['gender'] = 'male'  # 添加新的键值对
my_dict['age'] = 26  # 修改已有键的值

删除元素

可以使用 del 关键字来删除字典中的键值对，也可以使用 pop() 方法来删除指定键并返回其对应的值。

my_dict = {'name': 'yushifu', 'age': 23, 'city': 'Beijing'}
del my_dict['age']  # 删除键为 'age' 的键值对
age = my_dict.pop('age')  # 删除键为 'age' 的键值对，并返回值

字典的遍历

可以通过循环来遍历字典中的键值对。

my_dict = {'name': 'yushifu', 'age': 23, 'city': 'Beijing'}
for key, value in my_dict.items():
    print(key, value)

字典的常用方法

• keys()：返回字典中所有的键。
• values()：返回字典中所有的值。
• items()：返回字典中所有的键值对。

my_dict = {'name': 'yushifu', 'age': 23, 'city': 'Beijing'}
print(my_dict.keys())   # 输出: dict_keys(['name', 'age', 'city'])
print(my_dict.values())  # 输出: dict_values(['yushifu', 23, 'Beijing'])
print(my_dict.items())   # 输出: dict_items([('name', 'yushifu'), ('age', 23), ('city', 'Beijing')])

字典适合用于存储和操作具有键值对关系的数据。

---

四、集合

• Python中的集合（set）是一种无序且不重复的元素集，类似数学中的集合概念。
• 集合可以用于去重、判断成员关系等操作。
• 集合使用花括号 {} 来表示，元素之间使用逗号 , 分隔。

创建集合

• 可以使用花括号 {} 来创建集合。
• 也可以使用 set() 函数来创建一个空集合或从其他可迭代对象中创建集合。

# 创建空集合
my_set = set()

# 从列表中创建集合
my_set = set([1, 2, 3, 4, 5])

# 直接创建集合
my_set = {1, 2, 3, 4, 5}

集合的特点

• 无序性：集合中的元素没有顺序，不能通过索引访问。
• 唯一性：集合中的元素是唯一的，不存在重复元素。

访问集合元素

由于集合是无序的，不能通过索引来访问元素。可以使用循环或者转换为列表来访问集合中的元素。

my_set = {1, 2, 3, 4, 5}
for item in my_set:
    print(item)

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

修改集合

由于集合的元素是不可变的，不能直接修改集合中的元素。但是可以添加新的元素或者删除已有的元素。

my_set = {1, 2, 3}
my_set.add(4)  # 添加元素
my_set.remove(2)  # 移除元素

集合的常用操作

• 并集、交集、差集：可以使用集合操作符 |、&、- 来执行集合的并集、交集和差集操作。
• 成员关系判断：可以使用 in 和 not in 来判断元素是否在集合中。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 并集
union_set = set1 | set2  # 输出: {1, 2, 3, 4, 5, 6}
# 交集
intersection_set = set1 & set2  # 输出: {3, 4}
# 差集
difference_set = set1 - set2  # 输出: {1, 2}
# 成员关系判断
print(2 in set1)  # 输出: True
print(5 not in set1)  # 输出: True

集合的应用场景

• 去重：通过集合可以快速实现对列表等可迭代对象的去重操作。
• 成员关系判断：可以高效地判断一个元素是否包含在集合中。
• 集合运算：可以方便地进行集合的并集、交集、差集等操作。