第二章 Python 数据结构入门详解-EW帮帮网

第二章 Python 数据结构入门详解

让我们从最基础的概念开始，一步步来了解 Python 中常见的数据结构——列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set）、以及与它们相关的 切片（Slice） 和 文件操作 等知识。

一、什么是数据结构？

在 Python 中，数据结构指的是对数据进行存储和组织的方式，以便我们能方便、高效地访问和修改数据。学习和掌握数据结构，可以让我们写出更简洁、更高效的 Python 代码。

Python 内置了如下常见的数据结构：

列表（List）：有序、可变序列
元组（Tuple）：有序、不可变序列
字典（Dictionary）：无序、可变的“键-值”映射
集合（Set）：无序、元素不重复

另外，Python 提供了对这些数据结构常见的操作，比如 索引、切片、增删改查 等功能，我们将在下文详细讲解。

二、列表（List）

2.1 列表的特点

有序：列表中元素有先后顺序，每个元素都有固定的索引（从 0 开始）。
可变：可以对列表进行增、删、改等操作，列表本身的大小和内容都可以发生变化。
灵活：列表中的元素类型可以混合，比如同一个列表里可以包含字符串、数字、其它列表甚至对象等各种类型。

示例：

# 下面是一些示例列表：
list1 = [10, 20, 30, 40]                  # 全是数字
list2 = ['apple', 'banana', 'orange']     # 全是字符串
list3 = ['spam', 2.0, 5, [10, 20]]        # 混合类型

2.2 列表的创建

直接创建：使用 [] 并用逗号分隔不同元素

list1 = ['Google', 'Baidu', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = []  # 创建一个空列表

使用 list() 函数：可以将可迭代对象（如字符串、元组等）转换为列表

# 例子：把字符串转换为列表
list_from_str = list("hello")  # 结果：['h', 'e', 'l', 'l', 'o']

# 例子：把元组转换为列表
tuple_data = (1, 2, 3)
list_from_tuple = list(tuple_data)  # 结果：[1, 2, 3]

2.3 列表的访问

索引访问

列表的索引从 0 开始
使用 [索引] 的方式可以访问对应位置的元素

list1 = ['Google', 'Baidu', 1997, 2000]
print(list1[0])    # 输出: 'Google'
print(list1[2])    # 输出: 1997

注意：如果索引超出范围，会出现 IndexError 错误。

切片访问

切片操作可以获取列表的一个子序列
语法：
```
list[起始索引 : 结束索引 : 步长]
```
- 起始索引默认值是 0
- 结束索引不包含在结果内
- 步长默认为 1

list2 = [1, 2, 3, 4, 5, 6, 7]
print(list2[1:5])   # 取索引1到4的元素 => [2, 3, 4, 5]
print(list2[:3])    # 从头取到索引2 => [1, 2, 3]
print(list2[::2])   # 每隔1个取1个 => [1, 3, 5, 7]
print(list2[-2:])   # 从倒数第二个元素开始，到末尾 => [6, 7]

更多切片用法后面会单独讲解。

2.4 列表的修改、添加和删除

修改元素：直接通过索引进行赋值

my_list = [10, 20, 30]
my_list[1] = 200
print(my_list)  # [10, 200, 30]

添加元素：

append(x): 在末尾追加元素 x
insert(i, x): 在指定索引 i 处插入元素 x
extend(iterable): 将另一个可迭代对象的元素追加到列表末尾

my_list = [1, 2, 3]
my_list.append(4)               # [1, 2, 3, 4]
my_list.insert(1, 100)          # [1, 100, 2, 3, 4]
my_list.extend([200, 300])      # [1, 100, 2, 3, 4, 200, 300]

删除元素：

del my_list[i]: 删除指定索引的元素
remove(x): 删除列表中第一个值为 x 的元素
pop(i=-1): 默认删除并返回最后一个元素，也可指定索引
clear(): 清空列表

my_list = [10, 20, 30, 40]
del my_list[0]      # 删除索引0 => [20, 30, 40]
my_list.remove(30)  # 删除值为30的元素 => [20, 40]
last_item = my_list.pop()  # pop最后一个元素 => last_item=40; 列表=[20]
my_list.clear()            # 清空列表 => []

2.5 列表运算符

拼接：使用

运算符可以拼接两个列表

a = [1, 2]
b = [3, 4]
print(a + b)  # [1, 2, 3, 4]

重复：使用

运算符可以将列表重复多次

a = [1, 2]
print(a * 3)  # [1, 2, 1, 2, 1, 2]

成员检查：使用

in

判断某元素是否在列表内

a = [1, 2, 3]
print(2 in a)  # True
print(4 in a)  # False

2.6 练习：列表切片

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
print('L[0:3] =', L[0:3])   # 取索引0到2
print('L[:3] =', L[:3])     # 从开头到索引2
print('L[1:3] =', L[1:3])   # 索引1到2
print('L[-2:] =', L[-2:])   # 倒数第二个到结束

三、元组（Tuple）

3.1 元组的特点

有序：和列表一样，元组中元素也有固定的顺序和索引。
不可变：元组的元素一旦定义好，就不能修改（不能增删改）。
定义使用小括号 () 来包裹元素，或直接用逗号分隔。

示例：

tup1 = ('Google', 'Baidu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = "a", "b", "c", "d"  # 不需要括号也可以

3.2 单元素元组的定义

tup1 = (50)
print(type(tup1))  # <class 'int'>，这里不是元组，而是整数

tup2 = (50,)
print(type(tup2))  # <class 'tuple'>，单元素元组需要在元素后面加逗号

3.3 访问与切片

与列表相同，可以通过索引 tup[i] 获取某个元素，也可以使用切片 tup[start:end] 获取部分元素
但不能修改元组元素！

tup = (1, 2, 3, 4, 5)
print(tup[0])      # 1
print(tup[1:3])    # (2, 3)

3.4 元组的拼接与删除

拼接：可以用

运算符来组合两个元组，从而生成一个新的元组

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2  # (12, 34.56, 'abc', 'xyz')

删除整个元组：元组不能删除其中某个元素，但可以用

del

删除整个元组

tup = ('Google', 'Baidu', 1997, 2000)
del tup
# 再次使用 tup 会报错，因为 tup 已被删除

四、字典（Dictionary）

4.1 字典的特点

无序：字典中的元素没有顺序。
可变：可随时修改、增加或删除键值对。
键-值对存储：使用 {} 作为定义，键和值之间以 : 分隔，多个键值对用 , 分隔。
键（Key）必须唯一 且 键必须是不可变类型（如字符串、数字或元组），值（Value）可以是任意类型并且可以重复。

示例：

dict1 = {'name': 'Alice', 'age': 25}
dict2 = {'abc': 123, 98.6: 37}  # key 可以是字符串或数字，但必须是不可变的

4.2 字典的访问

使用 dict_name[key] 访问对应的值
如果字典中没有这个键，会报错 KeyError

info = {'name': 'Tom', 'age': 20, 'city': 'Beijing'}
print(info['name'])   # Tom
print(info['age'])    # 20

4.3 字典的增删改

增加/修改：直接通过 键 赋值即可，没有该键会自动新增，有则修改

info['gender'] = 'male'    # 新增一个 key='gender'
info['age'] = 21           # 修改原有 key='age' 的值

删除：
- del info['name']: 删除键为 ‘name’ 的元素
- info.pop('age'): 弹出并返回 age 对应的值
- info.clear(): 清空字典
- del info: 删除整个字典对象

data = {'a': 1, 'b': 2, 'c': 3}
del data['a']         # 删掉 'a' 键
value_b = data.pop('b')
print(value_b)        # 2
print(data)           # {'c': 3}
data.clear()          # {}
del data             # 整个字典都被删除

五、集合（Set）

5.1 集合的特点

无序、不重复 的元素集合。
使用大括号 {} 表示，或者使用 set() 函数来创建。
可以对集合执行数学意义上的集合操作，如并集、交集、差集等。

# 创建集合
set1 = {1, 2, 3, 3, 2, 1}
print(set1)  # {1, 2, 3} 自动去重

set2 = set([2, 2, 3, 4])
print(set2)  # {2, 3, 4}

5.2 集合的常用操作

添加元素：add(item)
删除元素：remove(item)（不存在会报错），discard(item)（不存在不会报错）
并集：set1 | set2 或 set1.union(set2)
交集：set1 & set2 或 set1.intersection(set2)
差集：set1 - set2 或 set1.difference(set2)

s = {1, 2, 3}
s.add(4)         # {1, 2, 3, 4}
s.remove(2)      # {1, 3, 4}
# 并集
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)     # {1, 2, 3, 4, 5}
# 交集
print(a & b)     # {3}
# 差集
print(a - b)     # {1, 2}

六、切片（Slice）

在前面我们已经多次见到切片的用法，简单回顾一下：

对列表、元组、字符串 都适用
语法：[start:end:step]，从 start 索引开始取到 end-1 索引，每次移动步长 step
可以省略 start、end、step 来简化操作

示例：

R = list(range(100))    # [0, 1, 2, ..., 99]
print('R[:10] =', R[:10])     # 取前10个 => [0, 1, 2, ..., 9]
print('R[-10:] =', R[-10:])   # 取后10个 => [90, 91, ..., 99]
print('R[10:20] =', R[10:20]) # 取10~19
print('R[:10:2] =', R[:10:2]) # 前10个，每2个取1个 => [0, 2, 4, 6, 8]
print('R[::5] =', R[::5])     # 每5个取1个 => [0, 5, 10, 15, ..., 95]

八、总结

列表（List）：有序可变，使用 [ ]。能增删改查，灵活性高。
元组（Tuple）：有序不可变，使用 ( )。适合存储不需要修改的数据。
字典（Dictionary）：无序可变的键值对映射，使用 { }。通过键来访问值。
集合（Set）：无序、元素不重复，使用 { }，可做集合运算（并集、交集等）。
切片：适用于列表、元组、字符串等可序列化结构，功能强大。

第二章 Python 数据结构入门详解