AI-Agent 面试题汇总 - Python进阶

1. Python 中 is 和 == 的区别是什么？

答案：

• == 比较值是否相等
• is 比较是否是同一个对象（身份/内存地址）

代码：

a = [1, 2]
b = [1, 2]
c = a

print(a == b)  # True
print(a is b)  # False
print(a is c)  # True

2. *args 和 **kwargs 的作用是什么？

答案：

• *args：接收任意数量位置参数（元组）
• **kwargs：接收任意数量关键字参数（字典）

代码：

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

demo(1, 2, 3, name="Tom", age=18)

3. lambda 表达式格式及应用场景？

答案：

• 格式：lambda 参数: 表达式
• 常用于：排序 key、短函数回调、map/filter

代码：

data = [("Tom", 90), ("Amy", 95), ("Bob", 88)]
data.sort(key=lambda x: x[1], reverse=True)
print(data)

4. re.search() 和 re.match() 的区别？

答案：

• match()：只从字符串开头匹配
• search()：在整个字符串中查找第一次匹配

代码：

import re

s = "abc123"
print(re.match(r"\d+", s))           # None
print(re.search(r"\d+", s).group())  # 123

5. 深拷贝和浅拷贝的区别是什么？

答案：

• 浅拷贝：只复制第一层，嵌套对象共享
• 深拷贝：递归复制，互不影响

代码：

import copy

a = [[1, 2], [3, 4]]
b = copy.copy(a)       # 浅拷贝
c = copy.deepcopy(a)   # 深拷贝

a[0][0] = 999
print(b)  # [[999, 2], [3, 4]]
print(c)  # [[1, 2], [3, 4]]

6. 如何拷贝一个对象？

答案：常见方式：

1. 赋值（不是拷贝）
2. 浅拷贝 copy.copy() 或切片
3. 深拷贝 copy.deepcopy()

代码：

import copy

x = [1, [2, 3]]
a = x
b = copy.copy(x)
c = copy.deepcopy(x)

x[1][0] = 999
print(a)  # [1, [999, 3]]
print(b)  # [1, [999, 3]]
print(c)  # [1, [2, 3]]

7. 什么是闭包？如何实现？

答案：内部函数引用外部函数变量，外部函数返回后变量仍可使用。

代码：

def outer(x):
    def inner(y):
        return x + y
    return inner

add10 = outer(10)
print(add10(5))  # 15

8. 迭代器是什么？什么场景用？

答案：实现了迭代协议（__iter__ + __next__）的对象，适合按需遍历大数据。

代码：

nums = iter([10, 20, 30])
print(next(nums))  # 10
print(next(nums))  # 20

9. 生成器是什么？和迭代器关系？

答案：生成器是特殊迭代器，使用 yield 惰性生成数据，更省内存。

代码：

def gen():
    for i in range(3):
        yield i

g = gen()
for x in g:
    print(x)

10. yield 和 return 的区别？

答案：

• return：返回后函数结束
• yield：返回一个值并暂停，下次继续执行

代码：

def f1():
    return 1

def f2():
    yield 1
    yield 2

print(f1())          # 1
print(list(f2()))    # [1, 2]

11. __new__ 和 __init__ 的区别？

答案：

• __new__：创建对象（先执行）
• __init__：初始化对象（后执行）

代码：

class A:
    def __new__(cls, *args, **kwargs):
        print("__new__")
        return super().__new__(cls)

    def __init__(self):
        print("__init__")

a = A()

12. 装饰器的本质是什么？

答案：本质是“接收函数并返回新函数”的高阶函数，用于增强原函数功能。

代码：

def log(func):
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log
def add(a, b):
    return a + b

print(add(2, 3))

13. Python 多线程与多进程的区别？

答案：

• 多线程：共享内存，适合 IO 密集
• 多进程：独立内存，适合 CPU 密集

代码（线程示例）：

import threading, time

def task(i):
    time.sleep(0.2)
    print("thread", i)

ts = [threading.Thread(target=task, args=(i,)) for i in range(3)]
for t in ts: t.start()
for t in ts: t.join()

14. Python 内存管理机制是怎样的？

答案：主要为引用计数，辅以分代回收与标记清除，处理循环引用。

代码：

import sys

a = []
print(sys.getrefcount(a))
b = a
print(sys.getrefcount(a))
del b
print(sys.getrefcount(a))

15. 默认参数为什么不建议用可变对象？

答案：默认参数只初始化一次，可变对象会在多次调用间共享。

代码：

def bad(x, arr=[]):
    arr.append(x)
    return arr

print(bad(1))  # [1]
print(bad(2))  # [1, 2]  # 往往非预期

16. global 和 nonlocal 区别是什么？

答案：

• global 修改全局变量
• nonlocal 修改外层函数变量

代码：

x = 10
def f():
    global x
    x = 20
f()
print(x)  # 20

def outer():
    y = 1
    def inner():
        nonlocal y
        y = 2
    inner()
    return y
print(outer())  # 2

17. 列表推导式的语法与优势？

答案：语法：[表达式 for 变量 in 可迭代对象 if 条件]，简洁、常更快。

代码：

nums = [1, 2, 3, 4, 5]
res = [x * x for x in nums if x % 2 == 1]
print(res)  # [1, 9, 25]

18. sort() 与 sorted() 的区别？

答案：

• list.sort() 原地排序，返回 None
• sorted() 返回新列表

代码：

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

a.sort()
print(a)  # [1, 2, 3]

19. 如何去重并保持原顺序？

答案：可用 dict.fromkeys()。

代码：

lst = [1, 2, 2, 3, 1, 4]
res = list(dict.fromkeys(lst))
print(res)  # [1, 2, 3, 4]

20. 字典为何查找快？

答案：底层哈希表，平均 O(1) 查找/插入。

代码：

d = {"a": 1, "b": 2}
print(d["a"])     # 1
d["c"] = 3
print("c" in d)   # True

21. set 的特点与应用？

答案：元素唯一、无序；适合去重与快速成员判断。

代码：

s = {1, 2, 2, 3}
print(s)          # {1,2,3}
print(2 in s)     # True

22. 异常处理 try-except-else-finally 执行顺序？

答案：try ->（异常走except / 无异常走else）-> finally（总会执行）

代码：

try:
    x = 1 / 1
except ZeroDivisionError:
    print("except")
else:
    print("else")
finally:
    print("finally")

23. 如何捕获多个异常并自定义异常？

答案：可元组捕获多个异常；自定义异常继承 Exception。

代码：

class MyError(Exception):
    pass

try:
    int("abc")
except (ValueError, TypeError) as e:
    print("捕获:", e)

def check(n):
    if n < 0:
        raise MyError("n不能小于0")

try:
    check(-1)
except MyError as e:
    print(e)

24. with open(...) 的作用是什么？

答案：上下文管理，自动关闭资源，避免忘记 close()。

代码：

with open("test.txt", "w", encoding="utf-8") as f:
    f.write("hello")

with open("test.txt", "r", encoding="utf-8") as f:
    print(f.read())

25. 文件模式 r/w/a/a+ 区别？

答案：

• r 只读
• w 覆盖写
• a 追加写
• a+ 追加并可读

代码：

with open("m.txt", "w", encoding="utf-8") as f:
    f.write("A\n")

with open("m.txt", "a", encoding="utf-8") as f:
    f.write("B\n")

with open("m.txt", "r", encoding="utf-8") as f:
    print(f.read())

26. 如何按行读取大文件？

答案：使用文件迭代器逐行读取，节省内存。

代码：

with open("big.txt", "r", encoding="utf-8") as f:
    for line in f:
        line = line.strip()
        # 处理 line

27. enumerate() 和 zip() 用法是什么？

答案：

• enumerate：遍历时拿索引
• zip：并行遍历多个序列

代码：

names = ["Tom", "Amy"]
scores = [90, 95]

for i, n in enumerate(names, start=1):
    print(i, n)

for n, s in zip(names, scores):
    print(n, s)

28. any() 与 all() 的区别？

答案：

• any：任一为真即真
• all：全部为真才真

代码：

arr1 = [0, "", 3]
arr2 = [1, 2, 3]
print(any(arr1))  # True
print(all(arr1))  # False
print(all(arr2))  # True

29. 如何判断一个数是否为素数？

答案：检查 2 ~ sqrt(n) 是否存在因子。

代码：

def is_prime(n: int) -> bool:
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    i = 3
    while i * i <= n:
        if n % i == 0:
            return False
        i += 2
    return True

print(is_prime(17))  # True
print(is_prime(18))  # False

30. 如何实现二分查找？

答案：在有序数组中每次折半定位，时间复杂度 O(log n)。

代码：

def binary_search(arr, target):
    l, r = 0, len(arr) - 1
    while l <= r:
        m = (l + r) // 2
        if arr[m] == target:
            return m
        elif arr[m] < target:
            l = m + 1
        else:
            r = m - 1
    return -1

print(binary_search([1, 3, 5, 7, 9], 7))  # 3

31. __name__ == "__main__" 有什么作用？

答案：用于区分“脚本直接运行”与“模块被导入”。

代码：

def main():
    print("脚本入口")

if __name__ == "__main__":
    main()

32. 什么是类方法和静态方法？

答案：

• @classmethod：第一个参数为 cls
• @staticmethod：不依赖类和实例

代码：

class Tool:
    count = 0

    @classmethod
    def inc(cls):
        cls.count += 1

    @staticmethod
    def add(a, b):
        return a + b

Tool.inc()
print(Tool.count)      # 1
print(Tool.add(2, 3))  # 5

33. property 有什么用？

答案：把方法包装成属性访问，便于做校验与封装。

代码：

class Person:
    def __init__(self):
        self._age = 0

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, v):
        if v < 0:
            raise ValueError("age不能为负")
        self._age = v

p = Person()
p.age = 20
print(p.age)

34. 如何实现一个简单计时装饰器？

答案：在装饰器中记录函数执行前后时间差。

代码：

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        res = func(*args, **kwargs)
        print(f"{func.__name__} 耗时: {time.time()-start:.6f}s")
        return res
    return wrapper

@timer
def work():
    sum(range(1000000))

work()

35. 如何把字典保存到 JSON 文件并读取？

答案：使用 json.dump 写入，json.load 读取。

代码：

import json

data = {"name": "Tom", "age": 20}

with open("user.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

with open("user.json", "r", encoding="utf-8") as f:
    obj = json.load(f)

print(obj)

import json

data = {"name": "Tom", "age": 20}

with open("user.json", "w", encoding="utf-8") as f:

json.dump(data, f, ensure_ascii=False, indent=2)

with open("user.json", "r", encoding="utf-8") as f:

obj = json.load(f)

print(obj)