Python 3常见的有6个标准的数据类型：

• 数字(Number)
• 字符串(String)
• 列表List)
• 元组(Tuple)
• 集合(Set)
• 字典(Dictionary)

一、序列

字符串、列表、元组属于序列，数字、集合、字典不属于序列。
在 Python 中，序列 (Sequence) 表示一组有序的元素集合。序列的特点是元素之间有明确的顺序，并且可以通过索引访问其中的元素。
Python 的序列类型具有以下共同特点：

• 有序性 ：元素按照一定的顺序排列。
• 可索引 ：支持通过索引（[]）访问单个元素。
• 可切片 ：支持通过切片操作（[:]）获取子序列。
• 可迭代 ：支持使用 for 循环遍历所有元素。

In [17]:

# 字符串是序列
# 定义一个字符串
s = "hello"

# 索引访问
print(s[0])  # 输出 'h'

# 切片操作
print(s[1:4])  # 输出 'ell'

# 迭代
for char in s:
    print(char)
# 输出：
# h
# e
# l
# l
# o

h
ell
h
e
l
l
o

二、可变和不可变数据类型

1. 可变数据类型(Mutable Types)

定义 ：
可变数据类型是指对象在创建后，其内容（值）可以在内存中原地修改，而无需创建新的对象。
特点：
修改对象的内容不会改变对象的内存地址。
常见的可变数据类型包括：

• 列表 (list)
• 字典 (dict)
• 集合 (set)

In [18]:

# 以列表示例可变数据类型
lst = [1, 2, 3]
print(id(lst))  # 输出列表的内存地址
lst.append(4)   # 修改列表内容
print(lst)      # 输出 [1, 2, 3, 4]
print(id(lst))  # 内存地址不变

# 字典示例
d = {"a": 1, "b": 2}
print(id(d))    # 输出字典的内存地址
d["c"] = 3      # 修改字典内容
print(d)        # 输出 {'a': 1, 'b': 2, 'c': 3}
print(id(d))    # 内存地址不变

1997492149504
[1, 2, 3, 4]
1997492149504
1997498385856
{'a': 1, 'b': 2, 'c': 3}
1997498385856

2. 不可变数据类型 (Immutable Types)

定义 ：
不可变数据类型是指对象在创建后，其内容（值）不能被修改。如果需要修改对象的值，实际上是创建了一个新的对象。
特点：
修改对象的内容会生成一个新的对象，并分配新的内存地址。
常见的不可变数据类型包括：

• 数字类型 (int, float)
• 字符串 (str)
• 元组 (tuple)

In [19]:

# 字符串示例
s = "hello"
print(id(s))  # 输出字符串的内存地址
s = s + " world"  # 修改字符串内容
print(s)      # 输出 "hello world"
print(id(s))  # 内存地址改变

# 元组示例
t = (1, 2, 3)
print(id(t))  # 输出元组的内存地址
t = t + (4,)  # 修改元组内容
print(t)      # 输出 (1, 2, 3, 4)
print(id(t))  # 内存地址改变

1997488364528
hello world
1997498396912
1997492147008
(1, 2, 3, 4)
1997498035520

三、列表

1. 学习目标

理解列表类型的概念，掌握它的基础用法。

2. 什么是列表

列表 (List) 是一种内置的、有序的、可变的数据结构，用于存储一组元素。
列表是 Python 中最常用的数据类型之一，因为它非常灵活，可以存储任意类型的元素（如数字、字符串、其他列表等），并且支持动态修改。

3. 列表的特点

以下是列表的核心特性：
(1) 有序性
列表中的元素按照插入顺序排列。
每个元素都有一个固定的索引位置（从 0 开始）。
(2) 可变性
列表是可变的，意味着可以在原地修改其内容（添加、删除或更改元素）。
修改列表时不会创建新的对象，而是直接在内存中操作。
(3) 支持多种数据类型
列表可以包含不同类型的元素（如整数、浮点数、字符串、甚至其他列表）。

In [ ]:

mixed_list = [1, "hello", 3.14, [True, False]]

(4) 动态大小
列表的长度是动态的，可以根据需要增加或减少元素。

4. 列表的定义

列表使用方括号[]定义，元素之间用逗号,分隔。

In [ ]:

# 空列表
empty_list = []

# 包含整数的列表
numbers = [1, 2, 3, 4]

# 包含字符串的列表
fruits = ["apple", "banana", "cherry"]

# 包含不同类型元素的列表
mixed = [1, "hello", 3.14, True]

5. 使用 list() 创建列表

list() 是 Python 的内置函数，用于将可迭代对象（如字符串、元组、集合、字典等）转换为列表。如果没有提供参数，list() 会返回一个空列表。

In [20]:

#(1) 创建空列表
empty_list = list()
print(empty_list)  # 输出 []

#(2) 将字符串转换为列表
s = "hello"
lst = list(s)
print(lst)  # 输出 ['h', 'e', 'l', 'l', 'o']

#将元组转换为列表
t = (1, 2, 3)
lst = list(t)
print(lst)  # 输出 [1, 2, 3]

[]
['h', 'e', 'l', 'l', 'o']
[1, 2, 3]

6. 列表的访问（通用）

说明:标记了通用的操作对所有属于序列的类型都是有效的，如对字符串、列表、元组等都可以使用相关操作。

列表中的每个元素都有一个唯一的索引位置，索引从 0 开始。Python 还支持负数索引，表示从列表末尾开始计数。
(1) 正向索引
正向索引从 0 开始，依次递增。

In [21]:

lst = [10, 20, 30, 40, 50]

# 访问第一个元素
print(lst[0])  # 输出 10

# 访问第三个元素
print(lst[2])  # 输出 30

10
30

(2) 反向索引
反向索引从 -1 开始，依次递减。

In [22]:

lst = [10, 20, 30, 40, 50]

# 访问最后一个元素
print(lst[-1])  # 输出 50

# 访问倒数第三个元素
print(lst[-3])  # 输出 30

50
30

7. 列表嵌套（通用）

列表可以包含其他列表，形成嵌套结构。这种嵌套结构非常适合表示多维数据，例如矩阵或表格。
示例：二维列表

In [23]:

matrix = [
    [1, 2, 3],  # 第一行
    [4, 5, 6],  # 第二行
    [7, 8, 9]   # 第三行
]

# 访问第一行
print(matrix[0])       # 输出 [1, 2, 3]

# 访问第二行的第三个元素
print(matrix[1][2])    # 输出 6

[1, 2, 3]
6

8. 切片操作（通用）

切片用于获取列表的子集，语法为 [start:end:step]，其中：

• start 是起始索引（包含），如果从第1个元素开始，可以为空。
• end 是结束索引（不包含），如果切片到最后一个元素，可以为空。
• step 是步长，默认为 1。

(1) 基本切片

In [24]:

lst = [10, 20, 30, 40, 50]

# 获取索引 1 到 3 的元素
print(lst[1:4])  # 输出 [20, 30, 40]

# 获取前三个元素
print(lst[:3])   # 输出 [10, 20, 30]

# 获取最后两个元素
print(lst[-2:])  # 输出 [40, 50]

[20, 30, 40]
[10, 20, 30]
[40, 50]

(2) 使用步长
步长决定了选取元素的间隔。默认步长为 1，可以设置为负值以实现反向切片。

In [25]:

lst = [10, 20, 30, 40, 50]

# 每隔一个元素取一次
print(lst[::2])  # 输出 [10, 30, 50]

# 反向切片
print(lst[::-1])  # 输出 [50, 40, 30, 20, 10]

[10, 30, 50]
[50, 40, 30, 20, 10]

注意事项

• 切片不会修改原列表，而是返回一个新的列表。
• 如果切片超出范围，不会抛出异常，而是返回尽可能多的元素。

In [26]:

# 定义一个原始列表
original_list = [1, 2, 3, 4, 5]

# 使用切片获取子列表
sliced_list = original_list[1:4]  # 获取索引 1 到 3 的元素（不包括索引 4）
print("原列表:", original_list)  # 输出原列表，未被修改
print("切片结果:", sliced_list)  # 输出切片结果

# 超出范围的切片操作
out_of_range_slice = original_list[3:10]  # 切片范围超出了列表长度
print("超出范围的切片结果:", out_of_range_slice)  # 返回尽可能多的元素

原列表: [1, 2, 3, 4, 5]
切片结果: [2, 3, 4]
超出范围的切片结果: [4, 5]

9.len()-获取列表长度（通用）

使用内置函数 len() 获取列表的长度（即元素的数量）。

In [27]:

lst = [10, 20, 30, 40, 50]
print(len(lst))  # 输出 5

5

10.in-检查元素是否包含在列表中（通用）

in 操作用于检查某个元素是否存在于列表中，返回布尔值。

In [28]:

lst = [10, 20, 30, 40, 50]

# 检查元素是否存在
print(20 in lst)  # 输出 True
print(60 in lst)  # 输出 False

True
False

11.max()和min()- 找出列表中的最大值和最小值（通用）

max() 和 min() 分别用于获取列表中的最大值和最小值。

注意事项

• 列表中的元素必须是同一类型（如都是数字或都是字符串），否则会抛出 TypeError。

In [29]:

lst = [10, 20, 30, 40, 50]

print(max(lst))  # 输出 50
print(min(lst))  # 输出 10

mixed_list = [10, "20", 30]
print(max(mixed_list))  # TypeError: '>' not supported between instances of 'str' and 'int'

50
10

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[29], line 7
      4 print(min(lst))  # 输出 10
      6 mixed_list = [10, "20", 30]
----> 7 print(max(mixed_list))  # TypeError: '>' not supported between instances of 'str' and 'int'

TypeError: '>' not supported between instances of 'str' and 'int'

• 如果元素是字符串，是按Unicode编码的顺序判断大小。

In [30]:

# 定义一个包含中文、英文和特殊字符的字符串列表
string_list = ["apple", "banana", "cherry", "苹果", "香蕉", "樱桃", "123", "!@#"]

# 使用 max() 获取最大值
max_value = max(string_list)

# 输出结果
print("字符串列表:", string_list)
print("最大值:", max_value)

# 解释 Unicode 编码顺序
print("\n每个字符串的首字符及其 Unicode 码点值:")
for s in string_list:
    print(f"'{s}': 首字符 '{s[0]}' -> Unicode 码点值 {ord(s[0])}")

字符串列表: ['apple', 'banana', 'cherry', '苹果', '香蕉', '樱桃', '123', '!@#']
最大值: 香蕉

每个字符串的首字符及其 Unicode 码点值:
'apple': 首字符 'a' -> Unicode 码点值 97
'banana': 首字符 'b' -> Unicode 码点值 98
'cherry': 首字符 'c' -> Unicode 码点值 99
'苹果': 首字符 '苹' -> Unicode 码点值 33529
'香蕉': 首字符 '香' -> Unicode 码点值 39321
'樱桃': 首字符 '樱' -> Unicode 码点值 27185
'123': 首字符 '1' -> Unicode 码点值 49
'!@#': 首字符 '!' -> Unicode 码点值 33

12.sum()- 列表求和运算（通用）

sum() 用于对列表中的所有元素求和。

注意事项

• 列表中的元素必须是数值类型（如整数或浮点数）。
• 如果列表为空，sum([]) 返回 0。

In [31]:

lst = [10, 20, 30, 40, 50]
print(sum(lst))  # 输出 150

# 定义一个空列表
empty_list = []

# 使用 sum() 计算空列表的总和
result = sum(empty_list)

# 输出结果
print("空列表:", empty_list)
print("sum([]) 的结果:", result)

150
空列表: []
sum([]) 的结果: 0

13. 列表的加法运算（通用）

使用 + 运算符连接两个列表，生成一个新的列表。

注意事项

• 加法运算不会修改原列表，而是返回一个新的列表。

In [32]:

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]

result = lst1 + lst2
print(result)  # 输出 [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6]

14. 列表的乘法运算（通用）

使用 * 运算符重复列表中的元素。
与正整数相乘，代表将列表重复相应的次数。

In [33]:

lst = [1, 2, 3]

result = lst * 3
print(result)  # 输出 [1, 2, 3, 1, 2, 3, 1, 2, 3]

[1, 2, 3, 1, 2, 3, 1, 2, 3]

15. 更新元素的值

通过索引直接修改列表中的元素。

注意事项

• 如果索引超出范围，会抛出 IndexError。

In [34]:

lst = [10, 20, 30, 40, 50]

# 修改第一个元素
lst[0] = 100
print(lst)  # 输出 [100, 20, 30, 40, 50]

[100, 20, 30, 40, 50]

16. 删除元素

有多种方法可以删除列表中的元素。

(1) 使用del关键字

del 的基本用法

1. 删除单个元素
   使用索引删除列表中指定位置的元素。
2. del list[index]
3. 删除多个元素（切片）
   使用切片语法删除一段连续的元素。
4. del list[start:end]
5. 删除整个列表
   直接删除整个列表变量。
6. del list

In [35]:

# 定义一个初始列表
my_list = [10, 20, 30, 40, 50, 60]

# 1. 删除单个元素（通过索引）
print("原始列表:", my_list)
del my_list[2]  # 删除索引为 2 的元素（值为 30）
print("删除索引 2 后的列表:", my_list)

# 2. 删除多个元素（通过切片）
del my_list[1:4]  # 删除索引 1 到 3 的元素（不包括索引 4）
print("删除切片 [1:4] 后的列表:", my_list)

# 3. 删除整个列表
del my_list
try:
    print(my_list)  # 尝试访问已删除的列表
except NameError as e:
    print("错误:", e)  # 输出: 错误: name 'my_list' is not defined

原始列表: [10, 20, 30, 40, 50, 60]
删除索引 2 后的列表: [10, 20, 40, 50, 60]
删除切片 [1:4] 后的列表: [10, 60]
错误: name 'my_list' is not defined

(2) 使用remove()方法

remove() 删除指定值的第一个匹配项。

In [36]:

lst = [10, 20, 30, 40, 50]

# 删除值为 30 的元素
lst.remove(30)
print(lst)  # 输出 [10, 20, 40, 50]

[10, 20, 40, 50]

(3) 使用pop()方法

pop() 删除并返回指定索引处的元素。
如果没有指定索引，默认删除最后一个元素。

In [37]:

lst = [10, 20, 30, 40, 50]

# 删除最后一个元素
last_element = lst.pop()
print(last_element)  # 输出 50
print(lst)           # 输出 [10, 20, 30, 40]

# 删除索引为 1 的元素
removed_element = lst.pop(1)
print(removed_element)  # 输出 20
print(lst)              # 输出 [10, 30, 40]

50
[10, 20, 30, 40]
20
[10, 30, 40]

(4) 使用clear()方法

clear() 是列表的一个方法，用于清空列表中的所有元素。调用 clear() 后，列表将变为空列表（即 []），但列表对象本身仍然存在。

In [38]:

# 定义一个初始列表
my_list = [10, 20, 30, 40, 50]

# 打印原始列表
print("原始列表:", my_list)

# 使用 clear() 清空列表
my_list.clear()

# 打印清空后的列表
print("清空后的列表:", my_list)

# 验证列表是否为空
print("列表是否为空:", len(my_list) == 0)

原始列表: [10, 20, 30, 40, 50]
清空后的列表: []
列表是否为空: True

17. 添加元素

有多种方法可以向列表中添加元素。

(1) 使用append()方法

append() 在列表末尾添加一个元素。

In [39]:

lst = [10, 20, 30]

lst.append(40)
print(lst)  # 输出 [10, 20, 30, 40]

[10, 20, 30, 40]

(2) 使用extend()方法

extend() 将另一个可迭代对象的所有元素添加到列表末尾。

常见的可迭代对象包括：

1. 序列类型: 列表、元组、字符串、范围对象(range)。
2. 映射类型: 字典。
3. 集合类型: 集合。
4. 文件对象。

In [40]:

lst = [10, 20, 30]

lst.extend([40, 50])
print(lst)  # 输出 [10, 20, 30, 40, 50]

[10, 20, 30, 40, 50]

(3) 使用insert()方法

insert() 在指定索引处插入一个元素。

In [41]:

lst = [10, 20, 30]

lst.insert(1, 15)
print(lst)  # 输出 [10, 15, 20, 30]

[10, 15, 20, 30]

13. 查找元素

index() 和 count() 是列表的两个方法，分别用于查找指定值的索引和统计指定值出现的次数。

(1)index()方法

功能

• 返回列表中第一个匹配元素的索引。
• 如果指定值不存在于列表中，则抛出 ValueError 异常。

语法

list.index(value, start=0, end=len(list))

• 参数:value: 要查找的值。start（可选）: 指定从哪个索引开始查找，默认为 0。end（可选）: 指定查找到哪个索引结束（不包括该索引），默认为列表长度。

In [42]:

# 定义一个列表
my_list = [10, 20, 30, 40, 20, 50]

# 查找第一个匹配的索引
print("第一个 20 的索引:", my_list.index(20))  # 输出: 1

# 在指定范围内查找
print("从索引 2 开始查找 20 的索引:", my_list.index(20, 2))  # 输出: 4

# 查找不存在的值
try:
    print(my_list.index(60))  # 抛出 ValueError
except ValueError as e:
    print("错误:", e)  # 输出: 错误: 60 is not in list

第一个 20 的索引: 1
从索引 2 开始查找 20 的索引: 4
错误: 60 is not in list

(2)count()方法

功能

• 返回列表中指定值出现的次数。
• 如果值不存在，返回 0。

语法

list.count(value)

• 参数:value: 要统计的值。

In [43]:

# 定义一个列表
my_list = [10, 20, 30, 40, 20, 50]

# 统计指定值的出现次数
print("20 出现的次数:", my_list.count(20))  # 输出: 2
print("60 出现的次数:", my_list.count(60))  # 输出: 0

20 出现的次数: 2
60 出现的次数: 0

14. 排序

列表的排序可以通过两种主要方法实现：sort() 方法 和 sorted() 函数。这两种方式都可以对列表进行升序或降序排序，并支持自定义排序规则。

(1) 使用sort()方法

功能

• 就地排序：直接修改原列表，不返回新的列表。
• 支持升序和降序排序。
• 可以通过关键字参数 key 和 reverse 自定义排序规则。

语法

list.sort(key=None, reverse=False)

• 参数:key（可选）: 指定一个函数，用于从每个元素中提取排序依据。默认为 None。reverse（可选）: 布尔值，指定是否按降序排序。默认为 False（升序）。

注意事项

sort() 直接修改原列表，不会返回新的列表。如果需要保留原列表，可以先复制列表：

sorted_list = my_list.copy()
sorted_list.sort()

In [44]:

# 定义一个列表
my_list = [5, 2, 9, 1, 7]

# 升序排序
my_list.sort()
print("升序排序后的列表:", my_list)  # 输出: [1, 2, 5, 7, 9]

# 降序排序
my_list.sort(reverse=True)
print("降序排序后的列表:", my_list)  # 输出: [9, 7, 5, 2, 1]

# 自定义排序规则（按绝对值排序）
my_list = [-3, 1, -2, 4]
my_list.sort(key=abs)
print("按绝对值排序后的列表:", my_list)  # 输出: [1, -2, -3, 4]

升序排序后的列表: [1, 2, 5, 7, 9]
降序排序后的列表: [9, 7, 5, 2, 1]
按绝对值排序后的列表: [1, -2, -3, 4]

(2) 使用sorted()函数

功能

• 返回新列表：不会修改原列表，而是返回一个新的排序后的列表。
• 支持升序和降序排序。
• 同样可以通过 key 和 reverse 参数自定义排序规则。

语法

sorted(iterable, key=None, reverse=False)

• 参数:iterable: 要排序的可迭代对象（如列表、元组等）。key 和 reverse 的作用与 sort() 方法相同。

In [45]:

# 定义一个列表
my_list = [5, 2, 9, 1, 7]

# 升序排序
sorted_list = sorted(my_list)
print("升序排序后的新列表:", sorted_list)  # 输出: [1, 2, 5, 7, 9]
print("原列表未被修改:", my_list)         # 输出: [5, 2, 9, 1, 7]

# 降序排序
sorted_list_desc = sorted(my_list, reverse=True)
print("降序排序后的新列表:", sorted_list_desc)  # 输出: [9, 7, 5, 2, 1]

# 自定义排序规则（按字符串长度排序）
words = ["apple", "banana", "cherry", "kiwi"]
sorted_words = sorted(words, key=len)
print("按字符串长度排序后的新列表:", sorted_words)  # 输出: ['kiwi', 'apple', 'banana', 'cherry']

升序排序后的新列表: [1, 2, 5, 7, 9]
原列表未被修改: [5, 2, 9, 1, 7]
降序排序后的新列表: [9, 7, 5, 2, 1]
按字符串长度排序后的新列表: ['kiwi', 'apple', 'banana', 'cherry']

注意

sort() 方法 和 sorted() 函数默认只支持相同元素类型的列表进行排序
如果一个列表中同时包含数值（如整数或浮点数）和字符串，直接使用 sort() 或 sorted() 对这些元素进行排序时抛出 TypeError 异常。

解决方案
为了解决这个问题，可以通过自定义排序元则对混合类型的列表进行排序。

自定义排序规则
使用 key 参数指定一个函数，将所有元素转换为字符串。

In [46]:

# 定义一个混合类型的列表
my_list = [3, "apple", 1, "banana", 2.5]

# 使用 key 参数：将所有元素转换为字符串排序
my_list.sort(key=str)
print("按字符串形式排序:", my_list)  # 输出: [1, 2.5, 3, 'apple', 'banana']

按字符串形式排序: [1, 2.5, 3, 'apple', 'banana']