Python map()函数批量处理序列的操作详解

numbers = [1, 2, 3, 4, 5]

# 方法一：for循环
result1 = []
for n in numbers:
    result1.append(n * 2)
print(result1)  # [2, 4, 6, 8, 10]

# 方法二：列表推导式
result2 = [n * 2 for n in numbers]
print(result2)  # [2, 4, 6, 8, 10]

# 方法三：map()函数
result3 = list(map(lambda n: n * 2, numbers))
print(result3)  # [2, 4, 6, 8, 10]

# map()的语法：
# map(function, iterable, ...)
# function: 要应用到每个元素的函数
# iterable: 一个或多个可迭代对象
# 返回值: map对象（迭代器），不是列表！

# ⌨️ 基本使用
def square(x):
    return x ** 2

numbers = [1, 2, 3, 4, 5]
result = map(square, numbers)

print(type(result))     # <class 'map'>
print(result)            # <map object at 0x...>
print(list(result))     # [1, 4, 9, 16, 25]

# ⚠️ map对象是迭代器——只能遍历一次！
result = map(square, numbers)
print(list(result))     # [1, 4, 9, 16, 25]
print(list(result))     # []  —— 第二次遍历为空！迭代器已耗尽

# 💡 如果需要多次使用，先转成列表
result = list(map(square, numbers))
print(result)  # [1, 4, 9, 16, 25]
print(result)  # [1, 4, 9, 16, 25]  —— 列表可以多次访问

# map()和内置函数是黄金搭档
# 内置函数通常用c实现，速度快

# 类型转换
str_numbers = ["1", "2", "3", "4", "5"]
int_numbers = list(map(int, str_numbers))
print(int_numbers)  # [1, 2, 3, 4, 5]

# 字符串处理
words = ["  python  ", "  java  ", "  rust  "]
cleaned = list(map(str.strip, words))
print(cleaned)  # ['python', 'java', 'rust']

lowered = list(map(str.lower, cleaned))
print(lowered)  # ['python', 'java', 'rust']

# 计算长度
word_lengths = list(map(len, lowered))
print(word_lengths)  # [6, 4, 4]

# 取绝对值
numbers = [-5, 3, -8, 1, -2]
abs_values = list(map(abs, numbers))
print(abs_values)  # [5, 3, 8, 1, 2]

# 计算ascii码
chars = ['a', 'b', 'c', 'a', 'b', 'c']
ascii_codes = list(map(ord, chars))
print(ascii_codes)  # [97, 98, 99, 65, 66, 67]

# ascii码转回字符
codes = [72, 101, 108, 108, 111]
letters = list(map(chr, codes))
print("".join(letters))  # hello

# 💡 map()可以接收多个可迭代对象
# function必须接收与可迭代对象数量相同的参数

# 两个列表的元素相加
a = [1, 2, 3, 4, 5]
b = [10, 20, 30, 40, 50]
sums = list(map(lambda x, y: x + y, a, b))
print(sums)  # [11, 22, 33, 44, 55]

# 使用内置函数 operator.add
import operator
sums2 = list(map(operator.add, a, b))
print(sums2)  # [11, 22, 33, 44, 55]

# 三个列表
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
products = list(map(lambda a, b, c: a * b * c, x, y, z))
print(products)  # [28, 80, 162]

# 💡 实际应用：合并多个数据源
names = ["张三", "李四", "王五"]
scores = [85, 92, 78]
grades = ["b", "a", "c"]

# 格式化为字符串
records = list(map(
    lambda name, score, grade: f"{name}: {score}分({grade})",
    names, scores, grades
))
for r in records:
    print(r)
# 张三: 85分(b)
# 李四: 92分(a)
# 王五: 78分(c)

# ⚠️ map()以最短的可迭代对象为准——多余的被忽略

a = [1, 2, 3, 4, 5]
b = [10, 20, 30]  # 只有3个元素

result = list(map(lambda x, y: x + y, a, b))
print(result)  # [11, 22, 33]  —— 只处理了前3对！

# 如果需要填充不足的部分，使用 itertools.zip_longest
from itertools import zip_longest

a = [1, 2, 3, 4, 5]
b = [10, 20, 30]

# 用0填充不足的部分
result2 = list(map(
    lambda pair: pair[0] + (pair[1] if pair[1] is not none else 0),
    zip_longest(a, b, fillvalue=0)
))
# 更简单的写法
result3 = [x + y for x, y in zip_longest(a, b, fillvalue=0)]
print(result3)  # [11, 22, 33, 4, 5]

import time

# 准备数据
numbers = list(range(1_000_000))

# 测试 map() 性能
start = time.perf_counter()
result_map = list(map(lambda x: x * 2 + 1, numbers))
map_time = time.perf_counter() - start
print(f"map(): {map_time:.4f}秒")

# 测试列表推导式性能
start = time.perf_counter()
result_listcomp = [x * 2 + 1 for x in numbers]
listcomp_time = time.perf_counter() - start
print(f"列表推导式: {listcomp_time:.4f}秒")

# 测试 for 循环性能
start = time.perf_counter()
result_loop = []
for x in numbers:
    result_loop.append(x * 2 + 1)
loop_time = time.perf_counter() - start
print(f"for循环: {loop_time:.4f}秒")

# 结果可能类似：列表推导式 ≈ map > for循环
# 使用内置函数时map可能更快（因为是c实现的）
start = time.perf_counter()
result_builtin = list(map(abs, numbers))
builtin_time = time.perf_counter() - start
print(f"map(内置函数): {builtin_time:.4f}秒")

# 选型指南

# ✅ 场景一：简单的转换——列表推导式更可读
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]  # 清晰直观

# ✅ 场景二：使用内置函数——map()更简洁
strings = ["1", "2", "3"]
ints = list(map(int, strings))  # 比 [int(s) for s in strings] 更简洁

# ✅ 场景三：需要条件过滤——列表推导式（map + filter很啰嗦）
numbers = [1, 2, 3, 4, 5, 6]
even_squares = [x ** 2 for x in numbers if x % 2 == 0]
# vs
even_squares_map = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))
# 列表推导式明显更清晰

# ✅ 场景四：多序列处理——map+operator 简洁
import operator
a = [1, 2, 3]
b = [4, 5, 6]
sums = list(map(operator.add, a, b))
# vs
sums_lc = [x + y for x, y in zip(a, b)]
# 两者都可以，map+operator稍微更"函数式"

# 💡 总结：没有绝对的"更好"
# - 简单转换 → 选你最舒服的
# - 有过滤条件 → 列表推导式
# - 用内置函数 → map()
# - 多序列 → map() 或 zip+列表推导式

# 场景：将api返回的字符串数据转为需要的格式

# 模拟api返回的温度数据（字符串，带单位）
api_response = ["23.5°c", "18.2°c", "30.1°c", "15.8°c", "27.3°c"]

# 使用map进行流水线处理
# 步骤1：去掉单位
# 步骤2：转为浮点数
# 步骤3：摄氏度转华氏度
# 步骤4：格式化输出

temps_c_str = list(map(lambda s: s.replace("°c", ""), api_response))
temps_c = list(map(float, temps_c_str))
temps_f = list(map(lambda c: c * 9/5 + 32, temps_c))
temps_f_str = list(map(lambda f: f"{f:.1f}°f", temps_f))

print(temps_f_str)
# ['74.3°f', '64.8°f', '86.2°f', '60.4°f', '81.1°f']

# 或者链式调用（用生成器表达式更清晰）
def convert_temperatures(raw_data):
    """温度转换流水线"""
    # 每一步都是可理解的转换
    stripped = map(lambda s: s.rstrip("°c"), raw_data)
    as_float = map(float, stripped)
    to_fahrenheit = map(lambda c: c * 9/5 + 32, as_float)
    formatted = map(lambda f: f"{f:.1f}°f", to_fahrenheit)
    return list(formatted)

print(convert_temperatures(api_response))

# 场景：处理电子表格中的数据
headers = ["姓名", "数学", "语文", "英语"]
rows = [
    ["张三", "85", "92", "78"],
    ["李四", "90", "88", "95"],
    ["王五", "76", "85", "82"],
]

# 分别提取各列并转换类型
names = list(map(lambda row: row[0], rows))
math_scores = list(map(lambda row: int(row[1]), rows))
chinese_scores = list(map(lambda row: int(row[2]), rows))
english_scores = list(map(lambda row: int(row[3]), rows))

# 计算每个学生的总分和平均分
total_scores = list(map(
    lambda m, c, e: m + c + e,
    math_scores, chinese_scores, english_scores
))
avg_scores = list(map(lambda t: round(t / 3, 1), total_scores))

for i, name in enumerate(names):
    print(f"{name}: 总分={total_scores[i]}, 平均={avg_scores[i]}")
# 张三: 总分=255, 平均=85.0
# 李四: 总分=273, 平均=91.0
# 王五: 总分=243, 平均=81.0

# ⚠️ 注意1：map返回的是迭代器，不是列表
result = map(str.upper, ["a", "b", "c"])
# 要转成列表才能多次访问
result_list = list(result)

# ⚠️ 注意2：map是惰性求值的
# 在list()调用之前，函数还没有被实际执行
result = map(lambda x: print(x), [1, 2, 3])
# 这里什么都不会打印！还没求值
list(result)  # 现在才会打印 1 2 3

# ⚠️ 注意3：迭代器只能消费一次
result = map(str, [1, 2, 3])
len1 = sum(1 for _ in result)  # 3
len2 = sum(1 for _ in result)  # 0 ——迭代器已空