Python数据结构讲解

数据结构

​ Python中的数据结构是用于存储和管理数据的基本工具。常用的数据结构包括字符串、列表、元组、字典和集合。每种数据结构都有其独特的特点和操作方法。以下是对它们的详细讲解：

字符串操作

​ 字符串是一种不可变的序列数据类型，用于表示文本数据。在 Python 中，字符串的操作非常丰富。

1. 切片、拼接、查找、替换

• 切片：

  • 切片用于提取字符串中的一部分，使用[start:end:step]语法。

  • start 是起始索引（包含），end 是结束索引（不包含），step 是步长（默认为1）。

  • 如果 start 或 end 省略，则分别默认从头开始或到字符串末尾结束。

  • 例子：

    s = "hello world"
    

  print(s[1:5]) # 输出 “ello”
  print(s[::2]) # 输出 “hlowrd”
  print(s[::-1]) # 输出 “dlrow olleh”

  
  - 注意：索引可以为负数，表示从字符串末尾开始计数。
  
  

• 拼接：

  • 使用 + 操作符拼接字符串。
  • 例子：

    s1 = "hello"
    s2 = "world"
    s = s1 + " " + s2  # 输出 "hello world"
    

• 查找：

  • 使用 find() 方法查找子字符串的位置，返回第一个匹配的起始索引，如果未找到返回 -1。
  • 使用 index() 方法查找子字符串的位置，返回第一个匹配的起始索引，如果未找到抛出 ValueError 异常。
  • 例子：

    s = "hello world"
    print(s.find("world"))   # 输出 6
    print(s.find("python"))  # 输出 -1
    print(s.index("world"))  # 输出 6
    # print(s.index("python")) # 抛出 ValueError 异常
    

• 替换：

  • 使用 replace() 方法替换子字符串，返回一个新的字符串。
  • 例子：

    s = "hello world"
    new_s = s.replace("world", "python")  # 输出 "hello python"
    

2. 字符串格式化

• f-string（Python 3.6+）：

  • 例子：

    name = "Alice"
    age = 30
    print(f"{name} is {age} years old.")  # 输出 "Alice is 30 years old."
    

• str.format() 方法：

  • 例子：

    name = "Alice"
    age = 30
    print("{} is {} years old.".format(name, age))  # 输出 "Alice is 30 years old."
    

• 百分号 % 格式化：

  • 例子：

    name = "Alice"
    age = 30
    print("%s is %d years old." % (name, age))  # 输出 "Alice is 30 years old."
    

3. 常用字符串方法

• split()：

  • 将字符串拆分为列表。
  • 例子：

    s = "hello world"
    words = s.split()  # 输出 ["hello", "world"]
    

• join()：

  • 将列表拼接为字符串。
  • 例子：

    words = ["hello", "world"]
    s = " ".join(words)  # 输出 "hello world"
    

• upper()：

  • 将字符串转换为大写。
  • 例子：

    s = "hello"
    print(s.upper())  # 输出 "HELLO"
    

• lower()：

  • 将字符串转换为小写。
  • 例子：

    s = "HELLO"
    print(s.lower())  # 输出 "hello"
    

• 其他常用方法：

  • strip()：去除字符串两端的空白字符。
  • startswith()：检查字符串是否以指定前缀开头。
  • endswith()：检查字符串是否以指定后缀结尾。
  • count()：统计子字符串在字符串中出现的次数。

• 注意事项：

  • 字符串是不可变的，因此所有字符串操作都会返回一个新的字符串，而不会修改原字符串。
  • 在进行字符串操作时，要注意编码问题，尤其是处理非ASCII字符时，建议使用UTF-8编码。

列表

​ 列表是Python中最常用的数据结构之一，是一个可变的、序列化的集合，可以包含不同类型的元素。

1. 定义与访问元素

• 定义列表：

  • 使用方括号 [] 定义列表。
  • 例子：

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

• 访问元素：

  • 通过索引访问列表中的元素，索引从0开始，支持负索引从列表末尾开始访问。
  • 例子：

    lst = [1, 2, 3, 4, 5]
    print(lst[0])   # 输出 1
    print(lst[-1])  # 输出 5（从末尾访问）
    

• 嵌套列表：列表可以包含其他列表，形成多维列表。

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

2. 列表操作（增、删、改、查）

• 增：

  • append()：在列表末尾添加元素。

    lst = [1, 2, 3]
    lst.append(4)  # lst 变为 [1, 2, 3, 4]
    

  • insert()：在指定位置插入元素。

    lst = [1, 2, 3]
    lst.insert(1, 5)  # lst 变为 [1, 5, 2, 3]
    

• 删：

  • remove()：移除列表中的第一个匹配项。

    lst = [1, 2, 3, 2]
    lst.remove(2)  # lst 变为 [1, 3, 2]
    

  • pop()：移除并返回指定位置的元素（默认为最后一个）。

    lst = [1, 2, 3]
    lst.pop()     # lst 变为 [1, 2]
    lst.pop(0)    # lst 变为 [2]
    

  • clear()：移除所有元素。

    lst = [1, 2, 3]
    lst.clear()   # lst 变为 []
    

• 改：

  • 直接使用索引修改元素。

    lst = [1, 2, 3]
    lst[1] = 5  # lst 变为 [1, 5, 3]
    

• 查：

  • index()：查找元素的索引。

    lst = [1, 2, 3]
    print(lst.index(2))  # 输出 1
    

  • count()：统计元素出现的次数。

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

3. 列表切片

• 切片语法与字符串相同，使用 [start:end:step]。
  • 例子：

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

4. 列表推导式

• 列表推导式是一种简洁的列表创建方式。
  • 例子：

    lst = [x**2 for x in range(6)]  # 输出 [0, 1, 4, 9, 16, 25]
    

元组

元组是一个不可变的、有序的序列数据类型。一旦创建，元组中的元素不能被修改。

1. 定义与访问元素

• 定义元组：

  • 使用小括号 () 定义元组。
  • 例子：

    tup = (1, 2, 3)
    

• 访问元素：

  • 使用索引访问元组元素，索引从 0 开始。
  • 例子：

    tup = (1, 2, 3)
    print(tup[0])   # 输出 1
    print(tup[-1])  # 输出 3（从末尾访问）
    

2. 不可变特性

• 元组是不可变的，一旦定义就不能修改其元素。
  • 例子：

    tup = (1, 2, 3)
    # tup[1] = 4  # 这会导致错误
    

3. 解包

• 元组可以直接解包赋值给多个变量。
  • 例子：

    tup = (1, 2, 3)
    a, b, c = tup  # a = 1, b = 2, c = 3
    

字典

1. 定义与访问元素

• 定义字典：

  • 使用花括号 {} 定义键值对。
  • 例子：

    d = {"name": "Alice", "age": 30}
    

• 访问元素：

  • 使用键来访问对应的值。
  • 例子：

    d = {"name": "Alice", "age": 30}
    print(d["name"])  # 输出 "Alice"
    

2. 增删改查

• 增：

  • 直接添加新键值对。

    d = {"name": "Alice"}
    d["age"] = 30  # d 变为 {"name": "Alice", "age": 30}
    

• 删：

  • 使用 del 关键字删除指定键值对。

    d = {"name": "Alice", "age": 30}
    del d["age"]  # d 变为 {"name": "Alice"}
    

  • 使用 pop() 方法删除并返回指定键的值。

    d = {"name": "Alice", "age": 30}
    age = d.pop("age")  # d 变为 {"name": "Alice"}
    

  • 使用 clear() 方法删除所有键值对。

    d = {"name": "Alice", "age": 30}
    d.clear()  # d 变为空字典 {}
    

• 改：

  • 直接通过键修改对应的值。

    d = {"name": "Alice", "age": 30}
    d["age"] = 31  # d 变为 {"name": "Alice", "age": 31}
    

• 查：

  • 使用 get() 方法根据键获取值，如果键不存在则返回 None 或默认值。

    d = {"name": "Alice", "age": 30}
    print(d.get("name"))  # 输出 "Alice"
    print(d.get("address", "unknown"))  # 输出 "unknown"
    

3. 字典推导式

• 字典推导式用于基于现有字典或序列生成新的字典。
  • 例子：

    squares = {x: x**2 for x in range(6)}  # 输出 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
    

集合

1. 定义与基本操作

• 定义集合：

  • 使用花括号 {} 定义集合，集合中的元素是唯一且无序的。
  • 例子：

    s = {1, 2, 3, 4}
    

• 并集：

  • 使用 | 操作符或 union() 方法计算两个集合的并集。
  • 例子：

    s1 = {1, 2, 3}
    s2 = {3, 4, 5}
    s3 = s1 | s2  # 输出 {1, 2, 3, 4, 5}
    

• 交集：

  • 使用 & 操作符或 intersection() 方法计算两个集合的交集。
  • 例子：

    s1 = {1, 2, 3}
    s2 = {3, 4, 5}
    s3 = s1 & s2  # 输出 {3}
    

• 差集：

  • 使用 - 操作符或 difference() 方法计算两个集合的差集。
  • 例子：

    s1 = {1, 2, 3}
    s2 = {3, 4, 5}
    s3 = s1 - s2  # 输出 {1, 2}
    

• 对称差集：

  • 使用 ^ 操作符或 symmetric_difference() 方法计算两个集合的对称差集。
  • 例子：

    s1 = {1, 2, 3}
    s2 = {3, 4, 5}
    s3 = s1 ^ s2  # 输出 {1, 2, 4, 5}
    

2. 集合推导式

• 集合推导式用于基于序列生成新的集合。
  • 例子：

    s = {x**2 for x in range(6)}  # 输出 {0, 1, 4, 9, 16, 25}
    

这些数据结构是Python编程的基础，掌握它们将为处理更复杂的数据和算法奠定基础。在学习过程中，通过实践练习来巩固这些知识非常重要。