03-07 18:46 吉林农业大学算法工程师发布于河北

关注

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. 如何拷贝一个对象？

答案：常见方式：

赋值（不是拷贝）
浅拷贝 copy.copy() 或切片
深拷贝 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