揭秘Python数据类型：字符串、列表、字典和元组的高效操作指南


参考资源链接：[传智播客&黑马程序员PYTHON教程课件汇总](https://wenku.csdn.net/doc/6412b749be7fbd1778d49c25?spm=1055.2635.3001.10343)
# 1. Python基础数据类型的概述

Python作为一门高级编程语言，其内置的多种数据类型为程序员提供了强大的工具。本章将带领读者了解Python的基础数据类型，为深入理解后续章节内容打下坚实基础。

## 1.1 Python数据类型概述

Python中的数据类型主要分为两大类：基本数据类型和复合数据类型。基本数据类型包括数字类型（如整数、浮点数和复数）、字符串（用于文本处理）以及布尔类型（表示真或假）。复合数据类型则涉及列表、元组、字典和集合，它们能够容纳多个元素并具有特定的结构。

## 1.2 变量和数据类型的动态赋值

在Python中，变量无需声明类型即可赋值。这一特性大大简化了编程过程，但开发者需要了解变量在赋值时采用的数据类型。例如：

age = 25            # 整型
height = 175.5      # 浮点型
is_student = True   # 布尔型
name = "Alice"      # 字符串

## 1.3 数据类型的选择和使用

选择合适的数据类型对于代码的效率和可读性至关重要。例如，在处理一系列可变数据时，列表会是更合适的选择；而在需要保证数据唯一性和不变性时，集合或元组可能是更好的选择。本章将对这些数据类型进行详细解读，旨在帮助读者在实际应用中做出更明智的选择。

随着章节的深入，我们将逐一探索每种数据类型的具体用法，掌握它们在实际编程中的应用技巧，为编写高效、优雅的Python代码奠定坚实的基础。

# 2. 字符串的高级操作技巧

字符串是编程中不可或缺的数据类型，尤其在文本处理、数据分析等领域发挥着巨大作用。深入掌握字符串的操作技巧，不仅可以提高代码的效率，还能优化性能和提升用户体验。本章将分几个小节介绍字符串的高级操作技巧，从基础操作到高级用例，旨在帮助读者全面理解和运用Python中的字符串处理技术。

## 2.1 字符串的基本操作

字符串的创建和格式化是任何字符串处理任务的起点。了解如何正确地创建字符串，并使用格式化技术来构建复杂的字符串是至关重要的。

### 2.1.1 字符串的创建和格式化

在Python中，创建字符串非常简单，只需将文本值赋给一个变量即可。格式化字符串则提供了更多灵活性，允许开发者将变量和表达式的值嵌入到字符串中。

# 创建字符串
greeting = "Hello, World!"
print(greeting)

# 使用.format()方法进行字符串格式化
name = "Alice"
age = 30
formatted_string = "My name is {} and I am {} years old.".format(name, age)
print(formatted_string)

# 使用f-string进行格式化（Python 3.6+）
age += 1
formatted_string_f = f"My name is {name} and I will be {age} years old next month."
print(formatted_string_f)

在上述代码中，我们创建了一个简单的问候字符串，并使用了`.format()`方法和f-string语法来格式化包含变量的字符串。f-string提供了一种更加简洁和易读的格式化方式，因此在支持的Python版本中推荐使用。

### 2.1.2 字符串的索引和切片

字符串的索引和切片是进行字符串操作的基础，它们允许访问字符串中的单个字符或字符序列。

text = "Python is awesome"

# 索引：通过索引访问字符串中的单个字符
first_char = text[0]  # 'P'
print(first_char)

# 切片：通过切片获取字符子串
substring = text[0:6]  # 'Python'
print(substring)

# 使用负索引从字符串末尾开始访问
last_char = text[-1]  # 'e'
print(last_char)

# 使用步长进行切片，如每隔一个字符
every_other_char = text[::2]  # 'Pto sas'
print(every_other_char)

通过索引和切片，我们可以灵活地处理字符串中的数据。例如，可以通过切片快速提取字符串中的特定部分，或者使用负索引从末尾开始操作。步长切片则提供了进一步的数据抽取功能，这在文本数据预处理中十分有用。

## 2.2 字符串的常用方法和函数

Python提供了大量内置方法和函数，以支持字符串处理的不同方面。了解和熟练应用这些方法和函数，能够极大提升开发效率。

### 2.2.1 常见字符串操作方法

字符串对象提供了许多方法来执行各种常见的字符串操作。这些方法可以分为几类，比如大小写转换、查找和替换、去除空白字符等。

# 大小写转换
original = "Python"
upper_text = original.upper()  # 'PYTHON'
lower_text = original.lower()  # 'python'

# 查找子字符串
index = original.find("th")  # 3

# 替换子字符串
replaced_text = original.replace("o", "*")  # 'Pyth*n'

# 去除空白字符
text_with_space = "  Hello, World!  "
trimmed_text = text_with_space.strip()  # 'Hello, World!'

在上述代码示例中，我们展示了字符串操作的一些常用方法。`upper()`和`lower()`用于转换字符串的大小写，`find()`用于查找子字符串的位置，`replace()`用于替换字符串中的字符，`strip()`用于去除字符串首尾的空白字符。

### 2.2.2 正则表达式在字符串中的应用

正则表达式提供了一种强大而灵活的方式来搜索、匹配和处理字符串中的模式。在Python中，正则表达式由`re`模块支持。

import re

# 搜索模式
text = "The rain in Spain stays mainly in the plain"
match = re.search("Spain", text)
if match:
    print("Found 'Spain' at index", match.start())

# 替换模式
replaced_text = re.sub("Spain", "Italy", text)

# 分割字符串
parts = re.split(",\s*", text)  # Split by commas and whitespace

# 编译正则表达式以提高性能
pattern = re.compile(r"Spain")
match = pattern.search(text)
if match:
    print("Found 'Spain' using compiled pattern at index", match.start())

在这个例子中，我们使用了`re.search()`来查找特定模式的字符串，`re.sub()`来替换匹配的模式，以及`re.split()`来分割字符串。此外，我们还展示了如何编译正则表达式以提高匹配和搜索的效率。这些操作对于复杂的文本处理任务，比如文本清洗和自然语言处理，是不可或缺的。

## 2.3 字符串处理的高级用例

字符串处理的高级用例涉及到更复杂的场景，比如文本清洗、自然语言处理等。这些用例通常需要结合多种字符串操作方法，并利用正则表达式等高级技术。

### 2.3.1 文本清洗和预处理

在进行数据分析之前，文本数据通常需要经过清洗和预处理，以确保数据的质量和分析的准确性。常见的预处理步骤包括去除标点符号、数字、空白、统一字符大小写等。

import string

# 原始文本数据
text = "Python 3.8, is awesome! Don't you think? 12345"

# 移除标点符号
punctuation_table = str.maketrans('', '', string.punctuation)
cleaned_text = text.translate(punctuation_table)

# 移除数字
cleaned_text = ''.join(filter(lambda x: not x.isdigit(), cleaned_text))

# 统一字符大小写
cleaned_text = cleaned_text.lower()

print(cleaned_text)

在这段代码中，我们首先使用`str.maketrans`和`translate`方法去除所有标点符号，然后使用`filter`和`lambda`函数移除数字，最后将所有字符转换为小写。这样的预处理步骤在进行文本分析前是常见的操作。

### 2.3.2 自然语言处理中的字符串操作

在自然语言处理（NLP）任务中，如文本分类、情感分析等，字符串操作扮演着核心角色。这类任务通常需要使用正则表达式来处理复杂的文本格式，并进行词干提取、词性标注等操作。

# 示例：使用NLTK库进行分词
import nltk
nltk.download('punkt')
from nltk.tokenize import word_tokenize

# 一个复杂的文本句子
sentence = "NLTK is a leading platform for building Python programs to work with human language data."

# 使用NLTK进行分词
tokens = word_tokenize(sentence)

print(tokens)

在这个例子中，我们使用了NLTK库中的`word_tokenize`函数进行分词处理。这是NLP中最基础的步骤之一，它将句子拆分为单词或词汇单元。分词是后续许多NLP任务，如词性标注、命名实体识别的基础。

在本章中，我们介绍了字符串的高级操作技巧，包括基本操作、常用方法和函数、以及高级用例的实现。掌握这些技巧对于处理文本数据、进行数据分析和执行自然语言处理等任务至关重要。字符串是Python编程中的基石，深入理解并灵活运用字符串操作将显著提升开发者的技能水平和工作效率。

# 3. 列表和元组的综合应用

在本章中，我们深入探讨Python中的列表（List）和元组（Tuple），这两种都是序列类型，但有本质的区别。列表是可变的，支持元素的添加、删除和替换，而元组则是不可变的，一旦创建就不能修改。这些特点使得它们在不同的场景下有不同的应用和优势。

## 3.1 列表的创建和管理

### 3.1.1 列表的基本操作

列表是Python中最常用的复合数据类型之一，它允许包含任意类型的元素，并且可以动态地进行修改。创建列表非常简单，可以使用方括号`[]`包含一系列用逗号分隔的元素。

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

列表支持多种操作，包括添加、删除、访问和修改元素。

# 添加元素到列表末尾
my_list.append(6)

# 在指定位置插入元素
my_list.insert(0, 'start')

# 删除指定元素
my_list.remove(2)

# 删除并返回指定位置的元素
popped_element = my_list.pop(2)

# 访问指定位置的元素
element_at_index_2 = my_list[2]

# 修改指定位置的元素
my_list[1] = 'two'

### 3.1.2 列表的增删改查技巧

列表的增删改查操作是其最核心的功能，通过这些操作可以实现对数据的灵活处理。

#### 列表的增加

- `append(x)`: 在列表末尾添加一个元素。
- `extend(iterable)`: 将一个可迭代对象的所有元素添加到列表末尾。
- `insert(i, x)`: 在指定位置`i`前插入一个元素`x`。

my_list = [1, 2, 3]
my_list.append(4)  # 结果: [1, 2, 3, 4]
my_list.extend([5, 6])  # 结果: [1, 2, 3, 4, 5, 6]
my_list.insert(0, 'start')  # 结果: ['start', 1, 2, 3, 4, 5, 6]

#### 列表的删除

- `remove(x)`: 删除列表中第一个值为`x`的元素。
- `pop([i])`: 删除指定位置`i`的元素，并返回它。
- `clear()`: 清空列表中的所有元素。

my_list.pop(1)  # 结果: ['start', 2, 3, 4, 5, 6]
my_list.remove(4)  # 结果: ['start', 2, 3, 5, 6]
my_list.clear()  # 结果: []

#### 列表的修改

修改列表通常通过索引来实现：

my_list = [1, 2, 3, 4, 5]
my_list[2] = 30  # 结果: [1, 2, 30, 4, 5]

#### 列表的查询

- `index(x[, start[, end]])`: 返回列表中第一个值为`x`的元素的索引。
- `count(x)`: 返回`x`在列表中出现的次数。

my_list = [1, 2, 30, 4, 5, 30]
index_of_30 = my_list.index(30)  # 结果: 2
count_of_30 = my_list.count(30)  # 结果: 2

### 3.1.2 列表的增删改查技巧（续）

在处理列表时，常常需要对元素进行排序和反转，Python为这些操作提供了简洁的方法：

# 排序
my_list.sort()  # 就地排序
sorted_list = sorted(my_list)  # 返回一个新的排序后的列表

# 反转
my_list.reverse()  # 就地反转
reversed_list = my_list[::-1]  # 通过切片方式得到反转列表

列表还支持切片操作，这是一种访问序列的子序列的方式：

sliced_list = my_list[1:4]  # 获取从索引1到3的子列表

在实际应用中，列表的这些操作是非常基础且重要的。通过列表操作，可以处理各种复杂的数据结构，并且根据实际需求进行灵活的调整。

## 3.2 元组的不可变性和应用

### 3.2.1 元组的创建和使用场景

元组是另一种序列类型，和列表类似，但是元组的元素是不可变的，也就是说，创建后无法修改。创建元组使用圆括号`()`。

my_tuple = (1, 2, 3)

元组通常用于以下场景：

- **函数返回多个值**：元组可以存储函数返回的多个值。
- **作为字典的键**：元组是不可变的，可以作为字典的键使用。
- **存储异构数据**：元组可以存储不同类型的数据，而列表通常存储相同类型的数据。

# 函数返回元组
def return_multiple_values():
    return 1, 'a', 2.5

# 使用元组作为字典键
dict_with_tuple_key = {(1, 2): 'value'}

# 存储异构数据的元组
heterogeneous_tuple = ('string', 123, True, [1, 2, 3])

### 3.2.2 元组与列表的性能比较

由于元组的不可变性，它在某些方面比列表更高效：

- **内存使用**：元组通常比列表消耗更少的内存。
- **访问速度**：元组的索引访问速度通常比列表快。

但是，元组的不可变性也意味着在某些操作上不如列表灵活。例如，如果需要在序列中间插入或删除元素，列表的可变性就显得更加高效。

## 3.3 列表和元组的高级操作

### 3.3.1 多维列表和元组的处理

列表和元组可以嵌套使用，形成多维的数据结构。这在处理复杂数据时非常有用。

# 多维列表
two_dimensional_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# 多维元组
two_dimensional_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

处理多维列表和元组时，需要注意索引的嵌套使用：

# 访问多维列表中特定元素
element = two_dimensional_list[1][2]  # 结果: 6

# 访问多维元组中特定元素
element = two_dimensional_tuple[1][2]  # 结果: 6

### 3.3.2 列表推导式和生成器表达式

列表推导式（List Comprehension）是Python中一种简洁且功能强大的构建列表的方法。它提供了一种简单的方式来创建列表，而不需要使用循环。

# 列表推导式示例
squares = [x * x for x in range(10)]  # 结果: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

生成器表达式（Generator Expression）和列表推导式类似，但是它返回一个生成器对象，而不是直接构建一个完整的列表。这对于处理大量数据时可以节省内存。

# 生成器表达式示例
squares_generator = (x * x for x in range(10))
for val in squares_generator:
    print(val)

列表推导式和生成器表达式在处理数据集合时，可以大幅简化代码并提高效率。它们是编写高效Python代码的重要工具之一。

通过以上内容，我们对列表和元组的综合应用有了深入的理解。在实际编程中，能够根据数据的特点和需求，选择合适的类型并运用各种高级技巧，将极大地提高开发效率和代码质量。

# 4. 字典和集合的深入操作

## 4.1 字典的键值对管理
### 4.1.1 字典的基本操作

字典是Python中一种非常重要的数据结构，它以键值对（key-value pairs）的形式存储数据。键必须是唯一的，而值则可以是任何数据类型。字典的创建和基本操作是理解更高级概念的基础。

在Python中，创建字典非常简单，可以通过花括号 `{}` 来实现，或者使用内置的 `dict()` 函数。字典的键必须是不可变类型，如字符串、数字或元组。

# 使用花括号创建字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(person)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用dict函数创建字典
another_person = dict(name='Bob', age=30)
print(another_person)  # 输出: {'name': 'Bob', 'age': 30}

访问字典中的元素可以使用方括号 `[]`，并提供键名：

print(person['name'])  # 输出: Alice

如果尝试访问一个不存在的键，将会抛出 `KeyError`。为了避免这种情况，可以使用 `.get()` 方法，它允许你为不存在的键指定一个默认值：

print(person.get('gender', 'Unknown'))  # 输出: Unknown

字典可以进行迭代，迭代的是键：

for key in person:
    print(key, person[key])

此外，字典还提供了一系列内置方法，如 `.keys()`, `.values()`, `.items()` 等，用于获取字典的不同视图。

### 4.1.2 字典推导式和常用方法

字典推导式是Python中一种优雅且高效地创建字典的方式，类似于列表推导式。它们可以快速生成字典，并在过程中执行各种操作。

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

字典还包含了许多有用的方法，例如：

- `.update()`: 更新字典中的元素
- `.pop()`: 删除字典中的元素，并返回它的值
- `.popitem()`: 随机删除并返回字典中的键值对
- `.clear()`: 清空字典中的所有元素

# 更新字典
squares.update({5: 25, 6: 36})
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

# 删除键为'1'的元素
squares.pop(1)
print(squares)  # 输出: {0: 0, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

# 清空字典
squares.clear()
print(squares)  # 输出: {}

这些方法使得字典的操作变得更为灵活和强大，进一步的探索将帮助开发者利用这些工具解决复杂的编程问题。

## 4.2 集合的去重和运算操作
### 4.2.1 集合的基本用法

集合（Set）是一个无序的不重复元素序列。集合可以用于去重和进行数学运算，如并集、交集、差集等。

集合的创建同样可以使用花括号 `{}`，不过集合中存储的是无序的、不重复的元素：

fruits = {'apple', 'banana', 'cherry'}
print(fruits)  # 输出: {'banana', 'apple', 'cherry'}

集合是可变的，可以添加和删除元素：

fruits.add('orange')
print(fruits)  # 输出: {'banana', 'apple', 'cherry', 'orange'}

fruits.remove('banana')
print(fruits)  # 输出: {'apple', 'cherry', 'orange'}

集合之间的运算可以使用 `|`（并集）、`&`（交集）、`-`（差集）、`^`（对称差集）等运算符：

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

print(a | b)  # 输出: {1, 2, 3, 4, 5, 6}
print(a & b)  # 输出: {3, 4}
print(a - b)  # 输出: {1, 2}
print(a ^ b)  # 输出: {1, 2, 5, 6}

集合同样提供了 `.union()`, `.intersection()`, `.difference()`, `.symmetric_difference()` 等方法，与运算符相对应。

## 4.3 字典和集合的高效算法
### 4.3.1 常见数据结构问题的字典解法

在处理数据结构问题时，字典常常可以提供高效的解决方案。例如，我们可以使用字典来统计每个元素的出现次数，这样可以将原本线性的查找时间复杂度降低到常数时间复杂度。

考虑一个常见的问题：找出一个字符串中所有不重复的字符。我们可以使用字典来记录每个字符的出现次数，如果字符出现一次，则计为1。

def find_unique_chars(s):
    char_count = {}
    for char in s:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    unique_chars = [char for char, count in char_count.items() if count == 1]
    return unique_chars

print(find_unique_chars("hello world!"))  # 输出: ['h', 'e', 'w', 'r', 'd']

### 4.3.2 集合在数据去重和查询优化中的应用

在数据去重方面，集合是一个非常有效的工具。由于集合中的元素是唯一的，我们可以轻松地使用集合去除列表中的重复项。

numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = list(set(numbers))
print(unique_numbers)  # 输出: [1, 2, 3, 4, 5]

此外，集合在进行数据查询时也能够提供优化。举一个实际的例子，假设我们需要检查一个很大的数字集合是否包含另一个集合中的所有元素，我们可以使用集合的 `issubset()` 方法。

superset = {1, 2, 3, 4, 5}
subset = {2, 4}

print(subset.issubset(superset))  # 输出: True

这在处理大规模数据集时非常有用，因为它避免了昂贵的循环检查，从而提高了性能。

字典和集合作为Python中的两种重要数据结构，不仅在日常开发中有着广泛的应用，而且在解决复杂问题时也扮演着关键角色。通过深入理解并掌握它们的高级操作和优化技巧，开发者能够编写出更加高效和优雅的代码。

# 5. 数据类型的实际案例分析

## 5.1 实际项目中的字符串应用

在现实世界的应用中，字符串的处理是不可或缺的一部分。无论是在前端展示、后端逻辑处理，还是数据清洗、网络爬虫的编写，字符串都扮演着重要的角色。

### 5.1.1 文本数据处理案例

在处理大量文本数据时，字符串的高级操作技巧可以大大提高处理效率。例如，对日志文件的分析，我们可能需要提取出特定格式的日志信息。

import re

# 假设我们有一个日志文件字符串
log_string = """
[2023-04-01 10:00:01] INFO SomeModule Some information message
[2023-04-01 10:01:02] WARNING SomeModule Some warning message
[2023-04-01 10:02:03] ERROR SomeModule Some error message

# 使用正则表达式解析日志文件
for line in log_string.split('\n'):
    match = re.search(r'\[(.*?)\] (\w+) (\w+) (.*)', line)
    if match:
        timestamp, level, module, message = match.groups()
        print(f"Timestamp: {timestamp}, Level: {level}, Module: {module}, Message: {message}")

上述代码展示了如何使用正则表达式来解析日志文件中的信息，有效地提取出日志时间戳、日志级别、模块名和信息内容。

### 5.1.2 网络爬虫中的字符串处理技巧

在编写网络爬虫时，字符串处理技巧更是至关重要。例如，对网页中的URL进行提取和清洗：

from urllib.parse import urlparse, urlunparse

# 假设我们已经获取了一个网页内容，并提取了URL字符串
url_string = 'https://www.example.com/page?query=python#section'

# 使用 urlparse 解析URL
parsed_url = urlparse(url_string)

# 清洗URL，并移除可能的查询参数和锚点
cleaned_url = urlunparse(parsed_url._replace(query='', fragment=''))

print(f"Cleaned URL: {cleaned_url}")

通过解析和重组URL，我们可以更加灵活地控制网络请求，并且过滤掉不需要的部分。

## 5.2 列表、元组、字典和集合的综合使用

### 5.2.1 数据处理流程的优化

在数据处理中，我们经常需要结合使用列表、元组、字典和集合来优化数据处理流程。例如，对于一个用户列表，我们可能需要去重并且统计每个用户的访问次数：

from collections import Counter

# 假设有一个用户访问记录列表
user_visits = [
    'user1', 'user2', 'user1', 'user3', 'user2', 'user2', 'user4'
]

# 使用集合去除重复记录，并用Counter计数
unique_visits = set(user_visits)
visits_count = Counter(unique_visits)

print(f"Unique user visits count: {visits_count}")

集合帮助我们去除了重复的元素，而 `Counter` 类则方便了计数。

### 5.2.2 复杂数据结构的设计与实现

在处理更复杂的数据结构时，如何合理使用 Python 的数据类型至关重要。例如，考虑一个电商网站的商品分类情况，我们可以使用字典来构建商品分类树：

# 商品分类数据
product_categories = {
    'Electronics': {
        'Televisions': {
            'LED': [],
            'LCD': [],
            'Plasma': []
        },
        'Portable Electronics': {
            'MP3 Players': [],
            'CD Players': [],
            '2 Way Radios': []
        }
    },
    'Sports': {
        'Team Sports': {
            'Baseball': [],
            'Basketball': [],
            'Football': []
        },
        'Individual Sports': {
            'Golf': [],
            'Tennis': [],
            'Swimming': []
        }
    }
}

# 假设我们想查找某一个特定的分类
def find_category(category_tree, category_path):
    current_level = category_tree
    for category in category_path:
        if category in current_level:
            current_level = current_level[category]
        else:
            return None
    return current_level

# 查找路径为 'Electronics' -> 'Portable Electronics' -> 'MP3 Players' 的分类
category_path = ['Electronics', 'Portable Electronics', 'MP3 Players']
category = find_category(product_categories, category_path)
print(f"Category path found: {category}")

这个例子展示了如何使用嵌套字典构建复杂的数据结构，并提供了一个函数来递归查询特定路径。

## 5.3 高级应用和性能优化

### 5.3.1 大数据场景下的数据类型选择

随着数据量的增大，选择合适的数据类型和数据结构变得越来越重要。比如，在大数据分析中，Pandas 库使用的 DataFrame 结构就是一种特殊的字典类型，非常适合于处理表格数据。

import pandas as pd

# 创建一个 DataFrame 来表示某些数据
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Gender': ['Female', 'Male', 'Male']
}

df = pd.DataFrame(data)

print(df)

Pandas 中的 DataFrame 结构可以高效地进行数据的增删改查，并支持复杂的查询操作。

### 5.3.2 性能测试和优化策略

在优化代码性能时，合理使用数据结构以及利用 Python 的内置函数和模块可以显著提升效率。例如，使用 `timeit` 模块进行性能测试：

import timeit

# 测试代码执行效率的函数
def test_performance():
    return sum([i for i in range(10000)])

# 使用timeit模块测试函数执行时间
execution_time = timeit.timeit('test_performance()', globals=globals(), number=1000)
print(f"Average execution time: {execution_time / 1000} seconds")

通过性能测试，我们可以了解不同数据类型操作的效率，并据此进行优化。