5个致命坑：东城会技术认证避坑指南与最佳实践
刚拿到“东城会”技术认证的报名通知，是不是兴奋之余又有点慌？别急，我见过太多新人栽在第一步。很多人以为只要把官方文档里的代码复制粘贴进去就能过，结果一运行全是红字报错，或者跑通了但性能慢得让人想摔键盘。这种“复制来的代码跑不通不知道怎么调”的绝望感，是初学者最大的痛点。
今天咱们不聊虚的，直接切入正题。针对“东城会”认证中常见的5个技术坑，结合最佳实践，手把手教你怎么从“小白”变成“能干活”的开发者。这些坑，我踩了至少三年，现在总结出来给你避避雷。记住，认证不是为了拿那张纸，而是为了让你真正理解技术底层逻辑，别把最佳实践当成死记硬背的条文。
坑一：环境配置差异导致的“本地能跑线上崩”
现象：为什么我在笔记本上没问题，提交就报错？
这是新手最崩溃的时刻。你在自己的MacBook Pro上，Python 3.9跑得飞起，代码逻辑清晰，单元测试全绿。一旦提交到“东城会”的在线评测环境（通常是CentOS 7或Ubuntu 20.04容器），立马抛出ModuleNotFoundError或者SyntaxError。
很多初学者以为是自己代码写错了，开始疯狂检查逻辑，其实问题出在环境隔离上。
根本原因：版本锁定与依赖管理缺失
“东城会”的评测环境是固定版本的Linux容器，它不会自动安装你本地最新的库。如果你本地用的是Python 3.10，而评测环境是3.8，某些语法特性（如match语句）就会直接报错。更隐蔽的是依赖库的版本冲突。比如numpy在1.20和1.24之间的API有细微变动，如果你没锁定版本，评测环境拉取到的版本可能与你本地测试的不一致。
根据开发者文档（如PEP 440规范）的建议，生产级项目必须严格管理依赖版本。很多新人忽略这一点，以为“能用就行”，这在认证考试中是大忌。
正确写法对比
错误写法（未锁定版本，依赖隐式导入）：
# install: pip install pandas requests
import pandas as pd
import requestsdef fetch_data(url):# 这里假设 requests 版本较新，使用了某些新特性response = requests.get(url, timeout=5)df = pd.DataFrame(response.json())return df正确写法（显式指定版本，兼容处理）：
# requirements.txt 中必须明确指定版本
# pandas==1.3.5
# requests==2.26.0import pandas as pd
import requests
from typing import Dict, Anydef fetch_data(url: str) - pd.DataFrame:获取数据并转换为DataFrame注意：兼容Python 3.8+环境try:response = requests.get(url, timeout=5)response.raise_for_status() # 检查HTTP错误，避免静默失败data = response.json()# 确保数据格式符合预期，防止NoneType错误if not data:raise ValueError(Empty response data)df = pd.DataFrame(data)return dfexcept requests.exceptions.RequestException as e:raise Exception(fRequest failed: {e})复现与修复代码检查Python版本：在代码开头打印sys.version，确认评测环境版本。
使用requirements.txt：在本地执行pip freeze requirements.txt，但在提交前，手动移除不必要的开发依赖，只保留核心库。
添加兼容性检查：import sysif sys.version_info (3, 8):raise EnvironmentError(Python 3.8+ required)# 你的业务代码...规避建议永远不要依赖本地环境：每次提交前，在一个干净的Docker容器中测试。
阅读官方环境说明：“东城会”官网通常会提供评测环境的详细配置（OS版本、Python版本、预装库列表），务必逐条核对。
使用虚拟环境：本地开发务必使用venv或conda，模拟评测环境的隔离性。坑二：并发处理中的“死锁”与“竞态条件”
现象：多线程跑着跑着卡住了，或者数据重复了
在“东城会”的并发编程模块，很多初学者喜欢直接用threading模块开几个线程。结果发现，有时候程序卡死不动（死锁），有时候数据库里出现了重复数据（竞态条件）。
这种问题最难调试，因为它不是必现的，而是概率性的。你可能本地跑十次都没事，考试时跑一次就崩了。
根本原因：共享资源保护不当
多线程的核心问题是共享状态。如果多个线程同时读写同一个变量，又没有加锁或同步机制，就会出问题。
很多新人误以为GIL（全局解释器锁）能保护线程安全，这是个大误区。GIL只保证同一时刻只有一个线程执行Python字节码，但它不保证业务逻辑的原子性。例如，list.append()是原子的，但check_then_act（检查后行动）不是。
正确写法对比
错误写法（无锁保护，存在竞态条件）：
import threadingcounter = 0def increment():global counterfor _ in range(100000):# 这里有一个微小的时间窗口，线程切换可能导致计数器不准counter += 1threads = []
for i in range(5):t = threading.Thread(target=increment)threads.append(t)t.start()for t in threads:t.join()print(fExpected: 500000, Got: {counter}) # 通常小于500000正确写法（使用Lock或threading.local）：
import threadingcounter = 0
lock = threading.Lock()def increment():global counterfor _ in range(100000):with lock: # 使用上下文管理器，确保锁一定释放counter += 1threads = []
for i in range(5):t = threading.Thread(target=increment)threads.append(t)t.start()for t in threads:t.join()print(fExpected: 500000, Got: {counter}) # 必定等于500000复现与修复代码最小化锁粒度：不要锁住整个函数，只锁住临界区（读写共享变量的部分）。
避免嵌套锁：如果必须使用多个锁，确保所有线程以相同的顺序获取锁，防止死锁。
使用threading.local：如果每个线程只需要自己的独立变量，使用threading.local避免加锁开销。import threadinglocal_data = threading.local()def worker():# 每个线程拥有独立的local_data，互不干扰local_data.value = threading.get_ident()print(fThread ID: {local_data.value})# ... 启动线程代码规避建议优先使用并发工具库：如concurrent.futures.ThreadPoolExecutor，它封装了锁和线程池管理，比手动管理线程更安全。
无状态设计：尽量让函数无状态，通过参数传递数据，而不是修改全局变量。
单元测试并发：编写专门的压力测试，模拟高并发场景，暴露潜在问题。坑三：内存泄漏与“大对象”未释放
现象：程序运行越久，内存占用越高，最终OOM
在处理大数据或长时间运行的服务时，初学者常遇到内存持续增长的问题。任务管理器显示Python进程占用几个G内存，GC（垃圾回收）也救不回来。
在“东城会”的性能优化模块，这类问题非常常见。很多新人不知道Python的内存管理机制，以为“引用计数”能解决所有问题。
根本原因：循环引用与缓存未清理
Python使用引用计数和标记-清除两种机制。引用计数能处理大多数情况，但循环引用（A引用B，B引用A）会导致引用计数不为0，对象无法立即释放。虽然GC能清理循环引用，但如果对象包含__del__方法，或者GC阈值设置不当，内存释放会延迟。
另外，很多新手喜欢用全局列表或字典做缓存，却从不清理。随着数据量增加，内存自然爆满。
正确写法对比
错误写法（全局缓存无上限，循环引用风险）：
cache = {}def process_data(key, data):# 数据只增不减，内存无限增长cache[key] = datareturn dataclass Node:def __init__(self, next_node):self.next = next_nodedef __del__(self):# 有__del__方法的对象，GC处理更复杂pass正确写法（使用LRU缓存，显式弱引用）：
from functools import lru_cache
import weakref# 使用LRU缓存，自动淘汰最久未使用的数据
@lru_cache(maxsize=128)
def process_data(key, data):# 注意：key必须是可哈希的return data# 使用weakref避免强引用导致的内存泄漏
class Node:def __init__(self, next_node):# 使用弱引用，不阻止next_node被GCif next_node:self.next = weakref.ref(next_node)else:self.next = None复现与修复代码监控内存：使用tracemalloc模块追踪内存分配：import tracemalloctracemalloc.start()# ... 你的代码snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')print([ Top 10 memory usage ])
for stat in top_stats[:10]:print(stat)手动触发GC：在关键节点后，手动调用gc.collect()：import gc# 处理完大批量数据后
del large_data
gc.collect()使用weakref：对于缓存对象，优先使用弱引用字典。规避建议限制缓存大小：任何缓存都必须有上限，使用LRU、TTL等策略。
避免全局可变对象：尽量将数据封装在类实例中，明确生命周期。
定期审计：在长期运行的服务中，定期打印内存使用情况，及时发现泄漏。坑四：异常处理中的“静默失败”
现象：程序没报错，但结果全是错的
这是最隐蔽的坑。代码跑完了，没有异常抛出，但输出的数据全是0，或者文件是空的。初学者往往花大量时间检查业务逻辑，却忽略了异常处理的问题。
在“东城会”的健壮性测试中，这类问题占比很高。很多新人为了“不让程序崩溃”，写了大量的try-except，却把异常吞掉了。
根本原因：异常被捕获但未处理
try-except的目的是处理异常，而不是隐藏异常。如果捕获了异常但不做任何记录或补偿操作，程序就会在错误的状态下继续运行，导致后续逻辑全部错误。
根据开发者文档（如PEP 3110）的最佳实践，异常处理应该遵循“捕获、记录、决策”三步走。
正确写法对比
错误写法（静默吞掉异常）：
def read_config(file_path):try:with open(file_path, 'r') as f:return json.load(f)except Exception:# 什么都没做！程序继续运行，config变成Nonepassconfig = read_config(missing.json)
# 后续代码假设config是dict，但实际是None，导致AttributeError或逻辑错误正确写法（记录日志，抛出特定异常或返回默认值）：
import logging
import jsonlogger = logging.getLogger(__name__)def read_config(file_path):try:with open(file_path, 'r') as f:return json.load(f)except FileNotFoundError:logger.warning(fConfig file {file_path} not found. Using defaults.)return {} # 返回默认值，让调用方知道配置缺失except json.JSONDecodeError as e:logger.error(fInvalid JSON in {file_path}: {e})raise ConfigError(fInvalid config file: {file_path}) from eclass ConfigError(Exception):pass复现与修复代码区分异常类型：不要捕获通用的Exception，尽量捕获具体异常（如FileNotFoundError、ValueError）。
记录日志：所有捕获的异常都必须记录日志，包含上下文信息（文件路径、参数等）。
决定后续行为：如果是可恢复的（如网络抖动），重试或返回默认值。
如果是不可恢复的（如配置错误），立即抛出异常，终止程序。规避建议禁止裸except：永远不要写except:，至少写except Exception as e:。
使用finally：确保资源释放（如关闭文件、数据库连接）在finally块中执行。
异常传播：如果当前层无法处理异常，就让它向上传播，不要就地消化。坑五：代码风格与“可维护性”被忽视
现象：代码能跑，但评审老师给了低分
很多初学者认为“能跑就行”，代码写得像面条一样，变量名是a、b、c，函数长达100行。在“东城会”的认证中，代码质量和可维护性是重要评分项。
这种“一次性代码”思维，在真实工作中会导致灾难。当同事接手你的代码时，会直接离职。
根本原因：缺乏工程化思维
初学者关注的是“功能实现”，而资深开发者关注的是“功能实现 + 可维护性 + 可扩展性”。
根据开发者文档（如PEP 8风格指南），良好的代码风格不仅是美观问题，更是团队协作的基础。
正确写法对比
错误写法（变量名晦涩，函数过长）：
def f(x, y, z):a = x + yb = a * zif b 100:c = b / 2return celse:return b正确写法（语义化命名，单一职责）：
def calculate_total_cost(quantity: int, unit_price: float, tax_rate: float) - float:计算含税总价Args:quantity: 商品数量unit_price: 单价tax_rate: 税率 (0.0 - 1.0)Returns:含税总价subtotal = quantity * unit_pricetax_amount = subtotal * tax_ratetotal = subtotal + tax_amountreturn round(total, 2)复现与修复代码遵循PEP 8：使用flake8或pylint自动检查代码风格。
添加类型提示：使用typing模块，让代码自解释。
拆分长函数：一个函数只做一件事，长度不超过50行。规避建议代码审查（Code Review）：提交前，自己先review一遍，问自己“别人能看懂吗？”
使用Linter：集成black、isort等工具，自动格式化代码。
编写文档字符串：每个公开函数都要有docstring，说明参数、返回值、异常。结尾：你的避坑经验是什么？
“东城会”技术认证，考的不仅是代码能力，更是工程素养和避坑经验。上面这5个坑，每一个都足以让新人栽跟头。但只要你掌握了最佳实践，理解了底层原理，这些坑就会变成你的垫脚石。
记住，技术没有银弹，但有最佳实践。多读官方文档，多踩坑，多总结，你才能从“会写代码”进阶到“会做工程”。
你更常用哪种写法？是在异常处理中倾向于“快速失败”（Fail Fast），还是“优雅降级”（Graceful Degradation）？或者你在“东城会”认证中踩过什么更奇葩的坑？评论区交流一下，互相避避雷。
5个致命坑：东城会技术认证避坑指南与最佳实践
刚拿到“东城会”技术认证的报名通知，是不是兴奋之余又有点慌？别急，我见过太多新人栽在第一步。很多人以为只要把官方文档里的代码复制粘贴进去就能过，结果一运行全是红字报错，或者跑通了但性能慢得让人想摔键盘。这种“复制来的代码跑不通不知道怎么调”的绝望感，是初学者最大的痛点。
今天咱们不聊虚的，直接切入正题。针对“东城会”认证中常见的5个技术坑，结合最佳实践，手把手教你怎么从“小白”变成“能干活”的开发者。这些坑，我踩了至少三年，现在总结出来给你避避雷。记住，认证不是为了拿那张纸，而是为了让你真正理解技术底层逻辑，别把最佳实践当成死记硬背的条文。
坑一：环境配置差异导致的“本地能跑线上崩”
现象：为什么我在笔记本上没问题，提交就报错？
这是新手最崩溃的时刻。你在自己的MacBook Pro上，Python 3.9跑得飞起，代码逻辑清晰，单元测试全绿。一旦提交到“东城会”的在线评测环境（通常是CentOS 7或Ubuntu 20.04容器），立马抛出ModuleNotFoundError或者SyntaxError。
很多初学者以为是自己代码写错了，开始疯狂检查逻辑，其实问题出在环境隔离上。
根本原因：版本锁定与依赖管理缺失
“东城会”的评测环境是固定版本的Linux容器，它不会自动安装你本地最新的库。如果你本地用的是Python 3.10，而评测环境是3.8，某些语法特性（如match语句）就会直接报错。更隐蔽的是依赖库的版本冲突。比如numpy在1.20和1.24之间的API有细微变动，如果你没锁定版本，评测环境拉取到的版本可能与你本地测试的不一致。
根据开发者文档（如PEP 440规范）的建议，生产级项目必须严格管理依赖版本。很多新人忽略这一点，以为“能用就行”，这在认证考试中是大忌。
正确写法对比
错误写法（未锁定版本，依赖隐式导入）：
# install: pip install pandas requests
import pandas as pd
import requestsdef fetch_data(url):# 这里假设 requests 版本较新，使用了某些新特性response = requests.get(url, timeout=5)df = pd.DataFrame(response.json())return df正确写法（显式指定版本，兼容处理）：
# requirements.txt 中必须明确指定版本
# pandas==1.3.5
# requests==2.26.0import pandas as pd
import requests
from typing import Dict, Anydef fetch_data(url: str) - pd.DataFrame:获取数据并转换为DataFrame注意：兼容Python 3.8+环境try:response = requests.get(url, timeout=5)response.raise_for_status() # 检查HTTP错误，避免静默失败data = response.json()# 确保数据格式符合预期，防止NoneType错误if not data:raise ValueError(Empty response data)df = pd.DataFrame(data)return dfexcept requests.exceptions.RequestException as e:raise Exception(fRequest failed: {e})复现与修复代码检查Python版本：在代码开头打印sys.version，确认评测环境版本。
使用requirements.txt：在本地执行pip freeze requirements.txt，但在提交前，手动移除不必要的开发依赖，只保留核心库。
添加兼容性检查：import sysif sys.version_info (3, 8):raise EnvironmentError(Python 3.8+ required)# 你的业务代码...规避建议永远不要依赖本地环境：每次提交前，在一个干净的Docker容器中测试。
阅读官方环境说明：“东城会”官网通常会提供评测环境的详细配置（OS版本、Python版本、预装库列表），务必逐条核对。
使用虚拟环境：本地开发务必使用venv或conda，模拟评测环境的隔离性。坑二：并发处理中的“死锁”与“竞态条件”
现象：多线程跑着跑着卡住了，或者数据重复了
在“东城会”的并发编程模块，很多初学者喜欢直接用threading模块开几个线程。结果发现，有时候程序卡死不动（死锁），有时候数据库里出现了重复数据（竞态条件）。
这种问题最难调试，因为它不是必现的，而是概率性的。你可能本地跑十次都没事，考试时跑一次就崩了。
根本原因：共享资源保护不当
多线程的核心问题是共享状态。如果多个线程同时读写同一个变量，又没有加锁或同步机制，就会出问题。
很多新人误以为GIL（全局解释器锁）能保护线程安全，这是个大误区。GIL只保证同一时刻只有一个线程执行Python字节码，但它不保证业务逻辑的原子性。例如，list.append()是原子的，但check_then_act（检查后行动）不是。
正确写法对比
错误写法（无锁保护，存在竞态条件）：
import threadingcounter = 0def increment():global counterfor _ in range(100000):# 这里有一个微小的时间窗口，线程切换可能导致计数器不准counter += 1threads = []
for i in range(5):t = threading.Thread(target=increment)threads.append(t)t.start()for t in threads:t.join()print(fExpected: 500000, Got: {counter}) # 通常小于500000正确写法（使用Lock或threading.local）：
import threadingcounter = 0
lock = threading.Lock()def increment():global counterfor _ in range(100000):with lock: # 使用上下文管理器，确保锁一定释放counter += 1threads = []
for i in range(5):t = threading.Thread(target=increment)threads.append(t)t.start()for t in threads:t.join()print(fExpected: 500000, Got: {counter}) # 必定等于500000复现与修复代码最小化锁粒度：不要锁住整个函数，只锁住临界区（读写共享变量的部分）。
避免嵌套锁：如果必须使用多个锁，确保所有线程以相同的顺序获取锁，防止死锁。
使用threading.local：如果每个线程只需要自己的独立变量，使用threading.local避免加锁开销。import threadinglocal_data = threading.local()def worker():# 每个线程拥有独立的local_data，互不干扰local_data.value = threading.get_ident()print(fThread ID: {local_data.value})# ... 启动线程代码规避建议优先使用并发工具库：如concurrent.futures.ThreadPoolExecutor，它封装了锁和线程池管理，比手动管理线程更安全。
无状态设计：尽量让函数无状态，通过参数传递数据，而不是修改全局变量。
单元测试并发：编写专门的压力测试，模拟高并发场景，暴露潜在问题。坑三：内存泄漏与“大对象”未释放
现象：程序运行越久，内存占用越高，最终OOM
在处理大数据或长时间运行的服务时，初学者常遇到内存持续增长的问题。任务管理器显示Python进程占用几个G内存，GC（垃圾回收）也救不回来。
在“东城会”的性能优化模块，这类问题非常常见。很多新人不知道Python的内存管理机制，以为“引用计数”能解决所有问题。
根本原因：循环引用与缓存未清理
Python使用引用计数和标记-清除两种机制。引用计数能处理大多数情况，但循环引用（A引用B，B引用A）会导致引用计数不为0，对象无法立即释放。虽然GC能清理循环引用，但如果对象包含__del__方法，或者GC阈值设置不当，内存释放会延迟。
另外，很多新手喜欢用全局列表或字典做缓存，却从不清理。随着数据量增加，内存自然爆满。
正确写法对比
错误写法（全局缓存无上限，循环引用风险）：
cache = {}def process_data(key, data):# 数据只增不减，内存无限增长cache[key] = datareturn dataclass Node:def __init__(self, next_node):self.next = next_nodedef __del__(self):# 有__del__方法的对象，GC处理更复杂pass正确写法（使用LRU缓存，显式弱引用）：
from functools import lru_cache
import weakref# 使用LRU缓存，自动淘汰最久未使用的数据
@lru_cache(maxsize=128)
def process_data(key, data):# 注意：key必须是可哈希的return data# 使用weakref避免强引用导致的内存泄漏
class Node:def __init__(self, next_node):# 使用弱引用，不阻止next_node被GCif next_node:self.next = weakref.ref(next_node)else:self.next = None复现与修复代码监控内存：使用tracemalloc模块追踪内存分配：import tracemalloctracemalloc.start()# ... 你的代码snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')print([ Top 10 memory usage ])
for stat in top_stats[:10]:print(stat)手动触发GC：在关键节点后，手动调用gc.collect()：import gc# 处理完大批量数据后
del large_data
gc.collect()使用weakref：对于缓存对象，优先使用弱引用字典。规避建议限制缓存大小：任何缓存都必须有上限，使用LRU、TTL等策略。
避免全局可变对象：尽量将数据封装在类实例中，明确生命周期。
定期审计：在长期运行的服务中，定期打印内存使用情况，及时发现泄漏。坑四：异常处理中的“静默失败”
现象：程序没报错，但结果全是错的
这是最隐蔽的坑。代码跑完了，没有异常抛出，但输出的数据全是0，或者文件是空的。初学者往往花大量时间检查业务逻辑，却忽略了异常处理的问题。
在“东城会”的健壮性测试中，这类问题占比很高。很多新人为了“不让程序崩溃”，写了大量的try-except，却把异常吞掉了。
根本原因：异常被捕获但未处理
try-except的目的是处理异常，而不是隐藏异常。如果捕获了异常但不做任何记录或补偿操作，程序就会在错误的状态下继续运行，导致后续逻辑全部错误。
根据开发者文档（如PEP 3110）的最佳实践，异常处理应该遵循“捕获、记录、决策”三步走。
正确写法对比
错误写法（静默吞掉异常）：
def read_config(file_path):try:with open(file_path, 'r') as f:return json.load(f)except Exception:# 什么都没做！程序继续运行，config变成Nonepassconfig = read_config(missing.json)
# 后续代码假设config是dict，但实际是None，导致AttributeError或逻辑错误正确写法（记录日志，抛出特定异常或返回默认值）：
import logging
import jsonlogger = logging.getLogger(__name__)def read_config(file_path):try:with open(file_path, 'r') as f:return json.load(f)except FileNotFoundError:logger.warning(fConfig file {file_path} not found. Using defaults.)return {} # 返回默认值，让调用方知道配置缺失except json.JSONDecodeError as e:logger.error(fInvalid JSON in {file_path}: {e})raise ConfigError(fInvalid config file: {file_path}) from eclass ConfigError(Exception):pass复现与修复代码区分异常类型：不要捕获通用的Exception，尽量捕获具体异常（如FileNotFoundError、ValueError）。
记录日志：所有捕获的异常都必须记录日志，包含上下文信息（文件路径、参数等）。
决定后续行为：如果是可恢复的（如网络抖动），重试或返回默认值。
如果是不可恢复的（如配置错误），立即抛出异常，终止程序。规避建议禁止裸except：永远不要写except:，至少写except Exception as e:。
使用finally：确保资源释放（如关闭文件、数据库连接）在finally块中执行。
异常传播：如果当前层无法处理异常，就让它向上传播，不要就地消化。坑五：代码风格与“可维护性”被忽视
现象：代码能跑，但评审老师给了低分
很多初学者认为“能跑就行”，代码写得像面条一样，变量名是a、b、c，函数长达100行。在“东城会”的认证中，代码质量和可维护性是重要评分项。
这种“一次性代码”思维，在真实工作中会导致灾难。当同事接手你的代码时，会直接离职。
根本原因：缺乏工程化思维
初学者关注的是“功能实现”，而资深开发者关注的是“功能实现 + 可维护性 + 可扩展性”。
根据开发者文档（如PEP 8风格指南），良好的代码风格不仅是美观问题，更是团队协作的基础。
正确写法对比
错误写法（变量名晦涩，函数过长）：
def f(x, y, z):a = x + yb = a * zif b 100:c = b / 2return celse:return b正确写法（语义化命名，单一职责）：
def calculate_total_cost(quantity: int, unit_price: float, tax_rate: float) - float:计算含税总价Args:quantity: 商品数量unit_price: 单价tax_rate: 税率 (0.0 - 1.0)Returns:含税总价subtotal = quantity * unit_pricetax_amount = subtotal * tax_ratetotal = subtotal + tax_amountreturn round(total, 2)复现与修复代码遵循PEP 8：使用flake8或pylint自动检查代码风格。
添加类型提示：使用typing模块，让代码自解释。
拆分长函数：一个函数只做一件事，长度不超过50行。规避建议代码审查（Code Review）：提交前，自己先review一遍，问自己“别人能看懂吗？”
使用Linter：集成black、isort等工具，自动格式化代码。
编写文档字符串：每个公开函数都要有docstring，说明参数、返回值、异常。结尾：你的避坑经验是什么？
“东城会”技术认证，考的不仅是代码能力，更是工程素养和避坑经验。上面这5个坑，每一个都足以让新人栽跟头。但只要你掌握了最佳实践，理解了底层原理，这些坑就会变成你的垫脚石。
记住，技术没有银弹，但有最佳实践。多读官方文档，多踩坑，多总结，你才能从“会写代码”进阶到“会做工程”。
你更常用哪种写法？是在异常处理中倾向于“快速失败”（Fail Fast），还是“优雅降级”（Graceful Degradation）？或者你在“东城会”认证中踩过什么更奇葩的坑？评论区交流一下，互相避避雷。
