数据结构

List 列表概述

列表是一种有序、可变的数据集合，可以容纳不同类型的元素。

列表就是一个排列整齐的队伍，在 Python 中，列表就是顺序表实现的
列表内的个体称作元素，由若干元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性的数据结构
使用[]表示
列表是可变的

列表是非常重要的数据结构，对其内存结构和操作方法必须烂熟于心。

列表（List）是Python中最常用的数据结构之一，它是一种有序的可变序列，可以存储任意类型的数据。列表的元素可以通过下标进行访问，下标从0开始，也可以使用切片（Slice）来访问列表中的一段元素。

列表的特点如下：

列表中的元素可以是任意类型的数据，包括数字、字符串、布尔值、列表、元组等。
列表是有序的，每个元素都有一个对应的索引。
列表是可变的，可以通过添加、删除、修改元素等操作改变列表的内容。
列表中可以包含重复的元素。
列表支持嵌套，即列表中可以包含其他列表。

常见的列表操作包括：

创建列表：可以使用方括号[]或者list()函数来创建一个空的列表，也可以在方括号中添加元素来创建一个非空的列表。
访问列表元素：可以通过下标来访问列表中的元素，下标从0开始，也可以使用切片来访问一段元素。
添加元素：可以使用append()方法在列表末尾添加一个元素，使用insert()方法在列表中的任意位置插入一个元素，使用extend()方法将一个列表中的元素添加到另一个列表中。
删除元素：可以使用remove()方法删除指定的元素，使用pop()方法删除指定位置的元素，并返回该元素的值，使用del语句删除指定位置的元素。
修改元素：可以通过下标来修改列表中的元素。
查找元素：可以使用in关键字判断列表中是否存在指定的元素，使用index()方法查找指定元素的位置。
排序和反转：可以使用sort()方法对列表进行排序，使用reverse()方法对列表进行反转。

在Python中，列表是非常常用的数据结构之一，可以用于各种数据处理和计算任务，也是很多Python库和框架的基础数据结构。

线性数据结构

线性数据结构是指数据元素之间存在一对一的相邻关系的数据结构。常见的线性数据结构包括数组、链表、栈和队列等。

数组（Array）：是一种基本的数据结构，它由一组连续的内存单元组成，可以容纳一组具有相同类型的元素。数组中的元素按照线性顺序排列，可以使用下标操作符来访问数组中的元素，时间复杂度为 O(1)。
链表（Linked List）：是一种动态数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表可以分为单向链表、双向链表和循环链表。链表中的元素不需要连续的内存空间，可以动态的添加、删除节点，时间复杂度为 O(1)。
栈（Stack）：是一种后进先出（LIFO）的数据结构，它只允许在栈顶进行插入和删除操作。栈可以用数组或链表实现。
队列（Queue）：是一种先进先出（FIFO）的数据结构，它可以在队尾插入元素，在队首删除元素。队列可以用数组或链表实现。

线性数据结构在计算机科学中应用广泛，例如算法、数据存储和处理等领域。根据具体的应用场景和要求，选择适合的线性数据结构可以提高程序的效率和性能。

线性表

线性表是一种基本的数据结构，它由 n（n>=0）个数据元素组成，这些元素按照线性顺序排列，每个元素都有唯一的直接前驱和直接后继。线性表中只有一个数据元素没有直接前驱，称之为表头，只有一个数据元素没有直接后继，称之为表尾。

线性表的存储结构通常有两种实现方式：

数组实现：线性表的每个元素都存储在数组的一个位置上，通过下标可以直接访问到每个元素。数组实现的优点是访问元素速度快，缺点是插入和删除元素需要移动其他元素，时间复杂度为 O(n)。
链表实现：线性表的每个元素都存储在一个节点中，节点包含数据和指向下一个节点的指针。链表实现的优点是插入和删除元素只需要改变指针的指向，时间复杂度为 O(1)，缺点是访问元素速度较慢，时间复杂度为 O(n)。

线性表的常见操作包括：

插入元素：将一个新元素插入到线性表的任意位置。
删除元素：从线性表中删除一个元素。
查找元素：查找线性表中某个元素的位置。
遍历元素：依次访问线性表中的每个元素。

线性表是一种非常基础的数据结构，它在计算机科学中的应用非常广泛，例如数组、链表、栈和队列等数据结构都可以通过线性表来实现。

顺序表（列表 List）

顺序表是一种线性表的存储结构，它是通过一段连续的内存空间来存储线性表中的元素。在顺序表中，线性表中的每个元素都按照一定的顺序存储在连续的内存空间中，每个元素占用一个固定的存储单元，也就是数组的一个元素。

顺序表的优点是支持随机访问，即可以通过下标来直接访问任意一个元素，访问速度很快。同时，由于顺序表是连续存储的，所以空间利用率也比较高。缺点是插入和删除元素比较困难，因为需要移动其他元素的位置。

顺序表通常由一个数组和一个记录元素个数的变量组成。数组用于存储元素，变量用于记录顺序表中实际存储的元素个数。顺序表中的元素可以是任意类型的数据，包括整数、浮点数、字符串等。

顺序表的常见操作包括：

初始化操作：创建一个空的顺序表。
插入元素：将一个新元素插入到顺序表的任意位置。
删除元素：从顺序表中删除一个元素。
查找元素：查找顺序表中某个元素的位置。
遍历元素：依次访问顺序表中的每个元素。

Python中的列表（List）就是一种顺序表的实现方式，它可以通过下标来访问任意一个元素，并且支持插入、删除和遍历等常见操作。在Python中，列表可以包含不同类型的元素，甚至可以包含其他列表，因此非常灵活。

元组

元组概述

元组（Tuple）是Python中的一种有序、不可变的数据类型。它与列表（List）相似，但不同之处在于元组的元素一旦创建，则不能被修改、添加或删除。

元组用圆括号 () 表示，其中的元素用逗号分隔。

元组的优点：

元组相对于列表在某些方面更加轻量级，适合存储一些不需要修改的数据。
元组可以作为字典的键，而列表不能，因为字典的键必须是不可变的。

元组是一种有用的数据结构，尤其在需要保护数据不被修改时很有用。

创建元组

你可以使用圆括号 () 来创建元组，并在其中放置逗号分隔的元素：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

创建只有一个元素的元组时，需要在这个元素后面加上逗号，以区分它与被括号包裹的普通值或表达式。没有逗号的话，Python 会将括号视为运算符或表达式中的优先级分组符。

例如，如果你想创建一个只包含整数1的元组，可以这样做：

single_element_tuple = (1,)

这个逗号很重要。如果不加逗号，Python 会将括号视为表示整数1的括号：

single_element_tuple_without_comma = (1)
print(type(single_element_tuple_without_comma))  # 输出：<class 'int'>

加上逗号后，Python 就知道你要创建一个元组：

single_element_tuple = (1,)
print(type(single_element_tuple))  # 输出：<class 'tuple'>

这个细微的差别非常重要，因为这影响了数据类型。

访问元组元素

元组的元素可以通过索引来访问，索引从0开始：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

print(my_tuple[0])  # 输出：1

print(my_tuple[3])  # 输出：'a'

切片

你可以使用切片操作来获取元组的子集：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

print(my_tuple[2:5])  # 输出：(3, 'a', 'b')

print(my_tuple[:4])   # 输出：(1, 2, 3, 'a')

print(my_tuple[3:])   # 输出：('a', 'b', 'c')

元组的方法

由于元组的不可变性，它具有较少的方法。主要的方法包括 count() 和 index()：

字典

字典键

字典中的键（key）是字典中用来唯一标识值（value）的部分。在 Python 字典中，键必须是不可变的对象，比如整数、字符串或元组等。键提供了对字典中值的快速访问，因为它们是唯一的，可以用来索引到特定的值。

下面是一个简单的示例说明如何使用字符串作为键来创建一个字典：

my_dict = {'name': 'Alice', 'age': 30, 'gender': 'female'}

## 使用键来访问对应的值
print(my_dict['name'])    # 输出: 'Alice'
print(my_dict['age'])     # 输出: 30
print(my_dict['gender'])  # 输出: 'female'

你也可以使用整数作为键：

my_dict = {1: 'apple', 2: 'banana', 3: 'orange'}

## 使用整数键来访问对应的值
print(my_dict[1])  # 输出: 'apple'
print(my_dict[2])  # 输出: 'banana'
print(my_dict[3])  # 输出: 'orange'

需要记住的是，字典中的键必须是唯一的。如果你尝试用已存在的键去添加新值，它会覆盖原来的值。值可以是任何数据类型，包括列表、字典等。

在 Python 中，字典的键必须是可哈希的，这意味着键必须是不可变的数据类型。因此，列表这样的可变数据类型不能作为字典的键。但是元组这样的不可变数据类型可以作为键。

例如，你可以使用元组作为字典的键：

my_dict = {('apple', 'banana'): 5, ('orange', 'grape'): 3}

## 使用元组作为键来访问对应的值
print(my_dict[('apple', 'banana')])  # 输出: 5
print(my_dict[('orange', 'grape')])  # 输出: 3

但如果尝试使用列表作为字典的键，会引发 TypeError 错误：

my_dict = {['apple', 'banana']: 5}
## 这行代码会引发 TypeError: unhashable type: 'list'

因此，虽然列表是可变的，不能作为字典的键，但你仍然可以将列表作为字典的值。

字典值

Python 中的字典的值可以是任何数据类型，包括列表。

## 创建一个字典，其值为列表
my_dict = {'numbers': [1, 2, 3, 4], 'fruits': ['apple', 'banana', 'orange']}

## 访问字典中值为列表的键
print(my_dict['numbers'])  # 输出: [1, 2, 3, 4]
print(my_dict['fruits'])   # 输出: ['apple', 'banana', 'orange']

在这个例子中，字典 my_dict 中的值是列表。你可以使用键来访问这些列表，并对列表进行操作，就像对任何其他列表一样。

字符串

在Python中，字符串是一个不可变的序列，由一系列Unicode字符组成。

字符串可以用单引号、双引号、三引号来表示，其中单引号和双引号的作用是相同的，而三引号则可以用来表示多行字符串。

字符串定义

使用单引号表示字符串

s1 = 'Hello, world!'
print(s1)  # Output: Hello, world!

使用双引号表示字符串

s2 = "Hello, world!"
print(s2)  # Output: Hello, world!

使用三引号表示多行字符串

s3 = """Hello,
world!"""
print(s3)  # Output: Hello,
           #         world!

字符串处理

r 前缀

r 前缀就是告诉字符串不要转义了

在Python中，字符串可以使用r前缀来表示一个“原始字符串”，它的作用是告诉Python解释器，这个字符串中的所有字符都应该按照它们的字面意义来处理，而不进行任何转义。

对于Python中的字符串，r前缀可以大写也可以小写，它的作用是告诉Python将字符串视为“原始字符串”，即不会对其中的转义字符进行转义。无论是大写的R还是小写的r，它们的作用是一样的，都可以用来表示“原始字符串”。

范例

在某些情况下，使用r前缀可以让代码更加清晰易懂，特别是当你需要表示一些包含大量反斜杠的字符串时，避免手动进行转义可以让代码更加简洁，易读。

例如，假设我们要表示一个Windows路径：

path = "C:\\Users\\Bob\\Documents\\example.txt"

这个路径中包含了很多反斜杠（\），而反斜杠是一个转义字符，因此需要使用两个反斜杠来表示一个反斜杠。

但是，如果我们使用r前缀，则可以让Python将字符串视为“原始字符串”，这样就不需要使用两个反斜杠来表示一个反斜杠了，例如：

path = r"C:\Users\Bob\Documents\example.txt"

在这个字符串中，反斜杠不再是一个转义字符，而是一个普通的字符，因此只需要使用单个反斜杠来表示它即可。

在上面的例子中，r前缀告诉Python解释器，字符串中的反斜杠应该被当作普通字符来处理，而不是表示转义字符，因此这个字符串可以直接被用于Windows路径的表示，而不需要对反斜杠进行转义。

f 前缀

使用f-字符串，我们可以在字符串中使用大括号{}来引用Python表达式，例如变量、函数调用、算术运算等等。在字符串被解析和格式化时，大括号内的表达式将被计算并替换为其结果。

范例

下面是一个使用f-字符串进行格式化输出的示例：

name = "Alice"
age = 30
height = 1.65

print(f"My name is {name}, and I am {age} years old. My height is {height:.2f} meters.")

在这个例子中，我们使用f-字符串来输出一句话，包括名字、年龄和身高。在字符串中，我们使用大括号{}来引用变量name、age和height，并使用点号.来表示要对height进行小数位精度控制。在输出时，Python会计算这些表达式并替换大括号内的内容，最终输出的结果为：

字节序列

bytes 和 bytearray 是 Python 内建的两种二进制数据类型，它们都用于表示字节序列，即由一系列字节组成的不可变（bytes）或可变（bytearray）序列。

bytes 和 bytearray 都可以用来存储二进制数据，如图片、音频、视频等文件。它们的元素是 0 到 255 之间的整数（即一个字节），每个整数对应一个 ASCII 码表中的字符或一个二进制数据。

bytes 是不可变的序列，因此不能像列表那样修改它的元素。可以使用下标操作符 [ ] 或切片操作符 [:] 访问 bytes 对象中的元素，但是无法通过下标或切片修改 bytes 对象中的元素。

bytearray 是可变的序列，可以像列表一样修改它的元素，也可以使用 append()、extend()、insert() 等方法来修改 bytearray 对象。

下面是一个使用 bytes 和 bytearray 的示例：

## 创建一个 bytes 对象
b = b'hello world'
print(b[0])    # 输出：104
## b[0] = 72   # 错误：bytes 对象不可变

## 创建一个 bytearray 对象
ba = bytearray(b)
print(ba[0])   # 输出：104
ba[0] = 72
print(ba)      # 输出：bytearray(b'Hello world')