【Python面试题】Python面试之基础知识常见面试题2——列表篇

专栏导读

• 🌸 欢迎来到Python办公自动化专栏—Python处理办公问题，解放您的双手

• 🏳️‍🌈 博客主页：请点击——> 一晌小贪欢的博客主页求关注

• 👍 该系列文章专栏：请点击——>Python办公自动化专栏求订阅

• 🕷 此外还有爬虫专栏：请点击——>Python爬虫基础专栏求订阅

• 📕 此外还有python基础专栏：请点击——>Python基础学习专栏求订阅

• 文章作者技术和水平有限，如果文中出现错误，希望大家能指正🙏

• ❤️ 欢迎各位佬关注！ ❤️

前言

在Python面试中，列表（List）作为最常用的数据结构之一，经常会被面试官重点考察。本文将总结Python列表相关的常见面试题，帮助大家更好地准备面试。

1. 列表基础操作

1.1 列表的创建和初始化

面试题：如何创建一个包含10个0的列表？

# 方法1：使用乘法操作符
list1 = [0] * 10

# 方法2：使用列表推导式
list2 = [0 for _ in range(10)]

# 方法3：使用range和list函数
list3 = list(range(0, 10, 0))  # 注意：这种方法不正确
# 正确的方法3
list3 = [0] * 10

注意事项：

• 当列表元素是可变对象时，使用[obj] * n可能会产生意外结果
• 例如：[[]] * 3会创建三个指向同一个列表的引用

1.2 列表的访问和切片

面试题：解释Python列表的负索引

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

# 正索引：0, 1, 2, 3, 4
# 负索引：-5, -4, -3, -2, -1

print(my_list[-1])   # 输出：5（最后一个元素）
print(my_list[-2])   # 输出：4（倒数第二个元素）

面试题：列表切片的语法和应用

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 基本切片
print(my_list[2:5])    # [2, 3, 4]
print(my_list[:3])     # [0, 1, 2]
print(my_list[3:])     # [3, 4, 5, 6, 7, 8, 9]
print(my_list[:])      # 复制整个列表

# 步长切片
print(my_list[::2])    # [0, 2, 4, 6, 8]（每隔一个元素）
print(my_list[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]（反转列表）

2. 列表的常用方法

2.1 添加和删除元素

面试题：append()、insert()、extend()的区别

my_list = [1, 2, 3]

# append()：在末尾添加一个元素
my_list.append(4)
print(my_list)  # [1, 2, 3, 4]

# insert()：在指定位置插入元素
my_list.insert(1, 'a')
print(my_list)  # [1, 'a', 2, 3, 4]

# extend()：将另一个可迭代对象的元素添加到列表末尾
my_list.extend([5, 6])
print(my_list)  # [1, 'a', 2, 3, 4, 5, 6]

# 注意：append vs extend的区别
list1 = [1, 2, 3]
list1.append([4, 5])    # [1, 2, 3, [4, 5]]

list2 = [1, 2, 3]
list2.extend([4, 5])    # [1, 2, 3, 4, 5]

面试题：remove()、pop()、del的区别

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

# remove()：删除第一个匹配的值
my_list.remove(2)  # 删除第一个2
print(my_list)     # [1, 3, 2, 4]

# pop()：删除并返回指定索引的元素（默认最后一个）
popped = my_list.pop()    # 删除并返回最后一个元素
print(popped)             # 4
print(my_list)            # [1, 3, 2]

popped = my_list.pop(0)   # 删除并返回索引0的元素
print(popped)             # 1
print(my_list)            # [3, 2]

# del：删除指定索引或切片的元素
del my_list[0]
print(my_list)            # [2]

2.2 查找和统计

面试题：如何查找列表中元素的位置？

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

# index()：返回第一个匹配元素的索引
index = my_list.index(2)
print(index)  # 1

# 查找所有匹配元素的索引
indices = [i for i, x in enumerate(my_list) if x == 2]
print(indices)  # [1, 3]

# count()：统计元素出现次数
count = my_list.count(2)
print(count)  # 2

3. 列表推导式

面试题：什么是列表推导式？有什么优势？

# 传统方法
squares = []
for i in range(10):
    squares.append(i**2)

# 列表推导式
squares = [i**2 for i in range(10)]

# 带条件的列表推导式
even_squares = [i**2 for i in range(10) if i % 2 == 0]

# 嵌套列表推导式
matrix = [[i*j for j in range(3)] for i in range(3)]
print(matrix)  # [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

优势：

• 代码更简洁
• 执行效率更高
• 更符合Python的编程风格

4. 列表的高级操作

4.1 列表排序

面试题：sort()和sorted()的区别

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

# sort()：原地排序，修改原列表
my_list.sort()
print(my_list)  # [1, 1, 2, 3, 4, 5, 6, 9]

# sorted()：返回新的排序列表，不修改原列表
original = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(original)
print(original)     # [3, 1, 4, 1, 5, 9, 2, 6]
print(sorted_list)  # [1, 1, 2, 3, 4, 5, 6, 9]

# 自定义排序
students = [('Alice', 85), ('Bob', 90), ('Charlie', 78)]
# 按成绩排序
students.sort(key=lambda x: x[1])
print(students)  # [('Charlie', 78), ('Alice', 85), ('Bob', 90)]

4.2 列表去重

面试题：如何去除列表中的重复元素？

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

# 方法1：使用set（不保持顺序）
unique_list1 = list(set(my_list))

# 方法2：使用dict.fromkeys()（保持顺序，Python 3.7+）
unique_list2 = list(dict.fromkeys(my_list))

# 方法3：使用列表推导式（保持顺序）
seen = set()
unique_list3 = [x for x in my_list if not (x in seen or seen.add(x))]

# 方法4：使用OrderedDict（Python 3.6及以下版本）
from collections import OrderedDict
unique_list4 = list(OrderedDict.fromkeys(my_list))

5. 列表的内存和性能

5.1 列表的内存分配

面试题：解释列表的动态扩容机制

import sys

# 查看列表的内存大小
my_list = []
for i in range(10):
    my_list.append(i)
    print(f"长度: {len(my_list)}, 内存大小: {sys.getsizeof(my_list)}")

关键点：

• 列表采用动态数组实现
• 当容量不足时，会重新分配更大的内存空间
• 通常按照1.5倍或2倍的方式扩容

5.2 性能考虑

面试题：列表操作的时间复杂度

6. 常见陷阱和注意事项

6.1 可变对象的陷阱

面试题：以下代码的输出是什么？

# 陷阱1：默认参数是可变对象
def add_item(item, target_list=[]):
    target_list.append(item)
    return target_list

list1 = add_item(1)
list2 = add_item(2)
print(list1)  # [1, 2]
print(list2)  # [1, 2]

# 正确的做法
def add_item_correct(item, target_list=None):
    if target_list is None:
        target_list = []
    target_list.append(item)
    return target_list

6.2 浅拷贝和深拷贝

面试题：解释列表的浅拷贝和深拷贝

import copy

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

# 浅拷贝
shallow_copy = original.copy()  # 或者 original[:] 或 list(original)
shallow_copy[0][0] = 'X'
print(original)      # [['X', 2, 3], [4, 5, 6]]
print(shallow_copy)  # [['X', 2, 3], [4, 5, 6]]

# 深拷贝
original = [[1, 2, 3], [4, 5, 6]]
deep_copy = copy.deepcopy(original)
deep_copy[0][0] = 'X'
print(original)   # [[1, 2, 3], [4, 5, 6]]
print(deep_copy)  # [['X', 2, 3], [4, 5, 6]]

7. 实际应用题

7.1 两数之和

面试题：给定一个整数数组和目标值，找出数组中和为目标值的两个数的索引

def two_sum(nums, target):
    """
    时间复杂度：O(n)
    空间复杂度：O(n)
    """
    num_dict = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_dict:
            return [num_dict[complement], i]
        num_dict[num] = i
    return []

# 测试
nums = [2, 7, 11, 15]
target = 9
result = two_sum(nums, target)
print(result)  # [0, 1]

7.2 数组去重并保持顺序

面试题：去除数组中的重复元素，保持原有顺序

def remove_duplicates(nums):
    """
    保持原有顺序的去重
    """
    seen = set()
    result = []
    for num in nums:
        if num not in seen:
            seen.add(num)
            result.append(num)
    return result

# 测试
nums = [1, 2, 2, 3, 3, 3, 4, 1]
result = remove_duplicates(nums)
print(result)  # [1, 2, 3, 4]

总结

列表是Python中最重要的数据结构之一，掌握列表的各种操作和特性对于Python开发者来说至关重要。在面试中，除了要熟悉基本操作外，还要理解：

1. 性能特点：了解各种操作的时间复杂度
2. 内存管理：理解列表的动态扩容机制
3. 常见陷阱：避免可变对象、浅拷贝等问题
4. 实际应用：能够运用列表解决实际问题

希望这篇文章能够帮助大家更好地准备Python面试中关于列表的相关问题！

相关文章推荐：

• Python面试之基础知识常见面试题1-基础篇
• Python面试之基础知识常见面试题3-字典篇
• Python面试之基础知识常见面试题4-字符串篇

结尾

• 希望对初学者有帮助；致力于办公自动化的小小程序员一枚

• 希望能得到大家的【❤️一个免费关注❤️】感谢！

• 求个 🤞 关注 🤞 +❤️ 喜欢 ❤️ +👍 收藏 👍

• 此外还有办公自动化专栏，欢迎大家订阅：Python办公自动化专栏

• 此外还有爬虫专栏，欢迎大家订阅：Python爬虫基础专栏

• 此外还有Python基础专栏，欢迎大家订阅：Python基础学习专栏