Nólëbase

切换主题

华为OD杭州 Python开发面试面经 ​

字数
7373 字
阅读时间
30 分钟

候选人: 陈启明 | 岗位: 华为OD杭州 Python开发 | 学历: 本科应届（无实习/工作经验）

第一部分：项目介绍（按STAR法则组织） ​

1.1 开场白（30秒自我介绍） ​

"面试官您好，我叫陈启明，是一名应届毕业生。我的技术栈主要是Python后端开发，熟悉FastAPI、数据处理和AI应用开发。我最近独立完成了一个毕业设计项目——智能表单映射填充系统，这是一个结合了FastAPI、LangChain和Selenium的自动化数据录入系统。我在项目中主要负责后端全栈开发，包括API设计、数据处理、AI Agent集成和浏览器自动化等核心模块。下面我简单介绍一下这个项目。"

1.2 项目介绍（3-5分钟版本） ​

S（Situation）- 背景 ​

企业日常办公中存在大量跨系统数据录入场景，比如将Excel表格的数据填写到各种Web表单中。传统的人工填写方式效率低、易出错，尤其是当数据量大、字段命名不一致时（比如源数据叫"姓名"，目标表单叫"申请人"），手动映射非常繁琐。

T（Task）- 任务 ​

我负责设计并实现一个能够自动识别源数据与目标表单字段对应关系的智能系统，核心挑战在于：

  1. 如何从多种数据源（Excel、SQL、网页）统一读取数据
  2. 如何理解源数据列和目标表单字段之间的语义对应关系
  3. 如何自动将数据批量填入目标网页表单

A（Action）- 行动 ​

我采用了分层架构+Agent模式的设计方案：

技术选型：

  • 后端框架：FastAPI（异步高性能，自动生成API文档）
  • AI框架：LangChain 1.x（Agent模式 + 工具调用链）
  • 大模型：阿里云百炼 Qwen-turbo（中文语义理解强）
  • 浏览器自动化：Selenium + Firefox
  • 数据处理：Pandas

核心实现：

  1. 多源数据接入层：设计了DataIngestionService统一入口，根据数据源类型（Excel/SQL/URL）分发到不同的工具类处理。Excel读取采用双引擎策略（openpyxl为主，xlrd降级）；SQL解析用正则表达式提取CREATE TABLE和INSERT；网页抓取采用静态解析优先（pandas.read_html）、失败后降级为Selenium动态渲染。

  2. AI字段映射核心：这是系统最核心的创新点。我使用LangChain的Agent模式，让大模型扮演"数据映射专家"角色，通过调用两个自定义工具（analyze_source_columns和analyze_target_fields）来获取源数据和目标字段的详细信息，然后进行语义推理，输出JSON格式的映射建议。如果大模型调用失败，自动降级为基于字符串包含关系的规则匹配。

  3. 智能选项匹配：针对下拉框、单选框、复选框的选项值匹配，设计了双策略机制：首选大模型直接匹配，失败则降级为同义词匹配（调用大模型生成同义词后精确匹配）。

  4. 浏览器自动化填充：封装了BrowserFillerTool，使用Selenium控制Firefox浏览器。字段定位采用4级优先级策略（NAME → ID → XPath placeholder → label关联），支持文本输入、下拉选择、单选、复选框四种字段类型。

  5. 容错与优化：实现了双层降级策略（Agent→规则匹配，LLM→同义词匹配）、浏览器操作重试机制（最多2次）、进程内内存缓存（避免重复数据处理）、批量填充限制（最多100条，防止资源过度消耗）。

R（Result）- 成果 ​

  • 系统支持Excel(.xlsx/.xls)、SQL、网页URL三种数据源的统一接入
  • AI字段映射覆盖率达到80%以上，经人工校验准确率达到95%
  • 可在10秒内完成单个表单的解析和映射推荐
  • 批量填充支持最多100条记录，可导出为Excel或CSV文件
  • 系统已通过完整的端到端测试，可正常运行演示

1.3 项目亮点/难点追问（提前准备） ​

Q: 这个项目的核心亮点是什么？ ​

"我认为有两个核心亮点。第一是AI驱动的字段映射机制——传统方案通常用规则匹配，但面对语义差异较大的字段（如'申请人' vs '姓名'）很难处理。我引入LangChain Agent模式，让大模型通过工具调用获取上下文信息后再推理映射关系，这比直接prompt一次输出更准确。第二是多源数据的统一处理——我设计了DataIngestionService作为统一入口，不同数据源只需实现各自的读取工具，然后统一走清洗流程，扩展性很好。"

Q: 项目中遇到的最大技术难点是什么？如何解决的？ ​

"最大的难点是网页表单结构的多样性。不同网站的表单结构差异很大：有的用标准的label+for关联，有的用包裹式label，有的只有placeholder，还有的使用aria-label做无障碍设计。我为此设计了6优先级标签提取策略：

  1. 通过id查找for=该id的label（最标准）
  2. 查找父级label包裹
  3. aria-label属性
  4. placeholder属性
  5. title属性
  6. name/id属性兜底

这样无论网站用哪种方式标记字段标签，系统都能正确识别。"

Q: 为什么选择FastAPI而不是Flask或Django？ ​

"选择FastAPI主要基于三点：

  1. 性能优势：FastAPI基于Starlette和Pydantic，支持原生异步，性能接近Node.js和Go，比Flask/Django同步框架高一个量级
  2. 类型提示：基于Pydantic的类型校验，开发时就能发现类型错误，开发体验好
  3. 自动文档：自动生成OpenAPI/Swagger文档，前后端协作效率高

而Flask太轻量缺乏开箱即用的功能，Django又太重且同步，FastAPI正好适合构建这种数据处理密集型的API服务。"

Q: 为什么使用LangChain Agent而不是直接调用LLM API？ ​

"直接调用LLM的方式是一次性把所有信息塞进prompt让模型输出结果，但当数据量大时prompt会很长，模型容易丢信息。LangChain Agent的优势在于思考-行动循环：

  1. Agent先调用analyze_source_columns工具获取源数据的详细列信息
  2. 再调用analyze_target_fields工具获取目标字段的详细信息
  3. 最后综合两次获取的信息进行推理

这种分步获取信息的方式准确率更高，而且通过@tool装饰器可以方便地扩展新工具，系统的可扩展性更好。"

Q: 系统的容错机制是怎样设计的？ ​

"我设计了双层降级容错机制：

  1. 字段映射层降级：AI Agent映射失败时（比如API超时），自动降级为基于字符串包含关系的规则匹配（源列名包含目标字段名或反之）
  2. 选项匹配层降级：大模型选项匹配失败时，降级为先调用大模型生成同义词列表，再进行精确字符串匹配

此外还有：浏览器操作的重试机制（最多2次，每次间隔2秒）；网页抓取的静态解析→动态渲染降级策略。这些容错机制保证了系统在部分功能不可用时仍能正常工作。"

Q: 系统目前有哪些局限？你认为如何改进？ ​

"当前局限及改进方向：

  1. 内存缓存不支持分布式：目前用进程内dict缓存，单机够用但多实例部署会有问题。改进方案是引入Redis做分布式缓存
  2. 批量填充效率低：每条记录都创建新的浏览器实例，资源消耗大。改进方案是复用浏览器会话，通过多标签页或iframe实现并行填充
  3. 字段映射的准确率依赖大模型：改进方向是加入人工反馈机制，积累映射数据后可以训练轻量级的相似度模型（如sentence-transformers）作为主方案，大模型作为兜底
  4. 仅支持3种数据源：可以扩展JSON、CSV、REST API等数据源类型"

Q: 100条记录的填充限制是怎么定的？ ​

"这个限制主要基于资源考量：每条记录填充需要创建新的Firefox浏览器实例（当前实现为了可视化而采用非headless模式），100条就是100个实例，普通机器很难承载。这个限制写在FillAgent的fill()方法开头，生产环境可以通过复用浏览器会话或改为headless模式来提升上限。"

第二部分：Python核心八股文 ​

2.1 Python基础 ​

Q: Python的可变类型和不可变类型有哪些？ ​

不可变类型：int、float、str、tuple、frozenset、bytes 可变类型：list、dict、set、bytearray

判断方式：对对象执行修改操作后，id()值是否改变。不变的就是不可变类型。

常见陷阱：

python
a = [1, 2]
b = a
b.append(3)
# a也变成[1, 2, 3]，因为list是可变类型，a和b指向同一个对象

Q: == 和 is 的区别？ ​

  • ==：比较值是否相等，调用__eq__方法
  • is：比较身份是否相同，即id()是否相同

注意：小整数池(-5~256)和短字符串的缓存机制会让is在特定情况下为True，但不能依赖

Q: Python的内存管理机制？ ​

  1. 引用计数：Python主要的垃圾回收机制，对象引用计数为0时立即回收
  2. 标记清除（Mark-Sweep）：针对循环引用，每隔一定时间扫描对象，标记存活对象，清除未标记对象
  3. 分代回收（Generational）：Python3.4+的分代垃圾回收，将对象分为三代（0/1/2），新对象在第0代，经历GC存活后晋升到下一代，不同代的GC频率不同

触发时机：当对象分配数减去释放数超过阈值时触发

Q: 深拷贝和浅拷贝的区别？ ​

  • 浅拷贝：只拷贝第一层，内层引用的对象是共享的
    • 实现方式：list.copy()、dict.copy()、copy.copy()、list[:]
  • 深拷贝：递归拷贝所有层级，完全独立
    • 实现方式：copy.deepcopy()
python
import copy
a = [[1, 2], [3, 4]]
b = copy.copy(a)       # 浅拷贝
c = copy.deepcopy(a)   # 深拷贝
a[0].append(3)
# b[0]也变成[1, 2, 3]，c[0]不变

Q: *args 和 **kwargs 的作用？ ​

  • *args：可变位置参数，接收任意数量的位置参数，类型为tuple
  • **kwargs：可变关键字参数，接收任意数量的关键字参数，类型为dict
python
def func(a, *args, **kwargs):
    print(a)        # 第一个位置参数
    print(args)     # 剩余位置参数的tuple
    print(kwargs)   # 关键字参数的dict

2.2 Python进阶 ​

Q: 装饰器的原理和实现？ ​

装饰器本质是闭包+函数调用，作用是在不修改原函数代码的前提下扩展功能。

python
import functools
def timer(func):
    @functools.wraps(func)  # 保留原函数的名称和文档
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        print(f"耗时: {time.time() - start}")
        return result
    return wrapper

@timer  # 等价于 func = timer(func)
def my_func():
    pass

应用场景：日志记录、性能计时、权限校验、缓存

Q: 生成器和迭代器的区别？ ​

  • 迭代器：实现了__iter__()和__next__()方法的对象，可以被next()调用逐个返回值
  • 生成器：一种特殊的迭代器，通过yield关键字实现，每次yield暂停执行并返回一个值

优势：节省内存，按需生成值而不是一次性生成所有值

python
# 生成器函数
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

Q: 列表推导式和生成器表达式的区别？ ​

  • 列表推导式：[x*x for x in range(1000000)]，一次性生成所有值，占用内存
  • 生成器表达式：(x*x for x in range(1000000))，惰性求值，几乎不占用内存

当数据量大时优先使用生成器表达式

Q: GIL是什么？对Python有什么影响？ ​

GIL（全局解释器锁）：CPython的一把全局互斥锁，确保在任何时刻只有一个线程在执行Python字节码。

影响：

  • 多线程在CPU密集型任务中没有优势（因为GIL，CPU密集型用多进程）
  • 多线程在IO密集型任务中有效（IO操作会释放GIL）

解决方案：多进程（multiprocessing）、使用C扩展绕过GIL、使用其他Python解释器（如PyPy）

Q: 多进程、多线程、协程的区别？ ​

类型资源开销切换速度适用场景
多进程大慢CPU密集、需要并行计算
多线程中中IO密集、需要共享内存
协程极小极快高并发IO（如异步网络请求）

Python中协程通过asyncio实现，使用async/await语法

Q: 闭包是什么？ ​

闭包是引用了外部函数变量的内部函数，即使外部函数已经返回，内部函数仍然可以访问这些变量。

python
def make_counter():
    count = 0  # 被闭包引用的变量
    def counter():
        nonlocal count  # nonlocal声明修改外层变量
        count += 1
        return count
    return counter

Q: Python的魔术方法（dunder）有哪些？ ​

常用魔术方法：

  • __init__：构造方法
  • __str__/__repr__：字符串表示（str面向用户，repr面向开发）
  • __eq__/__hash__：相等性比较和哈希
  • __getitem__/__setitem__：下标访问，支持obj[key]
  • __iter__/__next__：迭代支持
  • __enter__/__exit__：上下文管理器（with语句）
  • __call__：让对象可调用
  • __slots__：限制实例属性，节省内存

2.3 函数式编程与面向对象 ​

Q: lambda表达式和普通函数的区别？ ​

lambda是匿名函数，只能包含一个表达式，可与map/filter/sorted等配合使用。

python
# lambda主要用于简单的、一次性的函数逻辑
sorted(students, key=lambda s: s.score)
# 复杂逻辑仍用def定义函数

Q: map、filter、reduce的用法？ ​

python
from functools import reduce
# map：对每个元素应用函数
list(map(str.upper, ['a', 'b', 'c']))  # ['A', 'B', 'C']
# filter：过滤满足条件的元素
list(filter(lambda x: x > 0, [-1, 0, 1, 2]))  # [1, 2]
# reduce：累计计算
reduce(lambda x, y: x + y, [1, 2, 3, 4])  # 10

Q: 类的继承、多态、封装？ ​

  • 封装：通过_或__前缀约定私有属性/方法，使用property装饰器实现getter/setter
  • 继承：通过class Child(Parent)继承，支持多继承（MRO C3线性化）
  • 多态：不同类实现相同方法名，调用时根据实际类型执行对应实现

注意：Python是鸭子类型，不强制需要继承，只要有相同的方法名即可多态

Q: init 和 new 的区别？ ​

  • __new__：创建对象，返回实例。是静态方法，第一个参数是类本身。在__init__之前调用
  • __init__：初始化已创建的对象，设置属性值。不能返回值

应用场景：单例模式用__new__，正常初始化用__init__

2.4 Python常用库 ​

Q: requests库和urllib的区别？ ​

  • requests是第三方库，API更友好，支持Session、自动处理编码、更简洁的API
  • urllib是标准库，但API复杂 实际开发中优先使用requests

Q: Pandas常用操作？ ​

python
df = pd.read_excel('file.xlsx')     # 读取Excel
df = pd.read_csv('file.csv')        # 读取CSV
df.head(5)                          # 前5行
df.describe()                       # 统计信息
df.groupby('column').mean()         # 分组聚合
df.merge(df2, on='key')             # 合并
df.to_excel('output.xlsx')          # 写出Excel

Q: FastAPI的核心特性？ ​

  1. 基于类型提示的自动参数校验（Pydantic）
  2. 自动生成OpenAPI/Swagger文档
  3. 原生异步支持（async/await）
  4. 依赖注入系统
  5. 中间件支持（CORS等）

第三部分：后端开发高频面试题 ​

3.1 FastAPI框架 ​

Q: FastAPI的请求生命周期是怎样的？ ​

  1. 请求进入ASGI服务器（Uvicorn）
  2. FastAPI路由器匹配路由
  3. 依赖注入系统解析依赖项
  4. Pydantic校验请求参数
  5. 执行路由处理函数
  6. 序列化响应为JSON
  7. 返回给客户端

Q: FastAPI如何实现参数校验？ ​

使用Pydantic模型定义请求/响应结构，FastAPI自动进行类型校验：

python
from pydantic import BaseModel
class Item(BaseModel):
    name: str
    price: float
    is_active: bool = True

@app.post("/items/")
async def create_item(item: Item):
    return item

Pydantic会自动校验类型、处理默认值、生成错误提示

Q: FastAPI的依赖注入怎么用？ ​

使用Depends()声明依赖，支持函数、类作为依赖项：

python
async def get_db():
    db = create_connection()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/")
async def read_items(db=Depends(get_db)):
    return db.query(Item).all()

Q: CORS是什么？FastAPI中如何配置？ ​

CORS（跨域资源共享）是浏览器安全机制，允许指定的域名访问后端API。

python
from fastapi.middleware.cors import CORSMiddleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://yourdomain.com"],  # 生产环境指定域名
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

注意：allow_origins=["*"]在生产环境有CSRF风险

3.2 数据库与缓存 ​

Q: MySQL的索引类型有哪些？ ​

  1. B+树索引：最常用，InnoDB默认索引类型，适合范围查询
  2. 哈希索引：等值查询快，不支持范围查询（Memory引擎支持）
  3. 全文索引：全文搜索，MyISAM和InnoDB都支持
  4. 空间索引：地理位置数据，MyISAM支持

聚簇索引 vs 非聚簇索引：InnoDB主键索引是聚簇索引（数据存在叶子节点），辅助索引是非聚簇索引

Q: 数据库事务的ACID特性？ ​

  • 原子性（Atomicity）：事务中操作要么全部成功要么全部失败
  • 一致性（Consistency）：事务前后数据状态保持一致
  • 隔离性（Isolation）：多个事务互不干扰
  • 持久性（Durability）：事务提交后数据永久保存

隔离级别：读未提交 → 读已提交 → 可重复读（MySQL默认） → 串行化

Q: Redis和Memcached的区别？ ​

特性RedisMemcached
数据结构支持string/hash/list/set/sorted set仅支持string
持久化支持RDB/AOF不支持
分布式支持主从、哨兵、集群需要客户端实现
内存管理更完善的LRU淘汰策略简单的LRU

在我的项目中，如果需要替换内存缓存，我会选择Redis，因为它支持持久化和分布式。

3.3 网络与协议 ​

Q: HTTP和HTTPS的区别？ ​

  • HTTP明文传输，HTTPS加密传输（TLS/SSL）
  • HTTPS默认端口443，HTTP默认端口80
  • HTTPS需要证书，HTTP不需要
  • HTTPS性能略低但安全性高

Q: TCP三次握手的过程？ ​

  1. 客户端发送SYN=1，seq=x
  2. 服务端返回SYN=1，ACK=1，seq=y，ack=x+1
  3. 客户端发送ACK=1，ack=y+1

为什么三次握手？两次不能确认双方的收发能力，四次没必要（第二次可以合并SYN和ACK）

Q: GET和POST的区别？ ​

  • GET参数在URL中，POST在请求体中
  • GET有长度限制，POST理论上无限制
  • GET可以缓存和收藏，POST不行
  • GET是幂等的，POST不是
  • POST比GET更安全（但都是明文）

3.4 设计模式 ​

Q: 项目中用到了哪些设计模式？ ​

  1. 策略模式：多源数据接入，不同数据源采用不同的读取策略
  2. 工厂模式：WebScraperTool中创建不同类型的driver
  3. 装饰器模式：FastAPI路由装饰器、Python函数装饰器
  4. 单例模式：服务层类实例在整个应用中只创建一次
  5. 模板方法：数据清洗流程固定，具体实现可配置
  6. 代理模式：Agent作为大模型调用的代理

Q: 单例模式的实现方式？ ​

python
# 方式1：模块级变量（最常用）
_instance = None
def get_instance():
    global _instance
    if _instance is None:
        _instance = Singleton()
    return _instance

# 方式2：__new__方法
class Singleton:
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

# 方式3：装饰器
def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

第四部分：AI/LangChain相关（项目加分项） ​

4.1 LangChain基础 ​

Q: LangChain的核心组件？ ​

  1. Models：大模型封装（ChatModel、LLM）
  2. Prompts：提示词模板
  3. Chains：将多个组件串联（如Prompt+LLM+Parser）
  4. Agents：基于LLM的决策代理，可调用工具
  5. Memory：对话历史存储
  6. Tools：Agent可调用的外部工具
  7. Retrieval：RAG相关，文档检索增强生成

Q: Agent和Chain的区别？ ​

  • Chain：固定的执行流程，步骤预先确定。适合简单的线性任务
  • Agent：动态决策流程，由LLM决定下一步做什么（思考-行动循环）。适合复杂的不确定任务

在我的项目中，字段映射用Agent模式，因为步骤取决于LLM的判断（先看源数据还是先看目标字段由模型决定）。

Q: @tool装饰器的作用？ ​

LangChain的@tool装饰器将普通Python函数转换为Agent可调用的工具：

python
from langchain.tools import tool

@tool
def analyze_source_columns(source_columns: list, source_sample: list) -> str:
    """分析源数据表的列结构"""
    # 函数实现
    return analysis_result

关键是函数的docstring必须清晰描述工具的功能和参数，LLM会根据docstring决定何时调用此工具。

4.2 大模型应用 ​

Q: Prompt Engineering的常用技巧？ ​

  1. 明确角色：设定LLM扮演的角色（如"你是一个数据映射专家"）
  2. 分步引导：将复杂任务拆分为多步骤执行
  3. 指定输出格式：要求输出JSON等结构化格式
  4. 提供示例：Few-shot learning，给1-2个示例
  5. 约束条件：明确"只映射确定的字段"、"不要强行映射"等规则

Q: 如何评估大模型输出的质量？ ​

  1. 格式校验：检查是否为合法JSON
  2. 内容校验：检查关键字段是否存在
  3. 置信度检查：检查置信度分数是否低于阈值
  4. 降级策略：校验失败时使用规则匹配作为兜底

在我的项目中，我设计了_extract_json方法提取JSON内容，并在解析失败时自动降级为规则匹配。

第五部分：综合素质类面试题 ​

5.1 自我认知类 ​

Q: 你觉得自己的优势是什么？ ​

"我认为我的优势是学习能力强和动手实践能力强。在做这个毕业设计项目时，我需要同时学习FastAPI、LangChain、Selenium等多个新技术栈，我通过阅读官方文档、查看GitHub示例、动手写代码的方式在两周内就掌握了核心用法。另外，我在项目中遇到问题时习惯直接看源码定位原因，而不是只搜博客答案，这让我对技术的理解更深入。"

Q: 你遇到的最大挫折是什么？如何解决的？ ​

"在开发智能表单映射功能时，我遇到过一个棘手的问题：当源数据列是英文（如'name'）、目标表单标签是中文（如'姓名'）时，AI Agent有时会输出空的映射结果。我花了两天时间排查，最后发现是Agent的递归限制设置过低导致的——Agent需要先调用两个工具获取信息再推理，递归深度不够时会在中间被截断。解决方法是将recursion_limit从默认的5调大到10。这个经历让我学会了遇到问题时不要急于改代码，先仔细阅读日志和错误信息定位根因。"

5.2 团队协作类（无实习可谈项目协作） ​

Q: 你如何与前端同学协作？ ​

"在我的项目中，虽然是独立开发，但我模拟了前后端协作流程：

  1. API设计时，我先设计好请求/响应的JSON结构，确保前端可以直接对接
  2. 使用FastAPI自动生成的Swagger文档作为接口文档
  3. 接口版本化设计（如/api/v1/），便于后续迭代
  4. 错误响应统一格式：{code, message, data} 这些实践让我理解了前后端协作的核心是接口契约的明确和稳定。"

Q: 如果让你和团队成员意见不一致，你会怎么处理？ ​

"首先我会用数据和事实说服对方，而不是只说自己的想法。比如在技术选型时，我会对比不同方案的性能、维护成本、社区活跃度等。如果还是不能达成一致，我会建议做一个小范围的POC（概念验证），用实际结果来决定。如果最终由领导决定，我会执行决定并做好风险预案。"

5.3 职业规划类 ​

Q: 为什么选择华为？ ​

"华为是全球领先的ICT解决方案提供商，我了解到华为的OD项目注重实战能力培养，有完善的导师制和成长路径。我对Python后端开发有扎实的基础和浓厚的兴趣，希望能在华为的平台上参与到有影响力的项目中，同时向更有经验的工程师学习，快速成长。杭州是我希望长期发展的城市，也期待能在华为的杭州团队贡献自己的力量。"

Q: 你的职业规划？ ​

"短期（1年内）：快速熟悉团队业务和技术栈，在导师指导下独立完成开发任务，提升代码质量和工程能力。 中期（1-3年）：成为团队中独当一面的后端工程师，能够负责核心模块的设计和实现，深入研究高并发、分布式等技术。 长期（3年以上）：向技术专家或技术管理方向发展，在自己深耕的技术领域形成影响力。"

附录：快速记忆清单 ​

技术栈关键词（简历上要能脱口而出） ​

  • FastAPI：异步高性能、Pydantic类型校验、自动API文档
  • LangChain Agent：思考-行动循环、@tool工具调用、语义推理映射
  • Selenium + Firefox：浏览器自动化、多策略字段定位
  • Pandas：数据清洗、Excel/CSV读写、DataFrame处理
  • 阿里云百炼 Qwen-turbo：中文语义理解、JSON结构化输出

核心设计关键词 ​

  • 分层架构：前端→API→服务→Agent→工具
  • 双层降级：Agent→规则、LLM→同义词
  • 多策略定位：4级字段定位、6级标签提取
  • 容错机制：重试、降级、异常捕获

Python八股高频考点 ​

  • GIL、装饰器、生成器/迭代器、深浅拷贝
  • 可变/不可变类型、==和is的区别
  • *args/**kwargs、闭包、魔术方法
  • 多进程/多线程/协程的区别和适用场景

面试前建议：

  1. 把项目介绍练熟，最好能对着演示边操作边讲解
  2. Python基础题反复过，尤其是GIL、装饰器、内存管理
  3. 对于没有实习的情况，重点突出独立完成项目的深度和思考过程
  4. 华为OD面试注重基础和潜力，不要过度追求技术深度，把基础打牢

贡献者 ​

The avatar of contributor named as freeway348 freeway348

文件历史 ​

用 ♥ 撰写

CC BY-SA 4.0 © 2022-PRESENT Nólëbase 的创作者们