当前位置： 首页 > news >正文

Python面试题及详细答案150道（16-30） -- 数据结构篇

news 2025/8/8 9:09:46

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux… 。

前后端面试题-专栏总目录

在这里插入图片描述

文章目录

  • 一、本文面试题目录
      • 16. 列表（List）和元组（Tuple）的区别是什么？
      • 17. 如何实现列表去重？有哪些方法？
      • 18. 字典（Dictionary）的特性是什么？Python3.7+中字典有什么新特性？
      • 19. 如何遍历字典的键、值、键值对？
      • 20. 集合（Set）的主要作用是什么？如何创建集合？
      • 21. 列表推导式、字典推导式、集合推导式的语法及应用场景。
      • 22. 什么是生成器（Generator）？它与列表有何区别？
      • 23. 解释字符串的不可变性。
      • 24. 字符串的常用方法有哪些？（如`split()`、`join()`、`strip()`等）
      • 25. 如何判断一个字符串是否是回文？
      • 26. 列表的`append()`和`extend()`方法有什么区别？
      • 27. 如何实现两个列表的交集、并集、差集？
      • 28. 什么是有序字典（OrderedDict）？在Python3.7+中是否还有必要使用？
      • 29. 如何高效地反转一个列表或字符串？
      • 30. 解释`enumerate()`函数的作用及用法。
  • 二、150道Python面试题目录列表

一、本文面试题目录

16. 列表（List）和元组（Tuple）的区别是什么？

列表（List）和元组（Tuple）是Python中两种常用的序列类型，主要区别如下：

特性列表（List）元组（Tuple）
语法使用方括号 []使用圆括号 ()
可变性可变（可修改、添加、删除元素）不可变（创建后不能修改元素）
内存占用较大（需预留空间用于修改）较小（存储更紧凑）
适用场景元素需要动态变化的场景元素固定不变的场景（如常量集合）
常用操作append()、insert()、remove()等仅支持查询操作，无修改方法

示例：

# 列表（可变）
my_list = [1, 2, 3]
my_list.append(4)       # 添加元素
my_list[0] = 100        # 修改元素
print(my_list)          # [100, 2, 3, 4]# 元组（不可变）
my_tuple = (1, 2, 3)
# my_tuple.append(4)    # 错误：'tuple' object has no attribute 'append'
# my_tuple[0] = 100     # 错误：'tuple' object does not support item assignment# 元组可以转换为列表进行修改
temp_list = list(my_tuple)
temp_list.append(4)
my_tuple = tuple(temp_list)
print(my_tuple)         # (1, 2, 3, 4)

注意：元组的不可变性是指元素的身份（内存地址）不可变，如果元素是可变对象（如列表），其内部内容仍可修改：

tuple_with_list = (1, 2, [3, 4])
tuple_with_list[2].append(5)  # 允许修改元组中的列表元素
print(tuple_with_list)        # (1, 2, [3, 4, 5])

17. 如何实现列表去重？有哪些方法？

列表去重是常见需求，以下是几种常用方法：

  1. 使用集合（Set）：最简单的方法，利用集合元素唯一性，但会打乱原有顺序（Python 3.7+中集合也保留插入顺序）

    original_list = [1, 2, 2, 3, 3, 3, 4]
unique_list = list(set(original_list))
print(unique_list)  # [1, 2, 3, 4]（顺序可能变化）

  2. 使用列表推导式：保留原有顺序

    original_list = [1, 2, 2, 3, 3, 3, 4]
unique_list = []
[unique_list.append(x) for x in original_list if x not in unique_list]
print(unique_list)  # [1, 2, 3, 4]（保持原顺序）

  3. 使用dict.fromkeys()：Python 3.7+中字典保留插入顺序，去重同时保持顺序

    original_list = [1, 2, 2, 3, 3, 3, 4]
unique_list = list(dict.fromkeys(original_list))
print(unique_list)  # [1, 2, 3, 4]（保持原顺序）

  4. 使用itertools模块：适合处理大型列表，效率较高

    from itertools import groupbyoriginal_list = [1, 2, 2, 3, 3, 3, 4]
# 注意：groupby需要先排序
sorted_list = sorted(original_list)
unique_list = [key for key, group in groupby(sorted_list)]
print(unique_list)  # [1, 2, 3, 4]（排序后的顺序）

选择方法时需考虑：是否需要保持原顺序、列表大小、是否需要处理复杂元素等因素。

18. 字典（Dictionary）的特性是什么？Python3.7+中字典有什么新特性？

字典（Dictionary）的特性：

  • 由键值对（key-value）组成，通过键快速访问值
  • 键（key）必须是不可变类型（如字符串、数字、元组），且唯一；值（value）可以是任何类型
  • 支持动态修改（添加、删除、更新键值对）
  • 属于无序集合（Python 3.7之前）

示例：

person = {"name": "Alice","age": 30,"is_student": False
}# 访问值
print(person["name"])  # Alice# 添加新键值对
person["city"] = "New York"# 修改值
person["age"] = 31# 删除键值对
del person["is_student"]print(person)  # {'name': 'Alice', 'age': 31, 'city': 'New York'}

Python 3.7+中字典的新特性：

  1. 保留插入顺序：字典会记住键值对的插入顺序，遍历字典时会按插入顺序返回

    # Python 3.7+
d = {"a": 1, "b": 2, "c": 3}
print(list(d.keys()))  # ['a', 'b', 'c']（与插入顺序一致）

  2. 新增dict相关函数：

    • dict.values()和dict.items()返回的视图对象支持reversed()反向迭代
      for key in reversed(d):print(key)  # c, b, a

  3. 性能优化：字典的内存使用更加高效，插入和查找速度有所提升

  4. |和|=运算符：Python 3.9+支持用|合并字典，|=更新字典

    # Python 3.9+
d1 = {"a": 1, "b": 2}
d2 = {"b": 3, "c": 4}
d3 = d1 | d2          # 合并字典，相同键取后者值
print(d3)             # {'a': 1, 'b': 3, 'c': 4}d1 |= d2              # 更新字典d1
print(d1)             # {'a': 1, 'b': 3, 'c': 4}

19. 如何遍历字典的键、值、键值对？

字典提供多种遍历方式，可分别遍历键、值或键值对：

  1. 遍历键（key）：

    person = {"name": "Alice", "age": 30, "city": "New York"}# 方法1：直接遍历字典（默认遍历键）
for key in person:print(key)# 方法2：使用keys()方法
for key in person.keys():print(key)

    输出：

    name
age
city

  2. 遍历值（value）：使用values()方法

    for value in person.values():print(value)

    输出：

    Alice
30
New York

  3. 遍历键值对（key-value）：使用items()方法

    for key, value in person.items():print(f"{key}: {value}")

    输出：

    name: Alice
age: 30
city: New York

  4. 同时获取索引和键值对：结合enumerate()函数

    for index, (key, value) in enumerate(person.items()):print(f"{index}: {key} = {value}")

    输出：

    0: name = Alice
1: age = 30
2: city = New York

注意：在Python 3.7之前，字典遍历顺序是不确定的；Python 3.7+中，遍历顺序与插入顺序一致。

20. 集合（Set）的主要作用是什么？如何创建集合？

集合（Set）的主要作用：

  • 存储唯一元素（自动去重）
  • 高效进行成员关系测试（in操作）
  • 实现数学中的集合运算（交集、并集、差集等）
  • 快速消除列表中的重复元素

创建集合的方法：

  1. 使用大括号{}：

    # 创建空集合不能用{}，会被识别为字典
fruits = {"apple", "banana", "cherry"}
print(fruits)  # {'apple', 'banana', 'cherry'}（顺序不确定）# 自动去重
numbers = {1, 2, 2, 3, 3, 3}
print(numbers)  # {1, 2, 3}

  2. 使用set()函数：

    # 创建空集合
empty_set = set()
print(type(empty_set))  # <class 'set'># 从其他可迭代对象创建
from_list = set([1, 2, 2, 3])
print(from_list)  # {1, 2, 3}from_string = set("hello")
print(from_string)  # {'h', 'e', 'l', 'o'}（自动去重）from_tuple = set(("a", "b", "a"))
print(from_tuple)  # {'a', 'b'}

  3. 集合推导式：

    # 创建1-10的偶数集合
even_numbers = {x for x in range(1, 11) if x % 2 == 0}
print(even_numbers)  # {2, 4, 6, 8, 10}

集合是无序的，不能通过索引访问元素，但支持添加、删除元素和各种集合运算。

21. 列表推导式、字典推导式、集合推导式的语法及应用场景。

推导式（Comprehension）是Python中创建序列的简洁语法，可快速生成列表、字典和集合。

  1. 列表推导式

    • 语法：[表达式 for 变量 in 可迭代对象 if 条件]
    • 应用场景：快速生成列表，替代简单的for循环

    示例：

    # 生成1-10的平方列表
squares = [x**2 for x in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]# 筛选偶数
even_numbers = [x for x in range(1, 21) if x % 2 == 0]
print(even_numbers)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]# 嵌套循环
matrix = [[1, 2], [3, 4], [5, 6]]
flattened = [num for row in matrix for num in row]
print(flattened)  # [1, 2, 3, 4, 5, 6]

  2. 字典推导式

    • 语法：{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}
    • 应用场景：快速生成字典，或转换已有数据为字典

    示例：

    # 生成数字到其平方的映射
square_dict = {x: x**2 for x in range(1, 6)}
print(square_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}# 转换键值对
original = {"a": 1, "b": 2, "c": 3}
reversed_dict = {v: k for k, v in original.items()}
print(reversed_dict)  # {1: 'a', 2: 'b', 3: 'c'}# 筛选字典项
filtered = {k: v for k, v in original.items() if v > 1}
print(filtered)  # {'b': 2, 'c': 3}

  3. 集合推导式

    • 语法：{表达式 for 变量 in 可迭代对象 if 条件}
    • 应用场景：快速生成集合，自动去重

    示例：

    # 生成1-10的偶数集合
even_set = {x for x in range(1, 11) if x % 2 == 0}
print(even_set)  # {2, 4, 6, 8, 10}# 提取字符串中唯一的元音字母
vowels = {c for c in "hello world" if c in "aeiou"}
print(vowels)  # {'e', 'o'}# 去重并转换为大写
words = ["apple", "banana", "apple", "cherry"]
unique_words = {word.upper() for word in words}
print(unique_words)  # {'APPLE', 'BANANA', 'CHERRY'}

推导式使代码更简洁高效，但复杂的推导式可能降低可读性，应适度使用。

22. 什么是生成器（Generator）？它与列表有何区别？

生成器（Generator） 是一种特殊的迭代器，用于按需生成值，而不是一次性创建所有值并存储在内存中。

创建生成器的方式：

  1. 使用生成器表达式（类似列表推导式，但用圆括号）
  2. 在函数中使用yield关键字

示例：

# 生成器表达式
gen = (x**2 for x in range(1, 6))
print(gen)  # <generator object <genexpr> at 0x...># 遍历生成器
for num in gen:print(num)  # 1, 4, 9, 16, 25# 生成器函数
def count_up_to(n):i = 1while i <= n:yield i  # 每次调用返回一个值，并暂停函数执行i += 1generator = count_up_to(5)
print(next(generator))  # 1
print(next(generator))  # 2
for num in generator:print(num)  # 3, 4, 5

生成器与列表的区别：

特性生成器列表
内存占用小（按需生成，不存储所有值）大（存储所有值）
创建方式生成器表达式或yield函数列表推导式或[]
可迭代性可迭代（一次性）可迭代（可多次遍历）
访问方式只能通过迭代（next()或for循环）可通过索引直接访问
适用场景处理大量数据或无限序列数据量小，需要随机访问

示例：处理大数据时的内存差异

# 列表：创建100万个元素，占用大量内存
large_list = [x for x in range(1, 1000001)]# 生成器：几乎不占用内存，按需生成
large_generator = (x for x in range(1, 1000001))

生成器特别适合处理大型数据集或无限序列，以及需要节省内存的场景。

23. 解释字符串的不可变性。

字符串的不可变性是指字符串创建后，其内容不能被修改。尝试直接修改字符串的某个字符会抛出错误。

示例：

s = "hello"
# s[0] = "H"  # 错误：'str' object does not support item assignment

为什么字符串是不可变的？

  1. 安全性：作为字典键等哈希表元素时，不可变性确保哈希值不会改变
  2. 性能优化：字符串可以被安全地共享，无需复制
  3. 简化内存管理：Python可以对字符串进行缓存（如短字符串驻留）

如何"修改"字符串？
虽然不能直接修改字符串，但可以创建新的字符串：

s = "hello"# 方法1：字符串拼接
s1 = "H" + s[1:]
print(s1)  # "Hello"# 方法2：使用字符串方法（返回新字符串）
s2 = s.replace("h", "H")
print(s2)  # "Hello"# 方法3：转换为列表修改后再转回字符串
s_list = list(s)
s_list[0] = "H"
s3 = "".join(s_list)
print(s3)  # "Hello"

注意：每次"修改"字符串都会创建新的字符串对象，原字符串保持不变：

s = "hello"
s_new = s.upper()
print(s)      # "hello"（原字符串不变）
print(s_new)  # "HELLO"（新字符串）

理解字符串的不可变性有助于编写更高效的代码，避免不必要的字符串复制操作。

24. 字符串的常用方法有哪些？（如split()、join()、strip()等）

Python字符串提供了丰富的方法，以下是常用的一些：

  1. split(sep=None, maxsplit=-1)：按分隔符分割字符串，返回列表

    s = "apple,banana,cherry"
print(s.split(","))  # ['apple', 'banana', 'cherry']s2 = "hello world how are you"
print(s2.split(maxsplit=2))  # ['hello', 'world', 'how are you']（最多分割2次）

  2. join(iterable)：将可迭代对象中的字符串用原字符串连接

    fruits = ["apple", "banana", "cherry"]
print(", ".join(fruits))  # "apple, banana, cherry"
print(" ".join(fruits))   # "apple banana cherry"

  3. strip([chars])：去除字符串首尾指定字符（默认去除空白）

    s = "   hello world   "
print(s.strip())  # "hello world"（去除首尾空格）s2 = "###hello###"
print(s2.strip("#"))  # "hello"（去除首尾#）

    相关方法：lstrip()（仅去除左侧）、rstrip()（仅去除右侧）

  4. 大小写转换：

    s = "Hello World"
print(s.lower())  # "hello world"（全小写）
print(s.upper())  # "HELLO WORLD"（全大写）
print(s.title())  # "Hello World"（每个单词首字母大写）
print(s.capitalize())  # "Hello world"（仅首字母大写）

  5. replace(old, new, count=-1)：替换字符串中的子串

    s = "hello hello world"
print(s.replace("hello", "hi"))  # "hi hi world"（全部替换）
print(s.replace("hello", "hi", 1))  # "hi hello world"（只替换1次）

  6. startswith(prefix)和endswith(suffix)：检查字符串是否以指定前缀/后缀开头/结尾

    s = "hello.txt"
print(s.startswith("hello"))  # True
print(s.endswith(".txt"))     # True
print(s.endswith((".doc", ".txt")))  # True（检查多个选项）

  7. find(sub, start=0, end=len(string))和index(sub)：查找子串位置

    s = "hello world"
print(s.find("world"))  # 6（找到返回索引）
print(s.find("python"))  # -1（找不到返回-1）
# print(s.index("python"))  # 错误：ValueError（找不到抛出异常）

  8. format(*args, **kwargs)：格式化字符串

    name = "Alice"
age = 30
print("My name is {0}, I'm {1} years old".format(name, age))
print(f"My name is {name}, I'm {age} years old")  # f-string更简洁

25. 如何判断一个字符串是否是回文？

回文是指正读和反读都相同的字符串（忽略大小写和非字母字符）。判断方法如下：

方法1：反转字符串比较

def is_palindrome(s):# 预处理：转为小写，只保留字母和数字cleaned = "".join(ch.lower() for ch in s if ch.isalnum())# 比较清理后的字符串和其反转return cleaned == cleaned[::-1]print(is_palindrome("A man, a plan, a canal: Panama"))  # True
print(is_palindrome("race a car"))  # False
print(is_palindrome("level"))       # True

方法2：双指针法

def is_palindrome(s):left = 0right = len(s) - 1while left < right:# 移动左指针到下一个字母或数字while left < right and not s[left].isalnum():left += 1# 移动右指针到前一个字母或数字while left < right and not s[right].isalnum():right -= 1# 比较字符（忽略大小写）if s[left].lower() != s[right].lower():return Falseleft += 1right -= 1return Trueprint(is_palindrome("A man, a plan, a canal: Panama"))  # True
print(is_palindrome("race a car"))  # False

关键步骤：

  1. 预处理：过滤非字母数字字符，统一大小写
  2. 比较：
    • 方法1简单直观，利用Python字符串切片[::-1]快速反转
    • 方法2空间效率更高，无需创建新字符串

两种方法都能有效判断回文，方法1代码更简洁，方法2适合处理超长字符串（节省内存）。

26. 列表的append()和extend()方法有什么区别？

append()和extend()都是列表的添加元素方法，但功能不同：

  • append(item)：将item作为单个元素添加到列表末尾

    • 无论item是什么类型，都会被当作一个整体添加

  • extend(iterable)：将可迭代对象（如列表、元组、字符串）中的每个元素逐个添加到列表末尾

    • 只能接收可迭代对象作为参数

示例：

# 初始化列表
my_list = [1, 2, 3]# 使用append()
my_list.append(4)
print(my_list)  # [1, 2, 3, 4]（添加单个元素）my_list.append([5, 6])
print(my_list)  # [1, 2, 3, 4, [5, 6]]（列表作为单个元素添加）# 重置列表
my_list = [1, 2, 3]# 使用extend()
my_list.extend([4, 5])
print(my_list)  # [1, 2, 3, 4, 5]（添加可迭代对象中的元素）my_list.extend((6, 7))
print(my_list)  # [1, 2, 3, 4, 5, 6, 7]（元组元素被逐个添加）my_list.extend("89")
print(my_list)  # [1, 2, 3, 4, 5, 6, 7, '8', '9']（字符串字符被逐个添加）

错误示例：

# extend()不能接收非可迭代对象
# my_list.extend(10)  # 错误：'int' object is not iterable

总结：

  • 当需要添加单个元素时，使用append()
  • 当需要添加另一个可迭代对象中的所有元素时，使用extend()

27. 如何实现两个列表的交集、并集、差集？

可以通过将列表转换为集合，利用集合的运算实现列表的交集、并集和差集：

  1. 交集：两个列表中都存在的元素

    list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]# 方法1：使用集合的&运算符
intersection = list(set(list1) & set(list2))
print(intersection)  # [4, 5]（顺序可能不同）# 方法2：使用集合的intersection()方法
intersection = list(set(list1).intersection(set(list2)))
print(intersection)  # [4, 5]

  2. 并集：两个列表中所有不重复的元素

    # 方法1：使用集合的|运算符
union = list(set(list1) | set(list2))
print(union)  # [1, 2, 3, 4, 5, 6, 7, 8]（顺序可能不同）# 方法2：使用集合的union()方法
union = list(set(list1).union(set(list2)))
print(union)  # [1, 2, 3, 4, 5, 6, 7, 8]

  3. 差集：在第一个列表中但不在第二个列表中的元素

    # 方法1：使用集合的-运算符
difference = list(set(list1) - set(list2))
print(difference)  # [1, 2, 3]（顺序可能不同）# 方法2：使用集合的difference()方法
difference = list(set(list1).difference(set(list2)))
print(difference)  # [1, 2, 3]

  4. 对称差集：两个列表中不重叠的元素（并集减去交集）

    # 方法1：使用集合的^运算符
symmetric_diff = list(set(list1) ^ set(list2))
print(symmetric_diff)  # [1, 2, 3, 6, 7, 8]（顺序可能不同）# 方法2：使用集合的symmetric_difference()方法
symmetric_diff = list(set(list1).symmetric_difference(set(list2)))
print(symmetric_diff)  # [1, 2, 3, 6, 7, 8]

注意：

  • 集合转换会去除重复元素并改变顺序
  • 如果需要保留原始顺序或重复元素，需使用列表推导式：
    # 保留顺序的交集（包含重复）
intersection_ordered = [x for x in list1 if x in list2]
print(intersection_ordered)  # [4, 5]

28. 什么是有序字典（OrderedDict）？在Python3.7+中是否还有必要使用？

有序字典（OrderedDict） 是collections模块中的一个类，它保留了键值对的插入顺序，在Python 3.7之前用于解决普通字典无序的问题。

示例：

from collections import OrderedDict# 创建有序字典
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od["c"] = 3# 遍历顺序与插入顺序一致
for key, value in od.items():print(key, value)
# 输出：
# a 1
# b 2
# c 3# 移动元素到末尾
od.move_to_end("a")
print(list(od.keys()))  # ['b', 'c', 'a']# 弹出第一个元素
od.popitem(last=False)  # 删除并返回第一个元素 ('b', 2)

Python 3.7+中是否还有必要使用OrderedDict？

Python 3.7+的普通字典也开始保留插入顺序，但OrderedDict仍有其独特功能：

  1. move_to_end(key)：将指定键值对移动到开头或末尾
  2. popitem(last=True)：可以选择弹出最后一个或第一个元素
  3. 相等性比较：OrderedDict比较时会考虑顺序，而普通字典不考虑
    # Python 3.7+
d1 = {"a": 1, "b": 2}
d2 = {"b": 2, "a": 1}
print(d1 == d2)  # True（普通字典不考虑顺序）od1 = OrderedDict({"a": 1, "b": 2})
od2 = OrderedDict({"b": 2, "a": 1})
print(od1 == od2)  # False（OrderedDict考虑顺序）

因此，在Python 3.7+中：

  • 仅需保留插入顺序时，普通字典足够
  • 需要上述独特功能时，仍需使用OrderedDict

29. 如何高效地反转一个列表或字符串？

Python提供了多种方法反转列表或字符串，其中最简洁高效的是使用切片操作：

  1. 反转列表：

    # 方法1：切片操作（创建新列表）
my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]
print(reversed_list)  # [5, 4, 3, 2, 1]# 方法2：使用reversed()函数（返回迭代器）
reversed_iterator = reversed(my_list)
reversed_list = list(reversed_iterator)
print(reversed_list)  # [5, 4, 3, 2, 1]# 方法3：原地反转（修改原列表）
my_list.reverse()
print(my_list)  # [5, 4, 3, 2, 1]

  2. 反转字符串：

    # 方法1：切片操作（最简洁高效）
my_str = "hello"
reversed_str = my_str[::-1]
print(reversed_str)  # "olleh"# 方法2：使用reversed()函数
reversed_chars = reversed(my_str)
reversed_str = "".join(reversed_chars)
print(reversed_str)  # "olleh"

效率对比：

  • 切片操作（[::-1]）：简洁高效，时间复杂度O(n)，但会创建新对象
  • reversed()函数：返回迭代器，适合处理大型序列，内存效率高
  • 列表的reverse()方法：原地反转，不创建新对象，节省内存

选择建议：

  • 字符串反转：优先使用切片[::-1]
  • 列表反转：如需保留原列表用切片，无需保留原列表用reverse()方法，处理大型列表用reversed()

30. 解释enumerate()函数的作用及用法。

enumerate()函数用于将一个可迭代对象（如列表、元组、字符串）组合为一个索引序列，同时返回索引和对应的值，常用于需要获取元素索引的遍历场景。

语法：enumerate(iterable, start=0)

  • iterable：可迭代对象
  • start：索引的起始值，默认为0

用法示例：

  1. 基本用法：

    fruits = ["apple", "banana", "cherry"]# 不指定start（默认从0开始）
for index, fruit in enumerate(fruits):print(f"{index}: {fruit}")
# 输出：
# 0: apple
# 1: banana
# 2: cherry# 指定start（从1开始）
for index, fruit in enumerate(fruits, start=1):print(f"{index}: {fruit}")
# 输出：
# 1: apple
# 2: banana
# 3: cherry

  2. 与字符串一起使用：

    s = "hello"
for i, char in enumerate(s):print(f"Index {i}: {char}")
# 输出：
# Index 0: h
# Index 1: e
# Index 2: l
# Index 3: l
# Index 4: o

  3. 转换为列表：

    numbers = [10, 20, 30]
enumerated = list(enumerate(numbers))
print(enumerated)  # [(0, 10), (1, 20), (2, 30)]

  4. 替代传统的索引遍历：

    # 传统方式
for i in range(len(fruits)):print(f"{i}: {fruits[i]}")# 使用enumerate更简洁
for i, fruit in enumerate(fruits):print(f"{i}: {fruit}")

enumerate()函数使代码更简洁、可读性更高，避免了手动管理索引变量的麻烦，是Python中遍历带索引元素的推荐方式。

二、150道Python面试题目录列表

文章序号Python面试题150道
1Python面试题及详细答案150道（01-15）
2Python面试题及详细答案150道（16-30）
3Python面试题及详细答案150道（31-40）
4Python面试题及详细答案150道（41-55）
5Python面试题及详细答案150道（56-70）
6Python面试题及详细答案150道（71-80）
7Python面试题及详细答案150道（81-90）
8Python面试题及详细答案150道（91-100）
9Python面试题及详细答案150道（101-115）
10Python面试题及详细答案150道（116-125）
11Python面试题及详细答案150道（126-135）
12Python面试题及详细答案150道（136-150）
http://www.lryc.cn/news/613066.html

相关文章：

  • 分布式微服务--GateWay(过滤器及使用Gateway注意点)
  • 告别YAML，在SpringBoot中用数据库配置替代配置文件
  • word生成问题总结
  • 【遥感图像入门】近三年遥感图像建筑物细粒度分类技术一览
  • Day116 若依融合mqtt
  • 界面组件DevExpress WPF中文教程：网格视图数据布局 - 紧凑模式
  • 音视频时间戳获取与同步原理详解
  • 【Docker】RustDesk远程控制-私有化部署开源版本
  • 生成式AI的“幽灵漏洞”：法律如何为技术的阴影划界
  • PCIe Base Specification解析（八）
  • 从配置到远程访问：如何用群晖NAS FTP+ Cpolar搭建稳定文件传输通道
  • 深入解析Three.js中的BufferAttribute：源码与实现机制
  • Linux下动态库链接的详细过程
  • C++位图(Bitmap)与布隆过滤器(Bloom Filter)详解及海量数据处理应用
  • vue3父组件把一个对象整体传入子组件，还是把一个对象的多个属性分成多个参数传入
  • C#中统计某个字符出现次数的最简单方法
  • Git `cherry-pick` 工具汇总
  • Numpy科学计算与数据分析：Numpy线性代数基础与实践
  • 第一个vue应用
  • 【Kubernetes】部署 kube-bench 实现 K8s 最佳实践
  • LeetCode 分类刷题：125. 验证回文串
  • LongVie突破超长视频生成极限：1分钟电影级丝滑视频，双模态控制告别卡顿退化
  • Postman接口测试入门
  • ESXI7.0添加标准交换机过程
  • Python 位置参数（positional arguments）
  • 大文件断点续传（vue+springboot+mysql）
  • 8.结构健康监测选自动化：实时数据 + 智能分析，远超人工
  • Python 基础详解：变量（Variables）—— 程序的“记忆单元”
  • Numpy科学计算与数据分析：Numpy数据分析基础之统计函数应用
  • 理清C语言中动态内存管理相关函数