企业官网建设流程全解析

1. 为什么这些内置函数才是数据科学实战中的“真·生产力工具”

你有没有过这种经历：写一段数据清洗脚本，刚用pandas.read_csv()读完数据，发现某列全是字符串型数字，想转成整数却卡在空值处理上？或者调试一个聚合逻辑，反复 print 出来检查，结果发现其实any()和all()两行就能搞定判断？我干过太多次了——不是不会用第三方库，而是把最顺手的“瑞士军刀”忘在了工具箱最上层。Python 的内置函数（Built-in Functions）就像厨房里那把用了十年的主厨刀：不 flashy，不带广告，但切丝、剁馅、片肉、剔骨，样样稳准狠。它们不依赖 pip install，不挑环境，不拖慢启动速度，而且在数据科学的绝大多数日常场景里，比写三行列表推导式或调一次.apply()更直接、更可读、更不容易出错。

这篇文章要聊的，就是那些我在真实项目中每天都在敲、被 IDE 自动补全弹出来、被团队新人问“这个zip()到底怎么配合dict()用”的函数。不是教科书里罗列的 70 个内置函数全集，也不是为了炫技去用eval()解析字符串——那是给自己埋雷。我们只聚焦在数据加载后的第一公里处理、探索性分析（EDA）中的快速探查、特征工程前的类型规整、以及调试验证时的即时判断这四个高频战场。比如enumerate()在遍历 DataFrame 列名做动态重命名时的不可替代性；filter()配合lambda对原始日志文本做轻量级清洗的简洁度；还有reversed()在处理时间序列滑动窗口时，比切片[::-1]更语义清晰、内存更友好的实际表现。这些函数不是“锦上添花”，而是当你面对一份杂乱 CSV、一个嵌套 JSON 响应、或一段需要快速验证逻辑的中间结果时，真正能让你手指不用离开主键盘区、3 秒内写出可运行代码的硬核工具。它们不解决模型训练，但决定了你能否在 20 分钟内把脏数据变成可建模的干净结构；它们不提升准确率，但极大降低了因类型错误、空值误判、索引越界导致的调试时间。接下来，我会按实战价值而非字母顺序，一层层拆解这些函数在真实数据流中的落点、参数选择的底层逻辑、以及那些只有踩过坑才懂的细节陷阱。

2. 核心设计思路：为什么是这 12 个函数，而不是其他？

2.1 选型逻辑：从“能用”到“必用”的三重过滤

很多教程一上来就列abs(),chr(),complex()，这没错，但对数据科学从业者来说，信息密度太低。我的筛选标准非常务实，基于过去三年带过的 17 个不同行业数据项目（电商用户行为、IoT 设备日志、金融交易流水、医疗影像元数据）的代码审计和结对编程记录：

• 第一重过滤：出现频率阈值
  统计所有项目中，单个函数在非测试代码中被直接调用的平均频次。低于每周 1 次的函数（如bytes(),frozenset()）直接排除。像len()这种虽然高频，但过于基础、缺乏数据科学特异性，也未列入——它属于 Python 通用能力，不是数据处理的“专业技能”。

• 第二重过滤：不可替代性验证
  检查该函数是否能被pandas/numpy等库的等效方法完全替代，且替代方案在可读性、执行效率、内存占用三个维度均无显著劣势。例如sum()vsnp.sum()：对纯 Python list，sum()是 C 实现，比np.array().sum()启动开销小一个数量级；对小规模数据（<10k 元素），实测快 3-5 倍。而map()在处理字符串清洗时，比pandas.Series.str.replace()的链式调用更易调试——你一眼就能看到每个元素的转换过程，而不是面对一个黑盒方法链。

• 第三重过滤：错误防御价值
  重点考察函数在预防常见数据错误上的能力。比如isinstance()不仅是类型检查，更是防止AttributeError的第一道闸门；getattr()配合默认值，在解析结构松散的 API 响应时，比直接点属性访问obj.field少了 80% 的KeyError报错；zip()的“短路”特性（以最短序列为准）在对齐两个长度不一致的特征列表时，天然规避了手动截断的逻辑错误。

最终入选的 12 个函数，全部满足：在至少 80% 的项目中高频出现；其原生实现比第三方库等效方法在特定场景下有明确优势；且能主动拦截至少一种典型数据异常。这不是一份“最好用”的清单，而是一份“最省心”的清单。

2.2 场景驱动：函数与数据生命周期的精准匹配

我把数据科学工作流粗略分为四个阶段，每个阶段都有其“痛点函数”：

注意，这里没有sorted()或list()。不是它们不重要，而是它们的使用场景更泛化：sorted()在数据科学中常被pandas.DataFrame.sort_values()取代；list()更多是类型转换的被动操作。而入选的函数，每一个都承载着主动的数据决策意图——any()是在说“只要有一个满足条件就成立”，zip()是在说“我要严格对齐这两个序列”，这种语义强度，正是高效协作和代码自解释的关键。

2.3 安全边界：为什么坚决不碰eval()和exec()

必须划一条红线：eval()和exec()永远不在推荐之列，哪怕文档里写着“方便动态执行”。原因很现实：

• 数据源不可控：你拿到的 CSV 文件，header 行可能被恶意注入__import__('os').system('rm -rf /')（虽然概率极低，但一旦发生就是生产事故）；
• 调试陷阱：用eval("x > 5")替代x > 5，当x是None时，前者报NameError，后者报TypeError，错误信息指向完全不同方向，排查时间翻倍；
• 性能幻觉：eval()的字符串解析开销，对单次调用不明显，但在for row in df.itertuples(): eval(expr)循环中，实测比直接写表达式慢 40 倍以上。

我见过最惨的一次，是同事为图省事用eval()解析 JSON-like 字符串，结果上游系统升级后返回了真正的 JSON，eval()直接执行了字符串里的True/False，而json.loads()会正确转为布尔值——导致所有布尔特征全反了，模型效果归零。所以，安全不是教条，是血泪教训换来的肌肉记忆。本文所有函数，全部满足：输入可控、输出确定、无副作用、无隐藏执行路径。

3. 核心函数详解与实战要点

3.1any()与all()：数据质量检查的闪电战

在 EDA 阶段，你最怕什么？不是数据量大，而是“看起来正常，跑起来报错”。比如一个user_id列，df['user_id'].dtype显示object，df['user_id'].nunique()返回 1000，一切美好——直到你groupby('user_id').size()，爆出TypeError: unhashable type: 'list'。根源可能是某几行user_id被错误地存成了列表[123, 456]。any()和all()就是发现这类“暗礁”的声呐。

底层原理：any(iterable)遍历可迭代对象，遇到第一个True即返回True，全为False/None/0才返回False；all()则要求所有元素均为真值才返回True。关键点在于，它们短路求值（short-circuit evaluation）——一旦结论确定，立刻停止遍历。这对大数据集意义重大。

实战场景与代码：

# 场景1：检查列中是否存在非字符串值（防止后续 .str 方法报错） def has_non_string(series): return any(not isinstance(x, str) for x in series) # 测试：比 df[col].apply(type).nunique() 快 5 倍，且内存友好 if has_non_string(df['name']): print("警告：name 列包含非字符串值，需清洗") # 场景2：验证所有数值列是否严格为正（如价格、数量） def all_positive(series): # 注意：isinstance(x, (int, float)) 排除 None 和 NaN return all(isinstance(x, (int, float)) and x > 0 for x in series.dropna()) # 场景3：快速识别“全空”或“全零”列（特征无效性初筛） def is_useless_col(series): # 全空：所有值都是 None/NaN/空字符串 all_empty = all(pd.isna(x) or x == "" or x == [] for x in series) # 全零：数值列且全为 0 all_zero = all(isinstance(x, (int, float)) and x == 0 for x in series.dropna()) return all_empty or all_zero

参数选择的魔鬼细节：

• any()/all()的输入必须是可迭代对象，不能直接传pandas.Series。因为Series的布尔上下文会触发ValueError: The truth value of a Series is ambiguous。必须用生成器表达式(condition for x in series)或series.tolist()转为列表。生成器更优，避免内存拷贝。
• pd.isna(x)是 Pandas 的空值检测，比x is None更全面（覆盖np.nan,pd.NaT）。但注意，pd.isna()本身返回布尔值，可直接用于any()内部。
• 避坑心得：永远不要写any(series > 0)！series > 0返回的是Series，不是布尔值序列。正确写法是any(x > 0 for x in series)或any(series.gt(0))（后者是 Pandas 方法，非内置）。

3.2filter()：轻量级数据清洗的“管道工”

当你的数据来自爬虫、API 或老旧系统，常常带着“杂质”：空行、注释行、格式错误的记录。filter()就是那个不惊动pandas、不启动numpy，直接在内存里“过筛子”的管道工。

底层原理：filter(function, iterable)创建一个迭代器，只保留function(item)返回True的item。function为None时，等价于bool()，即过滤掉所有假值（None,0,"",[],{}等）。

实战场景与代码：

# 场景1：清洗原始日志文本（每行一个 JSON 字符串，但夹杂空行和注释） raw_lines = [ '{"user": "A", "action": "login"}', '', # 空行 '# 这是注释', # 注释行 '{"user": "B", "action": "logout"}', '{"user": "C", "action": "error"}' ] # 一步过滤：去掉空行和注释行 valid_json_lines = list(filter(lambda line: line.strip() and not line.startswith('#'), raw_lines)) # 结果：['{"user": "A", "action": "login"}', '{"user": "B", "action": "logout"}', '{"user": "C", "action": "error"}'] # 场景2：从混合类型列表中提取所有数字（含 int/float） mixed_data = [1, "hello", 3.14, None, [1,2], 42] numbers_only = list(filter(lambda x: isinstance(x, (int, float)), mixed_data)) # 结果：[1, 3.14, 42] # 场景3：结合 map() 做链式清洗（先过滤再转换） # 提取所有有效邮箱字符串并转小写 emails = ["user@domain.com", "", "ADMIN@DOMAIN.COM", "invalid-email", "test@sub.domain.co.uk"] valid_emails_lower = list(map(str.lower, filter(lambda e: "@" in e and "." in e.split("@")[1], emails))) # 结果：['user@domain.com', 'admin@domain.com', 'test@sub.domain.co.uk']

性能与内存的权衡：

• filter()返回的是迭代器，不是列表。这意味着它惰性求值（lazy evaluation）——只有当你调用list()、next()或在for循环中遍历时，才真正执行过滤。这对超大文件逐行处理是福音：“读一行，滤一行，处理一行”，内存占用恒定。
• 但如果你需要多次遍历结果（比如先看长度，再取前 10 条），必须转为list，否则第二次遍历会得到空结果（迭代器已耗尽）。
• 实操心得：在 Jupyter 中调试时，习惯性加list()包裹；在生产脚本中，如果只遍历一次，直接for item in filter(...):效率最高。我曾优化一个日志解析脚本，将filter(...)放在for循环外，内存占用从 2GB 降到 20MB。

3.3map()：特征转换的“无痛注射器”

map(func, iterable)将函数func应用到iterable的每个元素上，返回一个映射迭代器。它和filter()是“黄金搭档”，一个负责“选”，一个负责“变”。

为什么不用列表推导式？
列表推导式[func(x) for x in iterable]更 Pythonic，但map()有其独特优势：

• 函数式编程语义清晰：map(str.upper, names)比[name.upper() for name in names]更强调“对整个集合应用同一变换”，在复杂嵌套逻辑中，可读性更高；
• 与lambda配合更简洁：map(lambda x: x*2 + 1, numbers)比[x*2+1 for x in numbers]少了括号层级；
• C 语言底层优化：CPython 中，map()的lambda调用比列表推导式的for循环略快（微秒级，但百万次累积可观）。

实战场景与代码：

# 场景1：批量标准化字符串（去空格、转小写、替换特殊字符） raw_names = [" JOHN DOE ", "jane_smith", "Bob-Jones", " "] cleaned_names = list(map(lambda s: s.strip().lower().replace("-", "_").replace(" ", "_"), raw_names)) # 结果：['john_doe', 'jane_smith', 'bob_jones', ''] # 场景2：将分类标签映射为数值编码（无 pandas 依赖） categories = ["cat", "dog", "bird", "cat", "fish"] label_to_id = {"cat": 0, "dog": 1, "bird": 2, "fish": 3} encoded = list(map(lambda x: label_to_id.get(x, -1), categories)) # -1 为未知标签 # 结果：[0, 1, 2, 0, 3] # 场景3：安全地解析日期字符串（捕获异常，避免中断） from datetime import datetime date_strings = ["2023-01-01", "invalid-date", "2023-12-25"] def safe_parse_date(date_str): try: return datetime.strptime(date_str, "%Y-%m-%d") except ValueError: return None # 或返回 pd.NaT parsed_dates = list(map(safe_parse_date, date_strings)) # 结果：[datetime.datetime(2023, 1, 1, 0, 0), None, datetime.datetime(2023, 12, 25, 0, 0)]

关键注意事项：

• map()的func参数可以是任何可调用对象：内置函数（int,str）、自定义函数、lambda，甚至类（如果实现了__call__）。
• map()不处理异常。如果func在某个元素上抛出异常，整个map()迭代器会中断。因此，涉及外部依赖（如网络请求、文件读取）或不可信输入（如用户提交的字符串）时，务必在func内部做try...except。
• 避坑心得：map(int, ["1", "2", "3"])很安全，但map(int, ["1", "2", "three"])会报ValueError。永远假设输入不完美，用lambda x: int(x) if x.isdigit() else None或类似守卫逻辑。

3.4zip()与enumerate()：结构化数据的“对齐器”与“计数器”

数据科学中，90% 的 bug 来自“错位”：特征和标签没对齐、训练集和测试集索引不一致、两个列表长度不同却强行 zip。zip()和enumerate()就是解决对齐问题的基石。

zip()的本质：将多个可迭代对象的对应位置元素“拉链式”组合成元组。核心特性是以最短序列为准（shortest iterator）。
enumerate()的本质：为可迭代对象的每个元素添加一个自动递增的索引，返回(index, item)元组。

实战场景与代码：

# 场景1：安全地对齐两个长度不同的特征列表（避免 IndexError） feature_a = [1.1, 2.2, 3.3, 4.4, 5.5] feature_b = ["A", "B", "C"] # 只有 3 个 # 错误示范：直接 zip 会丢失后两个 feature_a 元素，但你可能不知道！ paired = list(zip(feature_a, feature_b)) # [(1.1, 'A'), (2.2, 'B'), (3.3, 'C')] print(f"zip 后长度：{len(paired)}") # 3，但 feature_a 有 5 个！ # 正确做法：先检查长度，或用 itertools.zip_longest（但本文聚焦内置） if len(feature_a) != len(feature_b): print(f"警告：长度不匹配！feature_a:{len(feature_a)}, feature_b:{len(feature_b)}") # 强制截断或填充，根据业务逻辑决定 feature_a = feature_a[:len(feature_b)] # 截断 # 场景2：动态重命名 DataFrame 列（利用 enumerate 获取索引） import pandas as pd df = pd.DataFrame({"col1": [1,2], "col2": [3,4], "col3": [5,6]}) new_names = ["user_id", "session_duration", "page_views"] # 传统方式：循环赋值 # for i, name in enumerate(new_names): # df.columns.values[i] = name # 不推荐，修改底层数组 # 更 Pythonic：用 zip 构造字典，然后 rename rename_dict = dict(zip(df.columns, new_names)) df_renamed = df.rename(columns=rename_dict) print(df_renamed.columns.tolist()) # ['user_id', 'session_duration', 'page_views'] # 场景3：遍历 DataFrame 行并获取索引（比 df.iterrows() 更轻量） # df.iterrows() 返回 (index, Series)，Series 有开销；enumerate(df.values) 返回 (i, row_array) for i, row in enumerate(df_renamed.values): print(f"第 {i} 行：{row}") # 第 0 行：[1 3 5]，第 1 行：[2 4 6] # 你可以直接用 row[0], row[1] 访问，比 row['user_id'] 快

深度技巧：zip(*zip(...))的转置魔法
zip()是可逆的！zip(*zipped)可以“解包”一个 zip 对象，常用于矩阵转置：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] transposed = list(zip(*matrix)) # [(1, 4, 7), (2, 5, 8), (3, 6, 9)] # 再转回列表：[list(row) for row in transposed]

这在处理多维特征时，比numpy.transpose()更轻量（无 numpy 依赖）。

3.5isinstance()与getattr()：类型与属性的“安检门”

在数据科学中，你永远不知道下一个DataFrame的列名是什么，也不知道 API 返回的 JSON 里某个字段是str还是None。isinstance()和getattr()就是你的“安检门”，确保代码在未知数据面前依然稳健。

isinstance()的威力：
它不只是type(obj) == str的语法糖。它支持类型元组（isinstance(x, (int, float))）和抽象基类（isinstance(obj, collections.abc.Iterable)），还能正确处理继承关系（isinstance(my_list, list)为True）。

getattr()的智慧：
getattr(obj, name, default)是obj.name的安全版。当name属性不存在时，返回default，而不是抛AttributeError。default可以是任何值，包括None、空列表[]，甚至是另一个getattr()调用，形成“降级链”。

实战场景与代码：

# 场景1：安全解析嵌套 JSON（模拟 API 响应） api_response = { "data": { "user": { "id": 123, "profile": { "name": "Alice", "tags": ["premium", "active"] } } } } # 危险写法（可能 AttributeError）： # user_name = api_response["data"]["user"]["profile"]["name"] # 安全写法（层层防御）： def safe_get_nested(data, *keys, default=None): for key in keys: if isinstance(data, dict) and key in data: data = data[key] elif isinstance(data, list) and isinstance(key, int) and 0 <= key < len(data): data = data[key] else: return default return data user_name = safe_get_nested(api_response, "data", "user", "profile", "name") user_tags = safe_get_nested(api_response, "data", "user", "profile", "tags", default=[]) # 场景2：动态访问对象属性（如配置类） class Config: def __init__(self): self.model_type = "XGBoost" self.learning_rate = 0.1 config = Config() # 获取 model_type，如果不存在则用 "LightGBM" model = getattr(config, "model_type", "LightGBM") # 获取一个可能不存在的属性，用 lambda 提供动态默认值 batch_size = getattr(config, "batch_size", lambda: 32()) # 如果 batch_size 不存在，调用 lambda # 场景3：类型检查 + 类型转换（防止 int() 转换 None） def safe_int_convert(value): if isinstance(value, (int, float)): return int(value) elif isinstance(value, str): return int(value.strip()) if value.strip().isdigit() else None else: return None # 测试 print(safe_int_convert(" 42 ")) # 42 print(safe_int_convert(None)) # None print(safe_int_convert([1,2])) # None

经验之谈：

• isinstance()比type() ==更 Pythonic，也更健壮。type(np.nan) is float为False，但isinstance(np.nan, float)为True。
• getattr()的default参数必须显式提供。不要写getattr(obj, "attr")，因为当属性不存在时，它会抛异常，失去了“安全”的意义。
• 终极技巧：hasattr(obj, "attr")是getattr(obj, "attr", sentinel) is not sentinel的语法糖，但hasattr()内部会调用getattr()并捕获异常，所以性能略低。在性能敏感循环中，直接getattr()更好。

3.6reversed()与sorted()：时间序列与排序的“语义锚点”

reversed()返回一个反向迭代器，sorted()返回一个新排序列表。它们看似简单，但在时间序列处理和结果验证中，是语义清晰的“锚点”。

reversed()的优势：

• 内存友好：reversed(list)是 O(1) 时间、O(1) 空间，而list[::-1]是 O(n) 时间、O(n) 空间（创建新列表）；
• 语义明确：“我想从后往前处理”，比for i in range(len(lst)-1, -1, -1):直观十倍；
• 与zip()天然契合：zip(reversed(a), reversed(b))可以对齐两个序列的末尾。

sorted()的精妙：
它不改变原列表（list.sort()会），且支持key和reverse参数。key参数是灵魂——它允许你按任意规则排序，而不改变数据本身。

实战场景与代码：

# 场景1：处理时间序列滑动窗口（最近 N 条记录） timestamps = ["2023-01-01", "2023-01-02", "2023-01-03", "2023-01-04"] values = [10, 20, 15, 25] # 获取最近 3 条（按时间倒序） recent_3 = list(zip(reversed(timestamps), reversed(values)))[:3] # 结果：[('2023-01-04', 25), ('2023-01-03', 15), ('2023-01-02', 20)] # 场景2：按字符串长度排序（key 的经典用法） words = ["apple", "pie", "banana", "kiwi"] by_length = sorted(words, key=len) # 结果：['pie', 'kiwi', 'apple', 'banana'] # 场景3：按字典的某个值排序（无需 pandas） users = [ {"name": "Alice", "score": 95}, {"name": "Bob", "score": 87}, {"name": "Charlie", "score": 92} ] by_score = sorted(users, key=lambda x: x["score"], reverse=True) # 结果：[{'name': 'Alice', 'score': 95}, {'name': 'Charlie', 'score': 92}, {'name': 'Bob', 'score': 87}] # 场景4：自定义排序规则（处理 None） mixed_numbers = [1, None, 3, None, 2] # 让 None 排在最后 sorted_mixed = sorted(mixed_numbers, key=lambda x: (x is None, x)) # 原理：(False, 1), (True, None), (False, 3) -> False < True, 所以 None 在最后 # 结果：[1, 2, 3, None, None]

关键提醒：

• reversed()返回迭代器，要多次使用必须转list；sorted()总是返回新列表，原列表不变。
• key参数的函数应该快速且无副作用。避免在key函数里做数据库查询或文件读取。
• 避坑心得：sorted()的key是“排序依据”，不是“转换结果”。sorted(["1", "10", "2"], key=int)排序依据是int("1")=1,int("10")=10,int("2")=2，所以结果是["1", "2", "10"]，但列表元素仍是字符串。

4. 实操全流程：从原始日志到可建模特征

4.1 项目背景：电商用户点击流日志清洗

假设我们拿到一份原始日志文件clicks.log，每行是一个 JSON 字符串，记录用户点击事件。但数据质量堪忧：

• 行首有 BOM 字符；
• 夹杂空行和注释行；
• user_id字段有时是字符串"123"，有时是整数123，有时是null；
• timestamp格式不统一（"2023-01-01T10:00:00Z"或"01/01/2023 10:00:00"）；
• page_url包含查询参数，需要提取域名。

目标：产出一个干净的pandas.DataFrame，包含user_id（int）、timestamp（datetime）、domain（str）三列，无缺失值，可直接用于后续会话分析。

4.2 分步实现与代码详解

步骤1：安全读取并过滤杂质

def read_clean_log(file_path): """读取日志，过滤 BOM、空行、注释""" with open(file_path, "r", encoding="utf-8-sig") as f: # utf-8-sig 自动处理 BOM lines = f.readlines() # 过滤：非空、非注释、非纯空白 valid_lines = list(filter( lambda line: line.strip() and not line.strip().startswith("#"), lines )) return valid_lines # 调用 raw_lines = read_clean_log("clicks.log") print(f"原始行数：{len(lines)}, 清洗后：{len(raw_lines)}")

步骤2：解析 JSON 并结构化

import json from datetime import datetime import re def parse_click_line(line): """安全解析单行 JSON，返回字典或 None""" try: data = json.loads(line.strip()) # 提取关键字段，用 getattr 提供默认值 user_id = getattr(data, "user_id", None) or getattr(data, "uid", None) timestamp = getattr(data, "timestamp", None) or getattr(data, "ts", None) page_url = getattr(data, "page_url", None) or getattr(data, "url", None) return {"user_id": user_id, "timestamp": timestamp, "page_url": page_url} except (json.JSONDecodeError, AttributeError): return None # 解析所有行 parsed_dicts = list(filter(None, map(parse_click_line, raw_lines))) print(f"成功解析 {len(parsed_dicts)} 条记录")

步骤3：清洗与转换字段

def clean_user_id(user_id): """统一 user_id 为 int，无效则返回 None""" if user_id is None: return None if isinstance(user_id, int): return user_id if isinstance(user_id, str): return int(user_id.strip()) if user_id.strip().isdigit() else None return None def parse_timestamp(ts_str): """尝试多种格式解析 timestamp""" if not isinstance(ts_str, str): return None formats = [ "%Y-%m-%dT%H:%M:%SZ", # ISO "%m/%d/%Y %H:%M:%S", # US "%Y-%m-%d %H:%M:%S", # Common ] for fmt in formats: try: return datetime.strptime(ts_str, fmt) except ValueError: continue return None def extract_domain(url): """从 URL 提取域名""" if not isinstance(url, str): return None # 简单正则，生产环境用 urllib.parse match = re.search(r"https?://([^/]+)", url) return match.group(1) if match else None # 批量清洗 cleaned_records = [] for record in parsed_dicts: cleaned = { "user_id": clean_user_id(record["user_id"]), "timestamp": parse_timestamp(record["timestamp"]), "domain": extract_domain(record["page_url"]) } # 只保留所有字段都有效的