前面几章，我们已经讲了 JSON、正则、时间处理。
你会发现，数据处理这件事，到这里已经越来越像真实工作了。
先从接口里把数据拿出来。 再从文本里把关键信息提取出来。 再把时间字段转成程序能理解的形式。
可光做到这里，还不够。
因为大多数时候，数据拿到手之后，你并不是立刻就结束了。 你通常还要继续做三类动作：
把数据按某种规则排一排 把重复内容清一清 把关键结果算一算
这三件事，看起来基础，实际上特别高频。
做成绩统计时，要按分数排序。 做用户数据清洗时，要把重复手机号去掉。 做销售分析时，要统计总数、平均值、最大值。 做日志分析时，要统计某个错误出现了多少次。 做商品数据整理时，要按价格从低到高排好。
所以这一章讲的内容，虽然不花哨，但非常重要。
如果说前面几章是在教你把数据拿进来，那么这一章开始，就是在教你怎么把数据变得更有价值。
排序、去重、统计，这三件事，几乎就是基础数据分析的三板斧。
一、为什么这三件事几乎所有项目都会遇到
很多初学者会有一个误区。 觉得数据分析好像是专门做报表的人才需要学的。
其实不是。
只要你在处理数据，不管你是不是做专业分析，排序、去重、统计都会反复出现。
比如你做一个通讯录程序。 你要按姓名排序，按拼音排序，按最近联系时间排序。
比如你做一个爬虫。 你抓下来 1000 个链接，可能里面有很多重复项。 你得先去重。
比如你做一个学生成绩系统。 你要统计总人数、及格人数、平均分、最高分、最低分。
你会发现，这三件事不是某个特定方向才会用，而是各种方向都会碰到。
换句话说，真正的数据处理，很多时候不是高深算法。 而是把这些基础动作做扎实。
谁把这些基本功练熟了，谁后面做项目就会更顺。
二、先建立一个很重要的意识：数据拿到手，不等于有价值
假设你抓到了一批商品价格：
prices = [199, 99, 299, 99, 159, 199, 89]
这串数据拿到了吗。 拿到了。
但它现在有多大价值，其实很有限。
因为它还是原始状态。
你一眼很难看出：
最便宜的是多少 最贵的是多少 一共有多少条 有没有重复值 平均价格是多少 按从低到高排是什么样
也就是说，原始数据只是材料。 真正的信息，要靠后续处理提炼出来。
而排序、去重、统计，恰恰就是最常见的提炼方式。
所以从这一章开始，你要慢慢养成一个习惯： 看到一组数据时，不要只想着把它打印出来。 而要开始问自己：
它能不能排一下 它有没有重复 它能统计出什么结果
这个意识一建立，数据处理能力就会明显往前走一步。
三、排序到底是在解决什么问题
排序这件事看起来很普通，但它的作用非常大。
因为数据一旦没有顺序，人就很难快速看出规律。
比如下面这组成绩：
scores = [78, 95, 63, 88, 91, 70]
如果不排序，它只是一些散乱数字。
但如果排完序：
[63, 70, 78, 88, 91, 95]
你一下子就能看出最低分、最高分、分布情况。
这就是排序最直接的价值： 让混乱的数据变得有秩序。
现实开发里，排序的用途非常多。
按价格从低到高展示商品 按时间从新到旧展示日志 按销量从高到低展示排行榜 按成绩从高到低输出名次 按文件大小排序，找出最大的几个文件
所以排序不是为了好看。 而是为了更容易观察、更容易比较、更容易决策。
四、Python 里最常见的排序方法有两个
学排序，先记住两个最常用的方式就够了：
sorted()list.sort()
它们都能完成排序，但用法和特点不一样。
先看 sorted()。
nums = [5, 2, 9, 1, 7]result = sorted(nums)print(nums)print(result)
输出：
[5, 2, 9, 1, 7][1, 2, 5, 7, 9]
这里要注意，sorted() 不会修改原列表。 它会返回一个新的排好序的结果。
再看 sort()。
nums = [5, 2, 9, 1, 7]nums.sort()print(nums)
输出：
[1, 2, 5, 7, 9]
这次原列表本身被改掉了。
所以你可以这样记：
sorted() 产生新结果，不动原数据sort() 直接修改原列表
这个区别非常重要。 后面做真实项目时，经常会影响程序逻辑。
五、什么时候该用 sorted，什么时候该用 sort
这个问题很实际。
如果你只是想临时得到一个排序结果，同时还想保留原始数据，那就更适合用 sorted()。
比如：
scores = [78, 95, 63, 88]sorted_scores = sorted(scores)print("原数据：", scores)print("排序后：", sorted_scores)
原数据不会丢。
但如果你本来就希望把这个列表直接重新整理成有序状态，那用 sort() 会更直接。
比如：
scores = [78, 95, 63, 88]scores.sort()print(scores)
这时候原列表就变了。
对于初学者来说，一个很实用的建议是： 刚开始更推荐多用 sorted()。
因为它更安全。 你不容易在不知不觉中把原数据改掉。
等你对列表可变性更熟了，再根据场景选择 sort() 也不迟。
六、升序和降序怎么控制
默认情况下，Python 排序是升序。
也就是从小到大，从低到高，从早到晚。
例如：
nums = [5, 2, 9, 1, 7]print(sorted(nums))
输出：
[1, 2, 5, 7, 9]
如果你想改成降序，可以加上 reverse=True。
nums = [5, 2, 9, 1, 7]print(sorted(nums, reverse=True))
输出：
[9, 7, 5, 2, 1]
这在排行榜、成绩排序、销量排序里非常常见。
比如按成绩从高到低：
scores = [78, 95, 63, 88, 91]print(sorted(scores, reverse=True))
输出：
[95, 91, 88, 78, 63]
这就是排行榜的基本雏形。
所以排序时，你要先问自己一句： 我到底想看最小的排前面，还是最大的排前面
这个方向意识很重要。
七、不只是数字，字符串也能排序
很多人一提排序，就只想到数字。 其实字符串同样可以排。
例如：
names = ["Tom", "Alice", "Jack", "Bob"]print(sorted(names))
输出：
['Alice', 'Bob', 'Jack', 'Tom']
它本质上是按字母顺序排的。
中文字符串也可以排，但默认规则主要是按字符编码来处理。 对于初学阶段来说，你先知道它能排就够了。
再看一个更贴近业务的例子：
cities = ["上海", "北京", "广州", "深圳"]print(sorted(cities))
它也会得到一个稳定的排序结果。
不过这里要提醒你，中文排序如果涉及拼音顺序、首字母顺序、复杂规则，后面通常需要借助更专门的处理方式。 但在当前阶段，我们先掌握基础排序思路即可。
八、真正有价值的排序，往往不是排简单数字，而是排复杂数据
真实开发里，很多数据不是一个纯数字列表，而是一组字典、元组、对象。
比如学生成绩数据：
students = [ {"name": "张三", "score": 85}, {"name": "李四", "score": 92}, {"name": "王五", "score": 78}]
这时候你不是想直接比较整个字典。 你真正想要的是： 按字典里的某个字段排序。
比如按分数排序。
这时就要用到 key。
students = [ {"name": "张三", "score": 85}, {"name": "李四", "score": 92}, {"name": "王五", "score": 78}]result = sorted(students, key=lambda x: x["score"])print(result)
输出：
[ {'name': '王五', 'score': 78}, {'name': '张三', 'score': 85}, {'name': '李四', 'score': 92}]
如果想按分数从高到低：
result = sorted(students, key=lambda x: x["score"], reverse=True)print(result)
输出：
[ {'name': '李四', 'score': 92}, {'name': '张三', 'score': 85}, {'name': '王五', 'score': 78}]
这类写法非常常见。
商品列表按价格排序 员工列表按工资排序 订单列表按创建时间排序 文章列表按阅读量排序
后面你会越来越频繁地见到 key= 这个参数。
九、key 到底该怎么理解
很多人第一次看到 key=lambda x: x["score"] 会有点晕。
其实你不用把它想得太玄乎。
key 的意思可以简单理解成： 排序时，拿什么作为比较依据
比如这组学生字典：
{"name": "张三", "score": 85}
如果不告诉 Python 比较什么，它不知道该怎么比字典。
但你一旦写上：
key=lambda x: x["score"]
意思就是： 每条数据都拿它的 score 字段出来参与排序。
如果写成：
key=lambda x: x["name"]
那就是按姓名排序。
例如：
students = [ {"name": "张三", "score": 85}, {"name": "李四", "score": 92}, {"name": "王五", "score": 78}]result = sorted(students, key=lambda x: x["name"])print(result)
你会得到按姓名规则排列的结果。
所以 key 的本质不是一种神秘语法。 它只是告诉排序函数： 你要看哪一部分
这个思路非常重要。
十、去重又是在解决什么问题
接下来讲第二板斧：去重。
排序是在整理顺序。 去重是在清理冗余。
现实数据里，重复内容非常常见。
爬虫抓下来的链接可能重复 用户名单里手机号可能重复 日志里某类错误可能重复出现 商品列表里某个商品可能抓了两遍 Excel 表格里某些行可能录入重复
如果不去重，数据就会显得很乱，统计结果也容易失真。
比如一份用户名单里，同一个人出现两次，那人数统计就不准了。 一批商品链接里有大量重复，你后面爬取时就浪费时间。 一个邮箱列表不去重，发通知时就可能给同一个人发多遍。
所以去重的意义不是单纯让列表变短。 而是让后续分析、统计、处理更可靠。
十一、最简单的去重方式：set
Python 里最基础的去重方式，就是集合 set。
因为集合有一个非常重要的特点： 元素不能重复
例如：
nums = [1, 2, 2, 3, 4, 4, 4, 5]result = set(nums)print(result)print(type(result))
输出可能是：
{1, 2, 3, 4, 5}<class 'set'>
这说明重复数字被自动去掉了。
如果你还想把结果变回列表，可以再转一次：
nums = [1, 2, 2, 3, 4, 4, 4, 5]unique_nums = list(set(nums))print(unique_nums)
这就是最常见的基础去重写法。
它很短，也很方便。
十二、为什么很多人去重后会觉得结果怪怪的
因为 set 去重虽然方便，但有个很重要的特点：
它不保证原来的顺序
例如：
names = ["张三", "李四", "张三", "王五", "李四"]print(list(set(names)))
输出结果里的元素顺序，可能和原列表不一致。
这对某些场景没问题。 比如你只是想知道总共有哪几个唯一值。
但如果你的业务对顺序敏感，这种方法就不够稳妥了。
比如：
评论列表本来按时间顺序排列 你去重后还希望保留第一次出现的顺序 这时候直接 set 就可能打乱原顺序
所以你要记住：
set 适合快速去重 但不适合要求保留原顺序的场景
这个区别很重要。
十三、既想去重，又想保留原顺序，怎么办
这是实战里很常见的需求。
比如有这样一组数据：
names = ["张三", "李四", "张三", "王五", "李四", "赵六"]
你想去重后得到：
["张三", "李四", "王五", "赵六"]
也就是说，只保留第一次出现的顺序。
一个常见写法是自己维护一个结果列表：
names = ["张三", "李四", "张三", "王五", "李四", "赵六"]result = []for name in names:if name notin result: result.append(name)print(result)
输出：
['张三', '李四', '王五', '赵六']
这个方法虽然不如 set 一行那么短，但它更符合很多真实业务需要。
因为顺序被保住了。
这也是一个很值得你体会的点： 不是代码越短越好。 而是越符合场景越好。
十四、复杂数据去重，往往没那么简单
如果数据是数字、字符串，去重相对简单。
但如果你面对的是字典列表，就不能直接 set() 了。
例如：
users = [ {"name": "张三", "phone": "13800000001"}, {"name": "李四", "phone": "13800000002"}, {"name": "王五", "phone": "13800000001"}]
这里你真正想去重的依据，可能是手机号，而不是整个字典。
因为字典内容不同，不代表不是重复用户。 有可能只是名字写法不一样，但手机号相同。
这时你要先明确： 到底按什么去重
比如按手机号去重，可以这样写：
users = [ {"name": "张三", "phone": "13800000001"}, {"name": "李四", "phone": "13800000002"}, {"name": "王五", "phone": "13800000001"}]seen = set()result = []for user in users: phone = user["phone"]if phone notin seen: seen.add(phone) result.append(user)print(result)
输出：
[ {'name': '张三', 'phone': '13800000001'}, {'name': '李四', 'phone': '13800000002'}]
这种写法很常见。
也特别能说明一个问题： 去重不是机械地删重复，而是先定义重复标准。
这才是真实数据处理的思维。
十五、统计又是在解决什么问题
前面排序是整理顺序，去重是清理重复。
那统计，就是把数据进一步变成结论。
例如：
一共多少条 最大值是多少 最小值是多少 总和是多少 平均值是多少 每个类别分别出现多少次
这些都属于统计。
而统计之所以重要，是因为程序最终往往不是只要原始数据，而是要一个能支撑决策的结果。
比如销售系统里，老板不一定关心每一笔订单明细。 他更关心今天总销售额是多少，平均客单价是多少，哪个商品卖得最多。
比如学生成绩系统里，老师不一定只想看分数列表。 他更想知道平均分、及格人数、最高分是谁。
所以统计的本质，是从一堆数据里提炼出摘要信息。
十六、最基础的统计函数，先掌握这些就很够用
Python 本身已经给了我们很多好用的基础统计工具。
比如：
len() 看数量sum() 求总和max() 求最大值min() 求最小值
先看一个例子：
scores = [78, 95, 63, 88, 91]print("人数：", len(scores))print("总分：", sum(scores))print("最高分：", max(scores))print("最低分：", min(scores))
输出：
人数： 5总分： 415最高分： 95最低分： 63
这几个函数看起来简单，但真的特别常用。
很多实际业务逻辑，都是从这些最基础的统计开始的。
所以别因为它们简单就小看它们。 真正高频的能力，往往就是这些基础动作。
十七、平均值怎么计算
平均值本身没有单独的内置函数，但计算很简单：
总和 ÷ 数量
例如：
scores = [78, 95, 63, 88, 91]average = sum(scores) / len(scores)print("平均分：", average)
输出：
平均分： 83.0
如果你想保留两位小数，可以这样写：
scores = [78, 95, 63, 88, 91]average = sum(scores) / len(scores)print(f"平均分：{average:.2f}")
输出：
平均分：83.00
平均值是各种分析里都特别常见的一项。 平均成绩、平均价格、平均耗时、平均访问量，几乎处处都有。
所以这个公式虽然简单，但一定要熟。
十八、如果数据为空，统计时要注意什么
这是实战里非常关键的一点。
比如一个列表是空的：
scores = []
这时候：
len(scores) 没问题 但 sum(scores) / len(scores) 就会出错max(scores) 和 min(scores) 也会出错
因为空列表没有最大值、最小值，而且数量是 0，不能直接做除法。
所以更稳妥的写法应该是先判断：
scores = []if scores: average = sum(scores) / len(scores) print("平均分：", average) print("最高分：", max(scores)) print("最低分：", min(scores))else: print("当前没有数据")
这个细节非常值得你记住。
真实业务里，空数据是很常见的。 别总默认数据一定存在。
会处理空数据的人，代码通常更稳。
十九、统计某个值出现了多少次
有时候我们关心的不是总和和平均值，而是频率。
比如：
某个成绩出现了几次 某个错误日志出现了几次 某个单词在文本里出现了几次 某个城市在用户列表里出现了几次
如果只是统计某一个值出现次数，可以直接用 count()。
例如：
nums = [1, 2, 2, 3, 2, 4, 5]print(nums.count(2))
输出：
3
再比如：
cities = ["北京", "上海", "北京", "广州", "北京"]print(cities.count("北京"))
输出：
3
这个方法非常直观，适合做单个值的频次统计。
二十、如果要统计所有元素的出现次数，怎么办
如果你想统计整个列表里每个元素分别出现了多少次，单靠 count() 一个个查会比较麻烦。
这时候就很适合用 collections 模块里的 Counter。
例如：
from collections import Countercities = ["北京", "上海", "北京", "广州", "北京", "上海"]result = Counter(cities)print(result)
输出大致是：
Counter({'北京': 3, '上海': 2, '广州': 1})
你可以把它理解成一种专门做计数的字典。
它特别适合这种频次统计场景。
比如统计日志级别：
from collections import Counterlevels = ["INFO", "ERROR", "INFO", "WARNING", "ERROR", "ERROR"]result = Counter(levels)print(result)
输出：
Counter({'ERROR': 3, 'INFO': 2, 'WARNING': 1})
这在日志分析、词频统计、用户标签统计里都特别常用。
二十一、Counter 不只是统计，还能直接找出最常见的内容
这是 Counter 很好用的一个地方。
比如你想知道，出现次数最多的前两个元素是什么，可以用 most_common()。
from collections import Counterwords = ["python", "java", "python", "c", "python", "java"]result = Counter(words)print(result.most_common(2))
输出：
[('python', 3), ('java', 2)]
这个功能在很多场景里都非常有价值。
比如：
评论里出现最多的关键词 日志中最常见的错误类型 销售数据里最常卖的商品 用户最常来自哪个城市
你看，很多看起来像小型分析报告的东西，底层就是这么来的。
二十二、把排序、去重、统计放到一个小例子里，你会更容易看懂
假设现在有一组商品价格数据：
prices = [199, 99, 299, 99, 159, 199, 89, 299, 129]
我们来一步一步处理。
先排序：
prices = [199, 99, 299, 99, 159, 199, 89, 299, 129]sorted_prices = sorted(prices)print("排序后：", sorted_prices)
输出：
排序后： [89, 99, 99, 129, 159, 199, 199, 299, 299]
再去重：
unique_prices = sorted(set(prices))print("去重后：", unique_prices)
输出：
去重后： [89, 99, 129, 159, 199, 299]
再统计：
print("总数量：", len(prices))print("不同价格有几种：", len(set(prices)))print("最高价：", max(prices))print("最低价：", min(prices))print("平均价：", sum(prices) / len(prices))
你会发现，一组原本很普通的数据，经过这几步处理后，立刻就有信息量了。
这就是三板斧的力量。
二十三、再看一个更贴近业务的数据案例：学生成绩分析
现在我们来做一个更像真实项目的小案例。
students = [ {"name": "张三", "score": 85}, {"name": "李四", "score": 92}, {"name": "王五", "score": 78}, {"name": "赵六", "score": 92}, {"name": "小刘", "score": 66}]
第一步，按成绩从高到低排序：
sorted_students = sorted(students, key=lambda x: x["score"], reverse=True)print(sorted_students)
第二步，统计平均分、最高分、最低分：
scores = [student["score"] for student in students]print("人数：", len(scores))print("平均分：", sum(scores) / len(scores))print("最高分：", max(scores))print("最低分：", min(scores))
第三步，统计及格人数：
pass_count = 0for score in scores:if score >= 60: pass_count += 1print("及格人数：", pass_count)
第四步，找出最高分学生：
top_score = max(scores)for student in students:if student["score"] == top_score: print("最高分学生：", student["name"], student["score"])
这个例子特别值得你慢慢体会。
因为这已经很接近一个简单成绩分析程序了。
而它背后的核心动作，并不复杂。 本质上仍然是排序、统计、筛选。
这说明什么
说明很多“看起来像分析”的事情，并不是一定要靠复杂库才能做。 你用 Python 基础能力就已经能做出不少东西。
二十四、列表推导式会让统计写法更顺手
到了这里，你会发现一个很自然的需求。
比如我们想从学生数据里拿出所有分数：
scores = [student["score"] for student in students]
这其实就是列表推导式在数据处理里的典型用法。
它会让你做统计时特别顺手。
再比如，只拿及格分数：
pass_scores = [student["score"] for student in students if student["score"] >= 60]
或者只拿学生姓名：
names = [student["name"] for student in students]
所以你会发现，前面学过的推导式，到这一章就开始越来越有用了。
真正有价值的知识点，不是学完就结束。 而是会在后面的场景里不断复用。
二十五、排序、去重、统计，很多时候是连着出现的
真实工作里，这三件事通常不是分开的，而是串在一起。
例如处理用户注册数据时：
先按注册时间排序 再按手机号去重 最后统计每天新增人数
例如处理商品数据时：
先按商品编号去重 再按价格排序 最后统计均价和最高价
例如处理日志时：
先把重复错误去掉 再按时间排序 最后统计每种错误出现次数
所以你不要把这一章理解成三个孤立的小功能。 它们其实经常是一个连续流程。
谁能把这三步串起来，谁就已经具备了基础数据分析的雏形。
二十六、看一个完整一点的小案例：整理一份订单金额数据
假设你现在拿到了一批订单金额：
orders = [99, 199, 99, 299, 159, 199, 89, 299, 129, 89]
现在你希望完成下面几件事：
按金额从低到高排序 去掉重复金额 统计订单总数 统计总金额 统计平均金额 统计每个金额分别出现几次
代码可以这样写：
from collections import Counterorders = [99, 199, 99, 299, 159, 199, 89, 299, 129, 89]sorted_orders = sorted(orders)unique_orders = sorted(set(orders))total_count = len(orders)total_amount = sum(orders)average_amount = total_amount / total_countamount_count = Counter(orders)print("排序后：", sorted_orders)print("去重后：", unique_orders)print("订单总数：", total_count)print("订单总金额：", total_amount)print("平均订单金额：", average_amount)print("各金额出现次数：", amount_count)
输出结果会非常清晰。
这个例子虽然不长，但已经有一点“小分析脚本”的味道了。
而你仔细看，会发现核心依然是这一章讲的内容。
二十七、学到这里，你应该开始具备一种分析意识
这一点比语法本身更重要。
以前你拿到一组数据，可能只是想： 怎么把它打印出来
现在你要慢慢升级成： 怎么从这组数据里看出规律
排序，是为了看顺序和大小关系。 去重，是为了看真实唯一值。 统计，是为了看整体分布和概要结果。
这其实已经是数据分析最基本的思维了。
很多人学 Python 学了一段时间之后，依然停留在“会写代码”的阶段。 而真正能把代码用起来的人，往往会在这里发生变化。
因为他不再满足于程序能跑。 他开始关心： 程序能不能帮我把数据说清楚
这就是很重要的一步。
二十八、初学者在这一章最容易踩的坑
第一个坑，是分不清 sorted() 和 sort()。
前者返回新列表，后者修改原列表。 这个一定要分清。
第二个坑，是用 set() 去重后，发现顺序乱了，却不知道为什么。
因为集合本来就不保证原顺序。
第三个坑，是统计平均值时忘了处理空列表。
结果一除以 0 就报错。
第四个坑，是面对字典列表时，不知道该按哪个字段排序、按哪个字段去重。
这时候你要记住，先问自己： 我的比较依据是什么 我的重复标准是什么
第五个坑，是只会算数字，不会结合业务含义。
比如算出了平均分，却不知道还要看及格率。 算出了商品数量，却没想到还要统计不同商品数。 所以别只盯着函数，得盯着问题本身。
二十九、给你一个特别实用的写代码建议
以后只要拿到一批数据，你都可以先做一个小检查。
先看看数量 再看看有没有重复 再看看排完序是什么样 最后想想能统计出什么指标
这个习惯非常好用。
比如：
data = [199, 99, 299, 99, 159, 199, 89]print("原始数据：", data)print("数量：", len(data))print("去重后数量：", len(set(data)))print("排序后：", sorted(data))print("最大值：", max(data))print("最小值：", min(data))print("平均值：", sum(data) / len(data))
你会发现，很多数据一旦做完这几步，轮廓一下子就清楚了。
这其实就是最朴素的分析习惯。
三十、这一章真正要学会的，不只是几个函数，而是一个处理套路
到这里，你应该能感觉到，这一章虽然讲的都是基础操作，但它们已经开始形成一个套路了。
当你拿到数据时，先问： 要不要排序
当你发现重复时，接着问： 要不要去重，去重标准是什么，顺序要不要保留
当你想提炼结论时，再问： 要统计总量、均值、最大值，还是频次分布
只要这个套路建立起来，你以后面对很多数据题、练习题、项目需求，思路都会清楚很多。
这比单纯背会 sorted、set、Counter 的名字更重要。
因为真正做项目时，没有人会告诉你应该用哪个函数。 你得自己识别问题。
而这一章训练的，恰恰就是这种识别能力。
本章小结
排序、去重、统计，是最基础也最常见的数据处理三板斧。
排序让数据更有秩序，方便观察大小规律。 去重让数据更干净，避免重复带来的误判。 统计让数据从原始记录变成可读结论。
这一章最常用的工具包括：
sorted() 和 sort() 用来排序set() 用来快速去重len()、sum()、max()、min() 用来做基础统计count() 和 Counter 用来统计出现次数
更重要的是，你要开始建立一种新的意识：
拿到数据之后，不只是把它存起来、打印出来。 而是要试着把它排一排、清一清、算一算。
当你开始这样处理数据时，你的 Python 就已经不只是会写，而是在真正发挥作用了。
课后练习
你可以自己动手练这几个小题，效果会特别明显。
第一，准备一组成绩数据，分别输出升序结果、降序结果、最高分、最低分和平均分。
第二，准备一组带重复的用户名，分别用 set 去重，和用循环保序去重，观察结果差异。
第三，准备一组城市列表，统计每个城市分别出现了多少次，并找出出现次数最多的城市。
第四，准备一个学生字典列表，按分数从高到低排序，再统计及格人数和平均分。
第五，把一组商品价格数据先去重，再排序，最后统计不同价格一共有几种。
10个月宝宝每天需要喝多少奶粉？
