🧠 Python 数据处理文档
核心思路：遍历 + dict + 排序
🟢 一、1 - 10）
1. 字符统计
Python
s = "aabbbcc" # 定义待处理的字符串
count = {} # 初始化一个空字典用于存储计数结果
for c in s: # 遍历字符串中的每一个字符
count[c] = count.get(c, 0) + 1 # 获取当前字符计数，不存在则默认为0，然后加1
print(count) # 输出计数字典
2. 数组去重
Python
arr = [1,2,2,3] # 定义包含重复元素的列表
res = list(set(arr)) # 将列表转为集合(set)自动去重，再转回列表
print(res) # 输出去重后的列表
3. 去重 + 排序
Python
arr = [3,1,2,3] # 定义乱序且有重复的列表
res = list(set(arr)) # 利用set去重
res.sort() # 调用sort方法对列表进行原地升序排序
print(res) # 输出去重并排序后的结果
4. 找最大值
Python
arr = [10,5,20] # 定义数值列表
print(max(arr)) # 使用内置函数max获取列表中的最大值并打印
5. 找最小值
Python
arr = [10,5,20] # 定义数值列表
print(min(arr)) # 使用内置函数min获取列表中的最小值并打印
6. 求和
Python
arr = [1,2,3] # 定义数值列表
print(sum(arr)) # 使用内置函数sum计算列表中所有元素的总和
7. 字符串反转
Python
s = "abc" # 定义字符串
print(s[::-1]) # 使用切片语法 [开始:结束:步长]，步长为-1表示从后往前取
8. 判断回文
Python
s = "abba" # 定义字符串
print(s == s[::-1]) # 将原字符串与反转后的字符串比较，相等则为回文
9. 统计列表中元素出现次数
Python
arr = [1,1,2,3] # 定义列表
count = {} # 初始化字典
for x in arr: # 遍历列表元素
count[x] = count.get(x, 0) + 1 # 统计每个元素出现的频率
print(count) # 打印统计结果
10. 遍历字典
Python
d = {"a":1,"b":2} # 定义字典
for k, v in d.items(): # 使用items()同时获取键(key)和值(value)
print(k, v) # 打印键值对
🟡 二、（11 - 20）
11. 找出现最多的元素
Python
arr = [1,1,2,2,2,3] # 定义列表
count = {} # 初始化计数字典
for x in arr: # 遍历并计数
count[x] = count.get(x, 0) + 1
# 使用max函数，通过key参数指定比较规则为字典的值(count.get)
print(max(count, key=count.get))
12. 按值排序字典
Python
d = {"a":3,"b":1,"c":2} # 定义字典
# 使用sorted排序，d.items()转化成元组列表，key指定按元组第二个元素(值)排序
res = sorted(d.items(), key=lambda x: x[1])
print(res) # 输出排序后的元组列表
13. 列表元素平方
Python
arr = [1,2,3] # 定义数值列表
res = [x*x for x in arr] # 列表推导式：对arr中每个元素x执行x*x操作
print(res) # 输出 [1, 4, 9]
14. 过滤大于2的数
Python
arr = [1,2,3,4] # 定义数值列表
res = [x for x in arr if x > 2] # 列表推导式配合if条件过滤
print(res) # 输出 [3, 4]
15. 两个数组配对
Python
a = [1,2,3] # 第一个列表
b = ["a","b","c"] # 第二个列表
for x, y in zip(a, b): # 使用zip将两个列表对应索引的元素打包成元组
print(x, y) # 同时遍历打印
16. JSON排序
Python
import json # 导入json模块
data = '[{"age":20},{"age":18}]' # 定义json格式字符串
arr = json.loads(data) # 将字符串解析为Python列表对象
arr.sort(key=lambda x: x["age"]) # 按字典中"age"键的值进行升序排序
print(arr) # 输出排序后的列表
17. 按字段排序对象
Python
data = [
{"name":"a","score":80},
{"name":"b","score":90}
] # 定义列表嵌套字典的数据
# 使用sort排序，reverse=True表示降序
data.sort(key=lambda x: x["score"], reverse=True)
print(data) # 输出按成绩从高到低排序的结果
18. 找Top1
Python
arr = [10,30,20] # 定义数值列表
print(max(arr)) # 获取并打印列表中的最大值
19. 统计字符串单词数量
Python
s = "hello world hello" # 定义带空格的字符串
words = s.split() # 默认按空格切割字符串，返回单词列表
count = {} # 初始化计数字典
for w in words: # 遍历单词列表
count[w] = count.get(w, 0) + 1 # 统计单词频次
print(count) # 输出结果
20. 判断是否存在某元素
Python
arr = [1,2,3] # 定义列表
print(2 in arr) # 使用 in 关键字判断元素是否在容器中，返回布尔值
🔵 三、进阶题（21 - 30）
21. 分组统计（核心）
Python
data = [
{"type":"A","value":10},
{"type":"A","value":20},
{"type":"B","value":5}
] # 定义原始数据列表
result = {} # 用于存储分组累加结果
for d in data: # 遍历每个字典对象
t = d["type"] # 获取类型
if t not in result: # 如果该类型第一次出现
result[t] = 0 # 初始化值为0
result[t] += d["value"] # 累加当前字典的value值
print(result) # 输出：{'A': 30, 'B': 5}
22. 分组 + 平均值
Python
data = [
{"type":"A","value":10},
{"type":"A","value":20}
] # 定义原始数据
result = {} # 用于存储求平均所需的中间数据
for d in data: # 遍历数据
t = d["type"] # 获取分组类型
if t not in result: # 初始化该类型的总和及计数
result[t] = {"sum":0,"count":0}
result[t]["sum"] += d["value"] # 累加数值
result[t]["count"] += 1 # 累加出现次数
for t in result: # 遍历计算后的中间字典
avg = result[t]["sum"] / result[t]["count"] # 计算平均值
print(t, avg) # 打印分组名和平均分
23. 最大利润（经典）
Python
prices = [7,1,5,3,6,4] # 股票每日价格列表
min_price = prices[0] # 初始化最低买入价格为第一天价格
max_profit = 0 # 初始化最高利润为0
for p in prices: # 遍历每一天的价格
min_price = min(min_price, p) # 更新历史最低价格
max_profit = max(max_profit, p - min_price) # 更新最大利润（当前价格减去最低价）
print(max_profit) # 输出最大可能利润
24. 找两个数之和
Python
arr = [2,7,11,15] # 定义列表
target = 9 # 目标和
d = {} # 辅助字典：存储 {数值: 索引}
for i, num in enumerate(arr): # 同时获取索引i和数值num
if target - num in d: # 如果 目标值减当前值 的结果已在字典中
print(d[target-num], i) # 找到匹配对，打印它们的索引
d[num] = i # 将当前值和索引存入字典
25. 合并两个列表
Python
a = [1,2] # 列表A
b = [3,4] # 列表B
print(a + b) # 使用 + 运算符拼接两个列表并输出
26. 队列（先进先出）
Python
from collections import deque # 从标准库导入双端队列
q = deque() # 创建队列对象
q.append(1) # 向右端添加元素1
q.append(2) # 向右端添加元素2
print(q.popleft()) # 从左端弹出并打印第一个进入的元素（先进先出）
27. 栈（后进先出）
Python
stack = [] # 使用普通列表模拟栈
stack.append(1) # 入栈元素1
stack.append(2) # 入栈元素2
print(stack.pop()) # 弹出并打印最后进入的元素（后进先出）
28. 使用Counter计数
Python
from collections import Counter # 导入计数器类
arr = [1,1,2] # 定义列表
count = Counter(arr) # 快速统计列表中各元素出现的次数
print(count) # 输出：Counter({1: 2, 2: 1})
29. 找TopK
Python
import heapq # 导入堆队列算法库
arr = [3,1,5,2] # 定义列表
print(heapq.nlargest(2, arr)) # 获取列表中最大的前2个元素
30. 用户消费Top1
Python
data = [
{"user":"A","amount":100},
{"user":"B","amount":200},
{"user":"A","amount":50}
] # 定义消费数据
total = {} # 存储用户总金额
for d in data: # 遍历每笔消费
u = d["user"] # 获取用户名
total[u] = total.get(u, 0) + d["amount"] # 累加消费金额
# 找到金额最大的键
max_user = max(total, key=total.get)
print(max_user, total[max_user]) # 打印最高消费者及其金额
股票利润计算（补充逻辑注释版）
Python
prices = [7,1,5,3,6,4] # 每日股价
# 只能买卖一次
# 求最大利润（低买高卖）
# 输出：5
min_price = prices[0] # 假定第一天价格最低
max_profit = 0; # 初始利润为0
for p in prices: # 遍历每日价格
if p < min_price: # 如果当前价格比历史最低还低
min_price = p # 更新最低买入价
profit = p - min_price # 计算如果今天卖出的利润
if profit > max_profit: # 如果该利润大于历史最高利润
max_profit = profit # 更新最高利润
print(max_profit) # 输出最终结果
消费统计进阶版
Python
data = [
{"user": "A", "amount": 100},
{"user": "B", "amount": 200},
{"user": "A", "amount": 50},
{"user": "C", "amount": 400},
{"user": "B", "amount": 100}
] # 模拟更复杂的数据集
# 要求：
# 1. 统计每个用户总消费
# 2. 找出消费最高的用户
total = {} # 用于统计的字典
for d in data: # 遍历数据
sum_amount = d["user"] # 获取当前记录的用户名
total[sum_amount] = total.get(sum_amount,0)+d["amount"] # 累加金额
max_user = max(total,key=total.get) # 获取消费金额最大的用户名
print(max_user,total[max_user]) # 打印该用户及其总额
股票平均价排序版
Python
trades = [
{"symbol": "AAPL", "price": 10},
{"symbol": "AAPL", "price": 12},
{"symbol": "GOOG", "price": 8},
{"symbol": "GOOG", "price": 10},
{"symbol": "MSFT", "price": 15}
] # 股票交易记录
# 要求：
# 1. 计算每个股票的平均价格
# 2. 按平均价格从高到低排序
price_groups = {} # 存储分组价格列表 {简称: [价格1, 价格2...]}
for t in trades: # 遍历交易记录
s = t["symbol"] # 提取股票简称
p = t["price"] # 提取价格
if s not in price_groups: # 如果简称第一次出现
price_groups[s] = [] # 初始化列表
price_groups[s].append(p) # 将价格加入对应的列表
result = {} # 存储最终平均值
for s,price in price_groups.items(): # 遍历分组后的字典
result[s] = sum(price) / len(price) # 计算平均数并存入结果字典
result_list = list(result.items()) # 将字典转为元组列表以便排序
# 对元组列表进行排序，x[1]表示按平均价排序，reverse=True为降序
# 注意：原代码此处 x[0] 是按名称排序，若按价格需改为 x[1]
result_list.sort(key=lambda x:x[1],reverse=True)
print(result_list) # 输出最终排序结果
🎯 总结
- 遍历（for） ：处理集合中每个元素的基础。
- 计数（dict） ：利用字典的键唯一性进行分类和频次统计。
- 排序（sort / lambda） ：对处理后的数据进行展示优化，lambda用于定义灵活的排序规则。
- 分组（dict嵌套） ：处理复杂结构（如求平均、分类型统计）的核心手段。
