大厂面试python复习基础100题

大厂面试python复习基础100题

• 一、先建立 0 基础 Python 思维
• 二、100 题按知识点讲解与答案
• • A. Python 基础概念：
  • • 1. Python 有什么特点？
    • 3. Python 是通用编程语言吗？
    • 4. Python 为什么叫解释型语言？
    • 5. 什么是 PEP？
    • 6. Python 如何管理内存？
    • 7. 什么是命名空间？
    • 8. 什么是 PYTHONPATH？
    • 9. 什么是 Python 模块？
    • 10. 局部变量和全局变量
    • 11. Python 区分大小写吗？
    • 12. 类型转换
    • 13. Windows 安装 Python 和设置路径
    • 14. Python 是否需要缩进？
    • 26 / 31. Python 注释
    • 32. Docstring 是什么？
    • 33. is、not、in
    • 34. help() 和 dir()
    • 35. Python 退出时为什么不一定清理所有内存？
    • 44. Python 内置类型
    • 93. 标识符最大长度是多少？
    • 94. 为什么不鼓励下划线开头变量？
    • 95. 哪个声明无效？
  • B. 列表、元组、字典、字符串、索引：1、15、21、29、30、36、39～41、46、47、53、91、97
  • • 1. 列表和元组区别
    • 15. 数组和列表区别
    • 21. `[::-1]` 是什么？
    • 29. 字符串首字母大写
    • 30. 字符串转小写
    • 36. 字典是什么？
    • 39. len() 函数有什么作用？
    • 40. split、sub、subn
    • 41. 负索引
    • 46. 添加元素
    • 47. 删除元素
    • 53. split 函数
    • 91. 哪些语句创建字典？
    • 97. `list1[-1]`
  • C. 函数、参数、迭代器、生成器、随机数：16、18、20、22～25、27、28、37、38、54、85
  • • 16. 函数是什么？
    • 18. lambda 函数
    • 20. break、continue、pass
    • 22. 随机打乱列表
    • 23. 迭代器是什么？
    • 24. 生成随机数
    • 25. range 和 xrange 区别
    • 27. pickling 和 unpickling
    • 28. 生成器是什么？
    • 37. 三元运算符
    • 38. `*args` 和 `**kwargs`
    • 54. 如何在 Python 中导入模块？
    • 85. map 函数
  • D. 面向对象：17、19、48、55～64
  • • 17. `__init__` 是什么？
    • 19. self 是什么？
    • 48. Python 有 OOP 概念吗？
    • 55. 继承是什么？
    • 56. 创建类
    • 57. Python 补丁 / 猴子补丁
    • 58. Python 支持多重继承吗？
    • 59. 多态是什么？
    • 60. 封装是什么？
    • 61. 数据抽象是什么？
    • 62. Python 有访问修饰符吗？
    • 63. 空类
    • 64. object() 函数
  • E. 文件、异常、复制、多线程：43、49～52、70、96、98～100
  • • 43. 删除文件
    • 49. 浅拷贝和深拷贝
    • 50. Python 多线程和 GIL
    • 51. Python 编译和链接
    • 52. Python 库
    • 70. 统计文件中大写字母数量
    • 96. 异常题
    • 98. 打开文件写入
    • 99. with 打开文件后是否关闭？
    • 100. try-except-else 中 else 什么时候执行？
  • F. 算法题：65～72
  • • 65. 冒泡排序
    • 66. 星号三角形
    • 67. Fibonacci 数列
    • 68. 判断素数
    • 69. 判断回文
    • 71. 列表排序
    • 72. 阅读代码求值
  • G. Web 框架与爬虫：73～84
  • • 73. Flask 是什么？
    • 74. Django 和 Flask 比较
    • 75. Django、Pyramid、Flask 差异
    • 76. Django 架构
    • 77. Django 设置数据库
    • 78. Django View 示例
    • 79. Django 模板组成
    • 80. Django Session
    • 81. Django 继承样式
    • 82. 根据 URL 保存图片
    • 83. 获取 Google 缓存页面
    • 84. 爬取 IMDb 前 250 电影
  • H. NumPy、SciPy、数据分析：45、86～90
  • • 45. NumPy 相比 Python 列表的优势
    • 86. NumPy 比列表好吗？
    • 87. NumPy 数组中 N 个最大值的索引
    • 88. NumPy 计算百分位数
    • 89. NumPy 和 SciPy 区别
    • 90. NumPy/SciPy 做 3D 可视化
• 三、python中的装饰器：
• • 再更简单解释一下装饰器，面试说：
• 四、面试中最重点的 20 几个高频考题
• • • GIL
    • 深拷贝浅拷贝
    • 生成器 / yield
    • `__new__` 和 `__init__`
  • 1. 装饰器
  • 2. GIL
  • 3. 深拷贝和浅拷贝
  • 4. 生成器和 yield
  • 5. `__new__` 和 `__init__`
  • 6. 异常处理顺序
  • 7. 垃圾回收

一、先建立 0 基础 Python 思维

你先记住这 6 句话：

二、100 题按知识点讲解与答案

A. Python 基础概念：

1. Python 有什么特点？

Python 是解释型、动态类型、面向对象、语法简单、开发快的语言。

解释:

C/C++ 通常是：

• 源代码 → 编译器 → 机器码程序 → CPU 直接执行

Python 常见运行过程是：

• py 源代码 → 字节码 → Python 虚拟机执行

Python 这样设计，是为了提高开发效率、增强代码灵活性、方便跨平台运行。

面试可以这样说：

Python 不需要像 C/C++ 那样先手动编译再运行，它由解释器执行。Python 是动态类型语言，变量不用提前声明类型。Python 支持面向对象，也常用于 Web、自动化、数据分析、人工智能等领域。

3. Python 是通用编程语言吗？

是。Python 不只是脚本语言，它可以做 Web、爬虫、数据分析、AI、自动化、后端服务等。

补充解释：

脚本语言强调“快速完成自动化任务”，比如批量处理文件、爬虫、自动化测试。 通用编程语言强调“能做很多领域的软件”，比如

• Web、AI、数据分析、自动化、后端服务。 结论：
• Python 既可以写小脚本，也可以做大型项目。

4. Python 为什么叫解释型语言？

因为 Python 程序通常由解释器执行，不需要开发者手动编译成机器码。

更准确地说，Python 会先生成字节码，再由虚拟机执行。但面试初级岗位说“Python 是解释型语言”就够了。

注意：

• 解释型语言不等于一定有虚拟机。 编译型语言也不等于一定没有虚拟机。 C/C++ 通常编译成机器码直接执行。 Java 是编译成字节码后由
• JVM 执行。 Python 常见实现也是源码到字节码，再由虚拟机执行。

5. 什么是 PEP？

PEP 是 Python Enhancement Proposal，意思是 Python 增强提案。

最常见的是 PEP 8，它规定 Python 代码风格，比如缩进 4 个空格、变量名小写加下划线等。

补充解释：

• PEP 是 Python 社区记录语言设计、改进和规范的正式文档。 PEP 8 是其中最常见的代码风格指南。

要特别说明：

• Python 强制要求缩进，但不强制必须 4 个空格(都是2个空格的python代码也能运行,只要缩进对齐没问题就行)。 4 个空格是 PEP 8 推荐风格。 变量名小写加下划线也是 PEP 8 推荐风格，不是语法强制。

6. Python 如何管理内存？

Python 自动管理内存。对象放在私有堆空间里，程序员不用手动释放。Python 有垃圾回收机制，会清理不再使用的对象。

你可以这样答：

• Python 的内存由解释器管理，主要包括引用计数和垃圾回收机制。开发者通常不需要手动分配和释放内存。 面试回答核心：
• Python 的内存管理主要包括对象分配、引用计数和垃圾回收。

7. 什么是命名空间？

命名空间就是“名字存放的地方”。

比如：

x = 10

这里 x 这个名字就存在某个命名空间里。函数内部有局部命名空间，整个文件有全局命名空间。

比如变量名、函数名、类名都会存在某个命名空间里。

常见命名空间：

局部命名空间。 全局命名空间。 内置命名空间。

作用： 避免命名冲突。

8. 什么是 PYTHONPATH？

PYTHONPATH 是环境变量，用来告诉 Python 去哪些目录查找模块。

例如你写：

import my_module

Python 会在当前目录、标准库目录、PYTHONPATH 指定的目录里查找这个模块。

9. 什么是 Python 模块？

模块是 Python 组织代码的单位，最常见形式是一个 .py 文件。

补充解释：

一个模块可以包含变量、函数、类。

例如：

# my_tools.py

PI = 3.14

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

class Dog:
pass

这个 my_tools.py 就是一个模块。

导入：

import my_tools

print(my_tools.PI)
print(my_tools.add(1, 2))

可以把模块理解成“工具箱”。

附加内容： math 不是 C/C++ 的数学头文件，而是 Python 官方提供的数学模块。

import math

print(math.sqrt(16))
print(math.pi)
print(math.ceil(3.2))

常用模块：

sys
os
math
random
datetime
json
re

10. 局部变量和全局变量

函数外定义的是全局变量，函数内定义的是局部变量。

x = 10 # 全局变量

def test():
y = 20 # 局部变量
print(y)

print(x)

x 是全局变量。 y 是局部变量。 x 在整个文件里都能访问，y 只能在函数内部使用。

11. Python 区分大小写吗？

区分。

Name = "Tom"
name = "Jerry"

Name 和 name 是两个不同变量。

12. 类型转换

类型转换就是把一种类型变成另一种类型。

常见例子：

int("123") # 字符串转整数
float("3.14") # 字符串转小数
str(100) # 数字转字符串
list("abc") # ['a', 'b', 'c']
tuple([1, 2]) # (1, 2)
set([1, 1, 2]) # {1, 2}

13. Windows 安装 Python 和设置路径

面试一般不会深问。核心回答：

• 从 Python 官网下载安装。
• 安装时勾选 Add Python to PATH。
• 命令行输入 python –version 验证安装。

14. Python 是否需要缩进？

需要。Python 用缩进表示代码块。

if True:
print("hello")

缩进错误会报错。

补充：

Python 强制要求缩进，但 4 个空格是 PEP 8 推荐风格。

26 / 31. Python 注释

单行注释用 #：

# 这是注释
print("hello")

多行说明常用三引号：

"""
这是多行说明
也可以作为文档字符串
"""

补充： 如果三引号写在模块、函数、类的开头，通常叫 Docstring。用于说明其用途、参数、返回值等，可通过 doc 属性访问，并被 IDE 和文档工具识别。‌

32. Docstring 是什么？

Docstring 是文档字符串，用于说明其用途、参数、返回值等，可通过 doc 属性访问，并被 IDE 和文档工具识别。‌

• docstring必须紧跟在函数定义后,且只有第一段字符串会被识别为文档字符串。

def add(a, b):
"""返回两个数的和"""
return a + b

补充： Docstring 和普通注释的区别：

普通注释运行时不会被保存。 Docstring 会被 Python 保存，可以通过 doc 或 help() 查看。

print(add.__doc__)
help(add)

33. is、not、in

a is b

判断两个变量是不是同一个对象。

a == b

判断两个值是否相等。

not True

取反。

3 in [1, 2, 3]

判断元素是否存在。

面试重点：is 比较对象身份，== 比较值是否相等。

34. help() 和 dir()

help() 用来看帮助文档：

help(str)

dir() 用来看对象有哪些属性和方法：

dir(list)

35. Python 退出时为什么不一定清理所有内存？

Python 退出时会尝试清理大部分对象。

但有些循环引用、全局对象、C 扩展占用的内存可能不会逐个释放。最终操作系统会回收进程资源。

44. Python 内置类型

常见内置类型：

int # 整数
float # 小数
complex # 复数
str # 字符串
bool # 布尔
list # 列表
tuple # 元组
dict # 字典
set # 集合

93. 标识符最大长度是多少？

Python 标识符理论上可以很长，没有固定最大长度限制。

标识符就是变量名、函数名、类名等。

94. 为什么不鼓励下划线开头变量？

因为约定俗成：单下划线开头表示“内部使用，不建议外部访问”。

比如

_name

表示内部使用，不建议外部访问。

不是强制私有，只是一种约定。

95. 哪个声明无效？

abc = 1000 2000 3000

无效，因为数字之间没有运算符，也没有逗号。

补充：

注意：

abc = 1,000,000

这是有效的，但它表示一个元组：

(1, 0, 0)

B. 列表、元组、字典、字符串、索引：1、15、21、29、30、36、39～41、46、47、53、91、97

1. 列表和元组区别

列表 list 用 []，可以修改。 元组 tuple 用 ()，一般不能修改。

列表 list：

a = [1, 2, 3]
a[0] = 100

元组 tuple：

b = (1, 2, 3)

面试答法：

列表是可变对象，适合存放需要修改的数据；元组是不可变对象，适合存放固定数据。列表用 []，元组用 ()。

15. 数组和列表区别

Python 列表可以放不同类型：

a = [1, "hello", 3.14]

数组通常要求元素类型一致。

比如：

from array import array
a = array("i", [1, 2, 3])

NumPy 数组也通常是同一种类型，适合计算。

21. [::-1] 是什么？

[::-1]表示反转序列。

s = "abc"
print(s[::–1]) # cba

输出：

cba

可以用来判断回文。

29. 字符串首字母大写

使用 capitalize()。

"hello".capitalize()

结果：

"Hello"

30. 字符串转小写

"HELLO".lower()

结果：

"hello"

36. 字典是什么？

字典dict是键值对结构。

person = {
"name": "Tom",
"age": 18
}

通过 key 找 value：

person["name"]

结果是：

"Tom"

39. len() 函数有什么作用？

len()用来获取长度。

len("abc") # 3
len([1, 2, 3]) # 3
len({"a": 1, "b": 2})

40. split、sub、subn

普通字符串的 split()用来切分字符串。

"a,b,c".split(",")

结果：

["a", "b", "c"]

正则模块 re 中：

re.split() # 按正则切分。
re.sub() # 按正则替换。
re.subn() # 替换并返回替换次数。

sub() 是替换，subn() 替换并返回替换次数。

41. 负索引

负索引是从后往前取元素。

a = [10, 20, 30]

print(a[–1])
print(a[–2])

输出：

30
20

-1表示最后一个元素。

46. 添加元素

重点融合内容：

a = [1, 2]
a.append(3) # 末尾加一个
a.extend([4, 5]) # 末尾加多个
a.insert(0, 100) # 指定位置插入

append() 添加一个元素。 extend() 添加多个元素。 insert() 在指定位置插入。

47. 删除元素

a.pop()

删除并返回最后一个元素。

a = [1, 2, 3]
a.remove(2)

remove() 按值删除，不返回删除值。

53. split 函数

a = "edureka python"
print(a.split())

结果：

["edureka", "python"]

91. 哪些语句创建字典？

正确：

d = {}
d = {"john": 40, "peter": 45}
d = {40: "john", 45: "peter"}

错误：

d = (40: "john", 45: "50")

字典外层必须用 {}，并且是 key-value 结构。

97. list1[-1]

list1 = [2, 33, 222, 14, 25]
list1[–1]

结果：

25

-1 表示最后一个元素。

C. 函数、参数、迭代器、生成器、随机数：16、18、20、22～25、27、28、37、38、54、85

16. 函数是什么？

函数是一段可以重复使用的代码。

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

print(add(1, 2))

函数的作用是减少重复代码。

18. lambda 函数

lambda 是匿名函数，适合写简单函数。

f = lambda x: x + 1
print(f(2)) # 3

等价于：

def f(x):
return x + 1

20. break、continue、pass

break：结束整个循环。 continue：跳过当前循环，进入下一轮。 pass：什么都不做，只是占位。

break

直接结束循环。

continue

跳过本轮循环，进入下一轮。

pass

什么都不做，只是占位。

例子：

for i in range(5):
if i == 2:
continue
print(i)

输出不会有 2。

22. 随机打乱列表

使用 random.shuffle()。

from random import shuffle

x = ["Keep", "The", "Blue"]
shuffle(x)
print(x)

shuffle() 会原地打乱列表。

23. 迭代器是什么？

迭代器是可以被 next() 一个一个取值的对象。

a = iter([1, 2, 3])
print(next(a)) # 1
print(next(a)) # 2

24. 生成随机数

使用 random 模块。

import random

random.random()

生成 0 到 1 之间的小数。

常见方法：

random.randint(1, 10)
random.randrange(1, 10)
random.uniform(1, 10)

25. range 和 xrange 区别

这是 Python 2 的问题。

Python 2：

range()

直接生成列表。

xrange()

按需生成，更省内存。

Python 3 里：

面试按 Python 3 答：

Python 3 中只有 range()，它返回一个 range 对象，不会一次性生成完整列表，节省内存。

27. pickling 和 unpickling

Pickling 序列化：把 Python 对象保存成二进制数据。

Unpickling 反序列化：把保存的数据还原成 Python 对象。

import pickle

data = {"name": "Tom"}

with open("data.pkl", "wb") as f:
pickle.dump(data, f)

with open("data.pkl", "rb") as f:
obj = pickle.load(f)

28. 生成器是什么？

生成器是一种特殊迭代器，用 yield 返回数据。

def gen():
yield 1
yield 2
yield 3

g = gen()

print(next(g))
print(next(g))

优点：

• 不会一次性把所有数据放进内存。
• 用到一个生成一个。
• 适合处理大量数据。

37. 三元运算符

格式： 值1 if 条件 else 值2

big = x if x > y else y

意思是：

如果 x > y，big 等于 x，否则等于 y。

38. *args 和 **kwargs

*args 接收多个位置参数，结果是元组。

def test(*args):
print(args)

test(1, 2, 3)

结果：

(1, 2, 3)

**kwargs 接收多个关键字参数，结果是字典：

def test(**kwargs):
print(kwargs)

test(name="Tom", age=18)

结果：

{"name": "Tom", "age": 18}

54. 如何在 Python 中导入模块？

重点融合内容：

import math

使用：

math.sqrt(16)

起别名：

import math as m
print(m.sqrt(16))

只导入某个函数：

from math import sqrt
print(sqrt(16))

不推荐滥用：

from math import *

因为容易命名冲突。

面试建议说：

推荐使用 import module 或 from module import name，不推荐大量使用 import *，因为容易命名冲突。

85. map 函数

map() 会把一个函数应用到序列的每个元素上。

nums = [1, 2, 3]
result = map(lambda x: x * 2, nums)
print(list(result))

结果：

[2, 4, 6]

map() 返回的是一个迭代器，所以通常需要用 list() 转换后查看结果。

D. 面向对象：17、19、48、55～64

17. __init__ 是什么？

__init__ 是初始化方法，创建对象时自动执行。

class Person:
def __init__(self, name):
self.name = name

p = Person("Tom")

创建 p 时，会自动调用 __init__。

19. self 是什么？

self 代表当前对象自己。

class Person:
def __init__(self, name):
self.name = name

self.name 是对象自己的名字。

48. Python 有 OOP 概念吗？

有。Python 支持面向对象编程，包括类、对象、继承、多态、封装等。

55. 继承是什么？

继承就是子类可以使用父类的属性和方法。

class Animal:
def eat(self):
print("eat")

class Dog(Animal):
pass

d = Dog()
d.eat()

56. 创建类

class Employee:
def __init__(self, name):
self.name = name

e1 = Employee("abc")
print(e1.name)

57. Python 补丁 / 猴子补丁

运行时动态修改类或模块的行为。

class A:
def hello(self):
print("hello")

def new_hello(self):
print("new hello")

A.hello = new_hello

这叫 monkey patch，灵活但容易让代码难维护。

58. Python 支持多重继承吗？

支持。

class A:
pass

class B:
pass

class C(A, B):
pass

59. 多态是什么？

同一个方法名，不同对象有不同表现。

class Dog:
def speak(self):
print("wang")

class Cat:
def speak(self):
print("miao")

调用 speak()，不同对象结果不同。

60. 封装是什么？

封装就是把数据和操作数据的方法放在类里。

class Person:
def __init__(self, name):
self.name = name

def say_hi(self):
print("Hi", self.name)

61. 数据抽象是什么？

抽象就是只暴露必要功能，隐藏内部细节。

比如你调用：

list.sort()

你不用关心它内部怎么排序。

62. Python 有访问修饰符吗？

Python 没有 Java 那种严格的 private/public。

但有约定：

_name # 受保护风格，提示内部使用
__name # 名称改写，较难从外部直接访问

63. 空类

class Empty:
pass

pass 是占位语句。

64. object() 函数

object() 返回一个最基础的对象。所有类最终都继承自 object。

E. 文件、异常、复制、多线程：43、49～52、70、96、98～100

43. 删除文件

import os
os.remove("test.txt")

49. 浅拷贝和深拷贝

浅拷贝只复制外层对象，里面的子对象还是共用。

深拷贝会递归复制里面的对象。

import copy

b = copy.copy(a) # 浅拷贝
c = copy.deepcopy(a) # 深拷贝

面试口诀：

浅拷贝拷贝外壳，深拷贝连里面一起拷贝。

50. Python 多线程和 GIL

Python 有多线程，但 CPython 有 GIL，全局解释器锁。

面试可以说：

GIL 使得同一时刻只有一个线程执行 Python 字节码，所以 CPU 密集型任务多线程不一定更快；I/O 密集型任务可以使用多线程提高效率。

51. Python 编译和链接

这题偏 C 扩展。简单答：

Python 可以通过 C/C++ 扩展提升性能。扩展模块需要编译成动态库，再由 Python 解释器加载。

52. Python 库

库就是一组模块或包。

常见库：

NumPy
Pandas
Matplotlib
Scikit–learn
Requests
Flask
Django

70. 统计文件中大写字母数量

推荐写法：

count = 0

with open("data.txt", "r", encoding="utf-8") as f:
for line in f:
for char in line:
if char.isupper():
count += 1

print(count)

一行写法：

count = sum(1 for line in f for char in line if char.isupper())

PDF 里少了一个 =，正确是 count = sum(…)。

96. 异常题

代码：

raise "someError"

在 Python 3 中是无效的，因为异常必须继承自 BaseException。

正确答案：无效代码。

正确写法：

raise Exception("someError")

98. 打开文件写入

正确：

outfile = open("c:\\\\scores.txt", "w")

或者：

outfile = open(r"c:\\scores.txt", "w")

答案选 w，因为 w 表示写入。

99. with 打开文件后是否关闭？

with open("data.txt", "w") as f:
pass
print(f.closed)

结果：

True

因为 with 代码块结束后会自动关闭文件。

注意：PDF 里的 print f.closed 是 Python 2 写法，Python 3 应该写：

print(f.closed)

100. try-except-else 中 else 什么时候执行？

没有异常时执行。

try:
print("ok")
except:
print("error")
else:
print("no error")

F. 算法题：65～72

65. 冒泡排序

冒泡排序思想：

相邻两个数比较，大的往后放。每一轮都会把当前最大的数“冒泡”到最后。

def bubble_sort(a):
n = len(a)
for i in range(n – 1):
for j in range(n – 1 – i):
if a[j] > a[j + 1]:
a[j], a[j + 1] = a[j + 1], a[j]
return a

print(bubble_sort([32, 5, 3, 6, 7, 54, 87]))

输出：

[3, 5, 6, 7, 32, 54, 87]

66. 星号三角形

def star_triangle(r):
for x in range(r):
print(" " * (r – x – 1) + "*" * (2 * x + 1))

star_triangle(5)

输出大概是：

*
***
*****
*******
*********

67. Fibonacci 数列

规律：

0, 1, 1, 2, 3, 5, 8…

后一个数 = 前两个数之和。

n = int(input("Enter the terms: "))

a = 0
b = 1

for i in range(n):
print(a, end=" ")
a, b = b, a + b

68. 判断素数

素数：只能被 1 和自己整除的数。

num = int(input("enter number: "))

if num <= 1:
print("not prime")
else:
for i in range(2, num):
if num % i == 0:
print("not prime")
break
else:
print("prime")

69. 判断回文

回文就是正着读和反着读一样。

a = input("enter sequence: ")

if a == a[::–1]:
print("palindrome")
else:
print("not palindrome")

71. 列表排序

lst = ["1", "4", "0", "6", "9"]
lst = [int(i) for i in lst]
lst.sort()
print(lst)

结果：

[0, 1, 4, 6, 9]

72. 阅读代码求值

重点知识：

zip()
dict()
range()
sorted()
列表推导式
字典推导式

结果：

A0 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
A1 = range(0, 10)
A2 = []
A3 = [1, 2, 3, 4, 5]
A4 = [1, 2, 3, 4, 5]
A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]

其中 A2 = []，因为 A1 里是数字，A0 的 key 是 'a' 'b' 'c'，所以没有匹配项。

G. Web 框架与爬虫：73～84

73. Flask 是什么？

Flask 是 Python 的轻量级 Web 框架。

面试答法：

Flask 是一个微框架，简单灵活，适合小型项目或接口服务。它依赖较少，常配合 Werkzeug、Jinja2 使用。

74. Django 和 Flask 比较

Flask：

轻量、自由、灵活，很多功能需要自己选扩展。

Django：

大而全，自带 ORM、后台管理、认证、模板系统，适合中大型项目。

75. Django、Pyramid、Flask 差异

Flask：小型项目，轻量灵活。

Pyramid：中大型项目，配置灵活。

Django：大而全，自带 ORM、Admin、认证等功能。

76. Django 架构

Django 常说 MVT：

Model 数据模型
View 业务逻辑
Template 页面模板

URL 把请求映射到 View。

77. Django 设置数据库

在 settings.py 中配置 DATABASES。

常见数据库：

SQLite
MySQL
PostgreSQL
Oracle

78. Django View 示例

from django.http import HttpResponse
import datetime

def current_datetime(request):
now = datetime.datetime.now()
html = f"<html><body>It is now {now}</body></html>"
return HttpResponse(html)

PDF 里的字符串格式有点旧，建议用 f-string。

79. Django 模板组成

模板是文本文件，里面包含：

变量
标签
过滤器
HTML 内容

例如：

Hello, {{ name }}

80. Django Session

Session 用来在多次请求之间保存用户状态。

比如登录后，服务器需要记住“这个用户已经登录”。

Django 通常通过 cookie 保存 session id，真正的数据保存在服务器端。

81. Django 继承样式

三种：

抽象基类
多表继承
代理模型

82. 根据 URL 保存图片

import urllib.request

urllib.request.urlretrieve("图片URL", "local-filename.jpg")

83. 获取 Google 缓存页面

PDF 给的是 Google cache URL 格式。这题现在实战意义不强，面试简单说：

可以通过 Google cache 的特殊 URL 查询网页缓存，但实际可用性取决于 Google 是否缓存该页面。

84. 爬取 IMDb 前 250 电影

核心流程：

requests 请求网页
BeautifulSoup 解析 HTML
find / find_all 提取数据
循环输出电影名、年份、评分

面试不一定要求背代码，重点是知道爬虫流程：

import requests
from bs4 import BeautifulSoup

url = "https://www.imdb.com/chart/top"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

H. NumPy、SciPy、数据分析：45、86～90

45. NumPy 相比 Python 列表的优势

Python 列表灵活，但数值计算慢。

NumPy 数组：

类型统一
内存更省
计算更快
支持向量化运算

86. NumPy 比列表好吗？

做数值计算时，NumPy 更好。

比如：

import numpy as np

a = np.array([1, 2, 3])
print(a * 2)

结果：

[2 4 6]

列表不能直接这样做数值向量运算。

87. NumPy 数组中 N 个最大值的索引

import numpy as np

arr = np.array([1, 3, 2, 4, 5])
print(arr.argsort()[–3:][::–1])

结果是最大 3 个值的索引。

88. NumPy 计算百分位数

import numpy as np

a = np.array([1, 2, 3, 4, 5])
p = np.percentile(a, 50)
print(p)

50 分位数就是中位数，结果：

3.0

89. NumPy 和 SciPy 区别

NumPy：核心是数组和基础数值计算。

SciPy：建立在 NumPy 上，提供更多科学计算功能，比如优化、积分、信号处理、线性代数等。

90. NumPy/SciPy 做 3D 可视化

NumPy 和 SciPy 本身主要负责计算，不负责高级绘图。

常用：

Matplotlib 的 mplot3d
Mayavi
Plotly

三、python中的装饰器：

Python 装饰器本质上是一个函数，它接收另一个函数作为参数，并返回一个新的函数。它的作用是在不修改原函数代码的情况下，给原函数增加额外功能，比如日志记录、权限校验、计时、缓存等。

• @decorator 这种写法只是语法糖，本质上等价于 func = decorator(func)。

下面的代码例子： 把 say_hello 这个函数交给 my_decorator 包装一下，然后用包装后的新函数替换原来的 say_hello。

def my_decorator(func):
def wrapper():
print("函数执行前")
func()
print("函数执行后")
return wrapper

@my_decorator
def say_hello():
print("Hello!")

say_hello()

这段代码等价于下面这样写：

def my_decorator(func):
def wrapper():
print("函数执行前")
func()
print("函数执行后")
return wrapper

def say_hello():
print("Hello!")

say_hello = my_decorator(say_hello)

say_hello()

重点在这一句：

say_hello = my_decorator(say_hello)

原来的 say_hello 函数被传进了 my_decorator：

my_decorator(say_hello)

所以在 my_decorator 里面：

func

其实就是原来的 say_hello。

问： 为什么func()等于调用原来的等于调用原来的say_hello()。

答： 在 Python 里，函数也可以像普通变量一样被传来传去。

因为函数名本质上是一个变量名，类似于：

def say_hello():
print("Hello!")

可以理解成 Python 创建了一个函数对象，然后让名字 say_hello 指向它。

类似于x = 10，这里 x 指向数字 10。

再更简单解释一下装饰器，面试说：

一句话：

• 装饰器本质是一个高阶函数，用来在不修改原函数代码的情况下增强功能，比如日志、计时、权限校验。

下面例子： @timer 等价于 run = timer(run)

import time
from functools import wraps

def timer(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"{func.__name__} cost {time.time() – start:.4f}s")
return result
return wrapper

@timer
def run():
time.sleep(1)
return "done"

四、面试中最重点的 20 几个高频考题

GIL

GIL 是 CPython 的全局解释器锁，导致同一时刻只有一个线程执行 Python 字节码。所以 CPU 密集型任务用多线程提升有限，更适合多进程；I/O 密集型任务比如网络请求、文件读写，多线程仍然有效，因为等待 I/O 时可以释放执行权。

深拷贝浅拷贝

浅拷贝只复制最外层容器，内部可变对象仍然共享；深拷贝会递归复制内部对象。比如 list 里嵌套 list 时，浅拷贝修改内部 list 会影响原对象。

生成器 / yield

生成器是惰性计算的迭代器，使用 yield 返回值并保存函数执行状态，适合处理大文件、流式数据、训练数据逐批加载等场景。

__new__ 和 __init__

__new__ 负责创建对象，返回实例；__init__ 负责初始化对象属性。单例模式会用到 __new__ 控制只创建一个实例。

1. 装饰器

一句话：

装饰器本质是一个高阶函数，用来在不修改原函数代码的情况下增强功能，比如日志、计时、权限校验。

代码模板：

import time
from functools import wraps

def timer(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"{func.__name__} cost {time.time() – start:.4f}s")
return result
return wrapper

@timer
def run():
time.sleep(1)
return "done"

面试重点不是代码多复杂，而是你要说出：

@timer 等价于 run = timer(run)。

2. GIL

一句话：

GIL 是 CPython 的全局解释器锁，保证同一时刻只有一个线程执行 Python 字节码。

怎么答应用场景：

你可以结合自己项目说：

我在训练和推理项目里更多遇到的是 GPU、CUDA、dtype、数据加载和进程管理问题，真正计算密集部分一般由 PyTorch 底层 C++/CUDA 执行。

3. 深拷贝和浅拷贝

一句话：

浅拷贝只复制最外层对象，内部嵌套的可变对象仍然共享；深拷贝会递归复制所有层级。

例子：

import copy

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

a[0].append(99)

print(b) # [[1, 2, 99], [3, 4]]
print(c) # [[1, 2], [3, 4]]

4. 生成器和 yield

一句话：

生成器是一种惰性迭代器，用 yield 返回数据，并保存函数执行状态。

适用场景：

简单代码：

def my_range(n):
for i in range(n):
yield i

for x in my_range(3):
print(x)

5. __new__ 和 __init__

一句话：

__new__ 负责创建对象，__init__ 负责初始化对象。

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

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

常见追问是单例模式：

class Singleton:
_instance = None

def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance

6. 异常处理顺序

记住这个顺序：

try:
print("可能出错的代码")
except Exception:
print("出错时执行")
else:
print("没出错时执行")
finally:
print("无论是否出错都执行")

一句话：

else 只有没有异常时执行，finally 无论是否异常都会执行，常用于释放资源。

7. 垃圾回收

一句话：

Python 主要使用引用计数，辅以标记清除和分代回收，解决循环引用等问题。

你能答到这个程度就够了：