《Python 从入门到精通》107|函数式清洗数据:让脏数据变整洁

前面几章，我们已经学了很多很实用的处理手段。

会读 JSON 了。 会用正则提取信息了。 会处理时间了。 会排序、去重、统计了。

但真正的数据处理工作，走到这一步，往往才刚刚开始。

因为你很快就会遇到一个现实问题：

数据不是不能用，而是不好用。 不是没有值，而是值很脏。 不是字段缺失，就是格式混乱。 不是大小写不统一，就是前后空格乱飞。 不是手机号写成了 138-1234-5678，就是邮箱写成了 TEST@QQ.COM。 不是日期写成 2026/3/9，就是姓名里混着多余符号。

这时候，你会发现，很多工作其实不是“分析数据”，而是“先把数据收拾干净”。

所以这一章很关键。

它讲的不是某一个零散函数，而是一种更像真实项目的处理思路：

把每一步清洗动作拆成独立函数。 让每个函数只做一件事。 再把这些函数像流水线一样串起来。

这就是所谓的函数式清洗数据。

你可以把它理解成一种更整洁、更可复用、更容易维护的数据清洗方式。

一、什么叫脏数据

先别把“脏数据”想得特别专业。

只要数据格式不统一、内容不规范、带有无效信息、影响后续处理，都可以叫脏数据。

比如下面这些，都很典型：

names = [" 张三", "李四 ", "  王五  ", "", None]phones = ["13812345678", "138-1234-5678", " 156 0000 1111 ", "abc", ""]emails = ["TEST@QQ.COM", " admin@test.com ", "wrong_email", None]dates = ["2026-03-29", "2026/3/29", "2026.03.29", "2026年03月29日"]

你一眼就能看出来，这些数据不是不能看。 但问题很多：

有空格 有空字符串 有 None有大小写不统一 有格式不统一 有明显无效值

如果不先清洗，后面很多操作都会出问题。

比如你想去重邮箱，结果：

"TEST@QQ.COM"" test@qq.com "

明明是同一个邮箱，却会被当成两个值。

你想统计手机号，结果有的带横杠，有的带空格，有的根本不是手机号。 那统计出来的结果自然也不靠谱。

所以真实项目里，清洗往往不是附加步骤，而是前置步骤。

很多分析结果之所以不准，不是因为分析方法错了。 而是因为输入数据本身就没整理干净。

二、为什么数据清洗往往比你想象中更重要

很多新手刚开始学 Python 时，会更关注“抓数据”和“算结果”。

比如：

怎么爬网页 怎么读文件 怎么统计平均值 怎么画图

这些当然重要。

但如果数据本身乱糟糟，再漂亮的统计也可能没意义。

举个最简单的例子。

假设你要统计某个班有多少学生交了作业，拿到的名单是这样的：

students = ["张三", "李四", "张三 ", " 王五", "李四", ""]

如果你直接统计长度，会得到 6。 但这显然不对。

因为里面有重复名字，有前后空格，还有空字符串。 真正有效的学生，其实只有 3 个。

再比如做销量统计时，商品名可能出现：

"iPhone 15""iphone 15"" iPhone 15 "

如果不统一格式，你的统计结果就会把它们当成三个不同商品。

所以你一定要建立一个很重要的意识：

垃圾进，垃圾出。 脏数据进去，再好的逻辑出来的结果也可能是错的。

这就是为什么很多真实业务中，数据清洗要占掉大量时间。 有时候甚至比“正式分析”还花时间。

三、什么叫函数式清洗

这个标题里最关键的词，不是“清洗”，而是“函数式”。

所谓函数式清洗，你不用把它理解成特别高深的函数式编程理论。 在这一章里，我们讲得更实用一点：

把每一种清洗动作，单独写成一个函数。 让函数有明确输入和输出。 再按顺序把多个函数组合起来处理数据。

比如：

去掉前后空格，是一个函数。 统一大小写，是一个函数。 去掉手机号里的横杠和空格，是一个函数。 判断邮箱是否合法，是一个函数。 把日期转成统一格式，是一个函数。

然后你把这些函数拼起来，就形成了一条清洗流水线。

这种方式和“把所有逻辑乱写在一个大循环里”相比，最大的优势就是：

更清楚 更容易改 更容易复用 更容易测试 更像正式项目代码

这就是本章真正想带你掌握的思路。

四、为什么不推荐把清洗逻辑全堆在一起

很多人一开始写数据清洗，往往会写成下面这种样子：

users = [" 张三 ", "李四", "", None, "  王五"]result = []for user in users:if user isnotNone:        user = user.strip()if user != "":            result.append(user)

这段代码其实没问题，也能跑。 但如果需求一多，代码就会迅速变乱。

比如后面你又想加上：

去重 统一大小写 去掉特殊字符 判断长度是否合法 过滤测试账号

这时你很容易把一堆 if、一堆字符串操作、一堆判断全塞进一个循环里。 最后代码越来越长，越来越难读。

这类代码最典型的问题有三个。

第一，不好复用。 如果你别的地方也要清洗用户名，你还得再写一遍。

第二，不好定位问题。 出了错，你很难一眼看出是哪一步出了问题。

第三，不好扩展。 后面要新增规则时，往往越改越乱。

所以更好的做法，是把逻辑拆开。

这就是函数式清洗的起点。

五、先从最简单的清洗函数开始

我们先写一个最基础的清洗函数：清洗姓名。

假设原始数据里，姓名可能有前后空格，也可能是空字符串，甚至可能是 None。

那可以先写一个函数：

defclean_name(name):if name isNone:returnNone    name = name.strip()if name == "":returnNonereturn name

来测试一下：

print(clean_name(" 张三 "))print(clean_name("   "))print(clean_name(None))

输出：

张三NoneNone

你会发现，这种写法有一个非常大的好处：

规则被封装进函数里了。

以后只要是清洗姓名，你都可以直接调用 clean_name()。 不用每次都重新写一遍 strip() 和判空逻辑。

这就是函数封装带来的第一层价值。

六、再写一个手机号清洗函数

手机号通常比姓名更乱。

有的带横杠，有的带空格，有的根本不是手机号。

例如：

"13812345678""138-1234-5678"" 156 0000 1111 ""abc"""

这时候，我们可以写一个更像样的清洗函数：

import redefclean_phone(phone):if phone isNone:returnNone    phone = phone.strip()    phone = phone.replace("-", "").replace(" ", "")if re.fullmatch(r"1[3-9]\d{9}", phone):return phonereturnNone

测试一下：

print(clean_phone("13812345678"))print(clean_phone("138-1234-5678"))print(clean_phone(" 156 0000 1111 "))print(clean_phone("abc"))

输出：

138123456781381234567815600001111None

这里你要特别注意一个思路：

清洗函数不只是“改格式”，还可以顺手做校验。 符合规则，就返回标准化结果。 不符合规则，就返回 None。

这种设计非常实用。

因为后面你可以很方便地根据 None 判断，这条数据是不是无效。

七、邮箱清洗函数也非常适合封装

邮箱数据常见的问题也很多：

前后空格 大小写不统一 格式不合法

例如：

" TEST@QQ.COM "" admin@test.com ""wrong_email"None

可以写成这样：

import redefclean_email(email):if email isNone:returnNone    email = email.strip().lower()if re.fullmatch(r"[\w.-]+@[\w.-]+\.\w+", email):return emailreturnNone

测试一下：

print(clean_email(" TEST@QQ.COM "))print(clean_email(" admin@test.com "))print(clean_email("wrong_email"))

输出：

test@qq.comadmin@test.comNone

这里你会看到一个很重要的清洗动作：

统一大小写。

因为邮箱统计、去重时，大小写不统一非常容易产生重复值。

所以标准化的核心，不只是“让它看起来整齐”。 更是为了让后续处理更一致。

八、日期清洗为什么尤其值得函数化

日期是最容易乱的字段之一。

比如你可能遇到：

"2026-03-29""2026/3/29""2026.03.29""2026年03月29日"

这些明明表示的是同一天，但格式完全不统一。

如果后面你要排序、比较、统计，最好先统一格式。

可以这样写：

from datetime import datetimedefclean_date(text):if text isNone:returnNone    text = text.strip()    formats = ["%Y-%m-%d","%Y/%m/%d","%Y.%m.%d","%Y年%m月%d日"    ]for fmt in formats:try:            dt = datetime.strptime(text, fmt)return dt.strftime("%Y-%m-%d")except ValueError:continuereturnNone

测试一下：

print(clean_date("2026-03-29"))print(clean_date("2026/3/29"))print(clean_date("2026.03.29"))print(clean_date("2026年03月29日"))print(clean_date("乱写的日期"))

输出：

2026-03-292026-03-292026-03-292026-03-29None

这就是非常典型的函数式清洗。

不管外部日期长什么样，只要能识别出来，最后统一输出成标准格式。

后面你再排序、比较、入库，就会轻松很多。

九、把一个字段一个字段清洗，和把一整条记录清洗，是两回事

前面我们写的都是单字段清洗函数。

这很好，也很必要。 但真实业务里，你经常拿到的不是单个值，而是一整条记录。

例如：

user = {"name": " 张三 ","phone": "138-1234-5678","email": " TEST@QQ.COM ","join_date": "2026/3/29"}

这时候你不可能每次都手动写：

user["name"] = clean_name(user["name"])user["phone"] = clean_phone(user["phone"])user["email"] = clean_email(user["email"])user["join_date"] = clean_date(user["join_date"])

虽然这样也行，但如果记录很多、字段很多，就会显得很分散。

更好的做法，是再封装一个“清洗整条记录”的函数。

比如：

defclean_user(user):return {"name": clean_name(user.get("name")),"phone": clean_phone(user.get("phone")),"email": clean_email(user.get("email")),"join_date": clean_date(user.get("join_date"))    }

然后你就可以这样用：

user = {"name": " 张三 ","phone": "138-1234-5678","email": " TEST@QQ.COM ","join_date": "2026/3/29"}print(clean_user(user))

输出：

{'name': '张三','phone': '13812345678','email': 'test@qq.com','join_date': '2026-03-29'}

这一步非常关键。

因为从这里开始，你的代码已经不再只是“处理某个值”，而是在“处理结构化记录”。 这就非常接近真实项目了。

十、为什么这种写法会让代码一下子清楚很多

你把前面的代码回头再看一遍，会发现一个明显变化。

以前是一坨逻辑混在一起。 现在是：

字段清洗函数负责各自规则。 记录清洗函数负责组织流程。

这个结构有很大的好处。

第一，职责很清楚。 名字清洗就是 clean_name 的事。 手机号清洗就是 clean_phone 的事。

第二，复用很方便。 以后别的表、别的接口、别的文件里，只要有手机号字段，都能直接复用。

第三，改动很安全。 比如手机号规则改了，你只改 clean_phone() 就行，不必全局乱翻代码。

第四，调试更容易。 如果邮箱总出问题，你重点检查 clean_email() 就行。

这就是“把复杂问题拆成小函数”的价值。

很多正式项目代码，之所以看起来不乱，不是因为逻辑少。 而是因为它把逻辑拆得足够清楚。

十一、函数式清洗最核心的原则：一个函数只做一件事

这是非常重要的一条原则。

比如 clean_phone()，它就专注干三件小事：

去空格 去连接符 判断是否合法

而它不去做别的事，比如： 不负责去重 不负责排序 不负责写文件 不负责打印报表

这就是单一职责。

你越早养成这个习惯，后面代码越不容易乱。

因为一旦一个函数同时做很多事，后面你自己都容易搞不清它到底是干什么的。

比如下面这种函数就不太理想：

defprocess_user(user):# 清洗字段# 判断是否有效# 打印日志# 保存文件# 统计数量

这种函数看起来很能干，实际上非常难维护。

更稳妥的思路是： 清洗归清洗 校验归校验 统计归统计 输出归输出

这样每一步都清楚。

十二、函数式清洗不等于必须写得很花哨

很多人一看到“函数式”这三个字，就会自动想到：

map()filter()lambda高阶函数 链式调用

这些东西当然有关系，但你千万别把自己吓住。

在真实项目里，函数式清洗最重要的，不是炫技。 而是把逻辑封装成函数，并让函数之间可以组合。

哪怕你最后还是用最普通的 for 循环来调这些函数，也完全没有问题。

例如：

users = [    {"name": " 张三 ", "phone": "138-1234-5678", "email": " TEST@QQ.COM ", "join_date": "2026/3/29"},    {"name": "李四", "phone": "abc", "email": "lisi@test.com", "join_date": "2026-03-28"},    {"name": "  ", "phone": "156 0000 1111", "email": "wrong_email", "join_date": "2026年03月27日"}]cleaned_users = []for user in users:    cleaned_users.append(clean_user(user))print(cleaned_users)

这已经是函数式清洗了。

所以你不要把注意力全放在“花哨语法”上。 先把封装和组合做好，才是重点。

十三、什么时候该保留无效值，什么时候该直接过滤掉

这是数据清洗里一个很实际的问题。

比如 clean_phone() 返回了 None，说明手机号无效。 那你是保留这条记录，还是直接删掉

答案要看业务场景。

如果这是用户资料表，手机号缺失不一定代表整条记录没用。 那你可以保留这条记录，只是让手机号字段变成 None。

但如果这是一个“短信通知名单”，那手机号无效就意味着这条记录不能用。 这时候就应该过滤掉。

所以清洗通常分两层：

第一层，字段标准化。 把值尽量整理干净，不能整理的就返回 None。

第二层，记录过滤。 根据业务规则，决定哪些记录保留，哪些记录淘汰。

这个分层非常重要。

清洗函数负责把值整理清楚。 过滤逻辑负责决定要不要留下这条数据。

不要把这两件事混成一件事。

十四、写一个记录校验函数，会让流程更清楚

比如我们规定：

姓名不能为空 手机号必须有效 邮箱必须有效

那可以单独写一个校验函数：

defis_valid_user(user):if user["name"] isNone:returnFalseif user["phone"] isNone:returnFalseif user["email"] isNone:returnFalsereturnTrue

然后再配合清洗流程：

users = [    {"name": " 张三 ", "phone": "138-1234-5678", "email": " TEST@QQ.COM ", "join_date": "2026/3/29"},    {"name": "李四", "phone": "abc", "email": "lisi@test.com", "join_date": "2026-03-28"},    {"name": "  ", "phone": "156 0000 1111", "email": "wrong_email", "join_date": "2026年03月27日"}]result = []for user in users:    cleaned = clean_user(user)if is_valid_user(cleaned):        result.append(cleaned)print(result)

输出最终只会保留真正有效的用户记录。

这里的结构非常值得你模仿。

先清洗 再校验 最后收集结果

这就是一个很稳的清洗流程。

十五、这其实已经有一点“数据流水线”的味道了

如果你把前面的步骤抽象一下，会发现整个过程已经很像一条流水线：

原始数据进来 每个字段分别清洗 整条记录重新组装 按规则判断是否有效 有效的进入结果集 无效的被丢弃或单独记录

这就是数据处理里非常经典的思路。

很多人觉得数据清洗很乱，其实恰恰是因为没有流程意识。 总是一会儿去空格，一会儿判断，一会儿统计，一会儿打印，全部搅在一起。

一旦你把它想成流水线，思路会顺很多。

程序最怕的不是步骤多。 而是步骤没有边界。

函数式清洗的价值，恰恰就在于帮你建立这种边界。

十六、再进一步：你可以把多个小函数串起来

比如我们继续聚焦字符串清洗。

有时候一个字段要经过多个小步骤，比如：

先去前后空格 再把多个连续空格变成一个 再统一大小写 再去掉首尾特殊符号

如果你都写在一个函数里，当然也行。 但有时拆成更小的函数，会更灵活。

例如：

import redefstrip_text(text):if text isNone:returnNonereturn text.strip()defnormalize_spaces(text):if text isNone:returnNonereturn re.sub(r"\s+", " ", text)deflower_text(text):if text isNone:returnNonereturn text.lower()

然后你可以在上层函数里组合：

defclean_title(title):    title = strip_text(title)    title = normalize_spaces(title)    title = lower_text(title)return title

测试一下：

print(clean_title("  Python   数据处理 入门  "))

输出：

python 数据处理 入门

这时候你会发现，函数就像积木一样。

你不必每次都从零写。 你可以把基础清洗动作拆成小模块，后面不断复用。

这就是函数式思维带来的另一层好处。

十七、map 和 filter 在清洗中能做什么

虽然前面说过，不必一上来追求花哨写法。 但你也应该知道，map() 和 filter() 在清洗里确实有用。

先看 map()。

它适合对一批数据做“同一种转换”。

例如我们有一组姓名：

names = [" 张三 ", "李四 ", "  王五"]

想统一去空格，可以写：

cleaned_names = list(map(clean_name, names))print(cleaned_names)

输出：

['张三', '李四', '王五']

再看 filter()。

它适合按条件过滤结果。

比如：

phones = ["13812345678", "abc", "15600001111", ""]cleaned_phones = list(map(clean_phone, phones))valid_phones = list(filter(None, cleaned_phones))print(valid_phones)

输出：

['13812345678', '15600001111']

这里的流程其实很清楚：

先用 map() 统一清洗 再用 filter() 去掉无效值

这种写法确实有一点函数式风格。

但我要提醒你，能看懂就行。 真正写项目时，用 for 循环还是 map/filter，不是最重要的。 重点是思路是不是清楚。

十八、列表推导式在清洗场景里通常更常见

比起 map() 和 filter()，很多 Python 项目里更常见的，其实是列表推导式。

因为它更直观。

比如清洗一批邮箱，再过滤掉无效值：

emails = [" TEST@QQ.COM ", "wrong_email", " admin@test.com "]result = [clean_email(email) for email in emails]result = [email for email in result if email isnotNone]print(result)

输出：

['test@qq.com', 'admin@test.com']

或者直接一步写完：

emails = [" TEST@QQ.COM ", "wrong_email", " admin@test.com "]result = [cleaned for cleaned in (clean_email(email) for email in emails) if cleaned isnotNone]print(result)

不过对初学者来说，前一种拆成两步的写法更容易读懂。

这一点你要记住： 代码不是越短越高级。 而是越清楚越好。

十九、函数式清洗最大的好处之一，是特别容易测试

这个好处非常容易被低估。

比如你写了 clean_phone()，那你完全可以单独测试它：

print(clean_phone("13812345678"))print(clean_phone("138-1234-5678"))print(clean_phone(" 156 0000 1111 "))print(clean_phone("abc"))print(clean_phone(None))

你很快就能知道规则是否正确。

同样，clean_email()、clean_date() 也都可以单独测试。

这和“大循环里塞满逻辑”的区别非常大。

如果逻辑都混在一起，你每次测试都得跑完整流程，出了问题还不容易定位。 但现在你可以逐个函数验证。

所以函数式清洗不只是代码更好看。 它还会让你调试效率高很多。

这在真实开发里特别重要。

二十、写一个完整一点的小案例：清洗一批用户资料

现在我们把前面的思路连起来，做一个更完整的例子。

原始数据如下：

raw_users = [    {"name": " 张三 ", "phone": "138-1234-5678", "email": " TEST@QQ.COM ", "join_date": "2026/3/29"},    {"name": "李四", "phone": "abc", "email": "lisi@test.com", "join_date": "2026-03-28"},    {"name": "  ", "phone": "156 0000 1111", "email": "wrong_email", "join_date": "2026年03月27日"},    {"name": "王五", "phone": "13988889999", "email": "wangwu@example.com", "join_date": "2026.03.26"}]

我们先准备前面写过的函数：

import refrom datetime import datetimedefclean_name(name):if name isNone:returnNone    name = name.strip()if name == "":returnNonereturn namedefclean_phone(phone):if phone isNone:returnNone    phone = phone.strip()    phone = phone.replace("-", "").replace(" ", "")if re.fullmatch(r"1[3-9]\d{9}", phone):return phonereturnNonedefclean_email(email):if email isNone:returnNone    email = email.strip().lower()if re.fullmatch(r"[\w.-]+@[\w.-]+\.\w+", email):return emailreturnNonedefclean_date(text):if text isNone:returnNone    text = text.strip()    formats = ["%Y-%m-%d", "%Y/%m/%d", "%Y.%m.%d", "%Y年%m月%d日"]for fmt in formats:try:            dt = datetime.strptime(text, fmt)return dt.strftime("%Y-%m-%d")except ValueError:continuereturnNonedefclean_user(user):return {"name": clean_name(user.get("name")),"phone": clean_phone(user.get("phone")),"email": clean_email(user.get("email")),"join_date": clean_date(user.get("join_date"))    }defis_valid_user(user):return user["name"] isnotNoneand user["phone"] isnotNoneand user["email"] isnotNone

然后开始清洗：

raw_users = [    {"name": " 张三 ", "phone": "138-1234-5678", "email": " TEST@QQ.COM ", "join_date": "2026/3/29"},    {"name": "李四", "phone": "abc", "email": "lisi@test.com", "join_date": "2026-03-28"},    {"name": "  ", "phone": "156 0000 1111", "email": "wrong_email", "join_date": "2026年03月27日"},    {"name": "王五", "phone": "13988889999", "email": "wangwu@example.com", "join_date": "2026.03.26"}]cleaned_users = []invalid_users = []for user in raw_users:    cleaned = clean_user(user)if is_valid_user(cleaned):        cleaned_users.append(cleaned)else:        invalid_users.append(cleaned)print("有效数据：")for user in cleaned_users:    print(user)print("无效数据：")for user in invalid_users:    print(user)

这个例子非常值得你多看几遍。

因为它已经非常接近真实项目里常见的数据清洗脚本结构了。

二十一、如果清洗完之后还要去重怎么办

这时前一章的内容就能接上了。

比如你清洗完用户资料后，发现有些手机号重复。 那你就可以继续做“按手机号去重”。

例如：

defdeduplicate_users(users):    seen = set()    result = []for user in users:        phone = user["phone"]if phone notin seen:            seen.add(phone)            result.append(user)return result

然后配合前面的清洗结果：

unique_users = deduplicate_users(cleaned_users)print(unique_users)

你会发现，章节之间已经开始串起来了。

先清洗 再过滤 再去重 后面还可以统计

这才是一个完整的数据处理流程。

所以不要把每一章都孤立看。 它们其实是在慢慢拼成一整套能力。

二十二、如果清洗完之后还要统计怎么办

比如你想统计：

有效用户有多少 无效用户有多少 注册日期最早的是哪天 不同邮箱后缀分别有多少个

也完全可以接着往下做。

例如统计数量：

print("有效用户数量：", len(cleaned_users))print("无效用户数量：", len(invalid_users))

再比如统计邮箱后缀：

from collections import Counterdomains = []for user in cleaned_users:    domain = user["email"].split("@")[1]    domains.append(domain)print(Counter(domains))

你看，清洗不是终点。 它是后续统计和分析的基础。

很多时候，清洗做得越规范，后面所有步骤就越轻松。

二十三、真实项目里，最常见的不是“复杂算法”，而是“脏数据治理”

很多初学者会觉得，真正难的东西一定是高深算法。 但你以后做项目会越来越发现：

更多时间花在处理数据细节上。

字段名不统一 日期格式不一致 手机号写法混乱 缺失值要不要保留 无效值怎么处理 重复值按什么规则认定 错误数据要不要单独记录

这些问题，看起来都不“高大上”。 但它们特别常见，也特别影响结果。

而函数式清洗的价值就在这里。

它不能让数据自动变完美。 但它能让你处理这些问题时，思路更清楚、代码更稳。

这其实就是从“会写脚本”走向“会写真正有用的处理程序”的一步。

二十四、函数式清洗的一个隐藏好处：以后特别适合接测试

虽然我们现在还没正式进入测试章节，但你已经可以提前感受到它的价值。

比如如果以后你要给 clean_phone() 写测试用例，会非常方便。

因为这个函数输入明确，输出明确。

传进来 "138-1234-5678"，就应该得到 "13812345678"。 传进来 "abc"，就应该得到 None。

这类函数特别适合测试。

而“写死在流程里的一堆零散代码”，就不容易做这种细粒度验证。

所以你现在每多养成一点函数化思维，后面工程化能力就会更强一点。

二十五、给初学者一个非常实用的建议

以后你写数据清洗代码时，尽量按下面这个顺序想问题：

第一步，先看数据脏在哪里。 是空格问题，还是大小写问题，还是格式问题，还是无效值问题。

第二步，把每一种清洗动作拆成小函数。 一个函数解决一种小问题。

第三步，再写一个上层函数，把这些小函数组装起来。 比如清洗整条记录。

第四步，决定哪些数据保留，哪些过滤。 这一步是业务规则，不要和字段清洗混为一谈。

第五步，清洗后再做去重、排序、统计。 不要把全部逻辑挤在一起。

只要你按这个顺序走，代码通常都会比较稳。

二十六、这一章真正要带走的，不是几个函数，而是一种整理复杂度的方法

到这里，你应该能慢慢感觉到，函数式清洗最重要的价值不是“高级”，而是“有秩序”。

数据本身已经够乱了。 如果代码也乱，那事情就会越来越难收拾。

而函数化的好处，就是把混乱拆开。 让每一步都有边界，让每一步都能单独理解、单独测试、单独修改。

这其实是一种非常重要的编程能力。

不是把所有事都一口气写完。 而是把复杂任务拆成一块一块，再拼起来。

这一点，不只是数据清洗能用。 你后面做自动化、爬虫、接口处理、Web 开发，都会反复用到。

所以这一章表面讲的是清洗数据。 更深一层，其实是在训练你怎么把复杂逻辑写得有条理。

本章小结

函数式清洗数据，核心不是炫技，也不是刻意写得很复杂。 它最本质的思路是：

把清洗动作拆成独立函数。 让每个函数只做一件事。 再把这些函数按顺序组合起来，形成稳定的数据清洗流程。

这一章你要重点掌握几件事。

脏数据通常表现为格式不统一、空值、无效值、重复值、大小写混乱等问题。 清洗函数可以负责标准化，也可以顺手做基础校验。 字段清洗和记录过滤，最好分开处理。 单字段函数、整条记录函数、校验函数，组合起来就能形成一条清晰的数据流水线。

更重要的是，你要开始建立这样一种意识：

数据清洗不是临时补丁。 它是后续去重、统计、分析、入库的基础。

当你学会把清洗逻辑写成一组清楚的小函数时，你的代码就已经开始越来越像真正的项目代码了。

课后练习

第一，自己写一个 clean_name()，要求去掉前后空格，并把空字符串转成 None。

第二，写一个 clean_phone()，要求兼容纯数字、带横杠、带空格三种手机号格式，并统一输出成纯数字。

第三，写一个 clean_email()，要求去空格、转小写、过滤无效邮箱。

第四，写一个 clean_date()，至少兼容三种不同日期格式，并统一转成 YYYY-MM-DD。

第五，自己构造一组用户字典数据，写一个 clean_user() 和 is_valid_user()，把有效数据和无效数据分开。

第六，在清洗完成后，再按手机号去重，最后统计有效用户一共有多少条。