Python-VBA函数之旅-map函数

一、map函数的常见应用场景

二、map函数使用注意事项

三、如何用好map函数？

1、map函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客

一、map函数的常见应用场景

map函数在Python中非常有用，它提供了一种简洁的方式来对序列中的每个元素应用一个函数，常见的应用场景有：

1、数据转换：假设你有一个整数列表，你想将它们都转换为字符串，使用map()函数可以很容易地完成这个任务。

2、字符串处理：如果你有一个字符串列表，并想要将每个字符串转换为大写，可以使用map()函数轻松实现。

3、过滤和筛选：尽管map()函数主要用于转换，但结合条件表达式(如lambda函数中的if语句)，它也可以用于过滤或筛选数据。例如，过滤出一个列表中所有的偶数。

4、与其他函数结合使用：map()函数可以与Python的其他内置函数或自定义函数一起使用，以实现更复杂的操作。例如，结合reduce()函数计算列表中所有数字的和。

5、并行处理多个序列：当你有多个序列，并且想要并行地对它们中的元素执行操作时，map()函数非常有用。例如，合并两个列表中的对应元素。

6、读取和处理文件数据：当从文件中读取数据时，可以使用map()函数来处理每一行数据。

7、结合可迭代对象使用：然map()函数最常用于处理列表，但它也可以与其他可迭代对象一起使用，如字典和集合。例如，你可以使用map()函数来更新字典中所有值。

8、替代循环：在某些情况下，使用map()函数可以使代码更简洁，避免显式的循环，这在函数式编程风格中特别常见，它倾向于使用高阶函数来操作数据，而不是使用显式的循环结构。

9、数学运算：你可以使用map()函数对列表中的每个元素执行数学运算。例如，计算列表中每个元素的平方。

总之，map()函数在Python中是一个强大的工具，可以用于各种序列处理任务，特别是当你需要对序列中的每个元素应用相同的函数时。

二、map函数使用注意事项

在Python中，map()函数是一个内置的高阶函数，用于将一个函数应用于一个或多个可迭代对象(如列表、元组等)的每个元素，并返回一个新的迭代器，其中包含应用函数后的结果。在使用map()函数时，需要注意以下几点：

1、参数类型：第一个参数应该是一个函数对象，可以是Python内置函数，也可以是用户自定义的函数；第二个及后续参数应该是一个或多个可迭代对象。

2、返回类型：在Python 3中，map()函数返回的是一个迭代器对象，而不是列表。如果你想要得到一个列表，需要将迭代器转换为列表，例如使用list()函数；在Python 2中，map()函数直接返回列表，但这一行为在Python 3中已被改变。

3、不改变原序列：map()函数不会修改原始的可迭代对象，而是返回一个新的迭代器。

4、处理异常：如果传入的函数在处理可迭代对象的元素时抛出异常，那么map()函数也会抛出该异常。因此，在使用map()函数时，需要确保传入的函数能够妥善处理可能出现的异常。

5、内存使用：由于map()返回的是迭代器，它在处理大量数据时具有内存优势，因为它不需要一次性将所有结果加载到内存中，这有助于处理大型数据集，减少内存消耗。

6、可迭代对象的长度：当对多个可迭代对象使用map()函数时，如果它们的长度不同，map()函数将在最短的可迭代对象耗尽时停止迭代，因此，要确保传入的可迭代对象具有相同的长度，或者能够妥善处理长度不一致的情况。

7、惰性加载特性：由于map()返回的是一个迭代器，因此它的计算是惰性的，即只有在需要时才会计算结果，这可以提高性能，特别是在处理大型数据集时。

8、线程安全：在多线程环境中使用map()函数时，需要注意线程安全问题。由于map()函数本身不是线程安全的，因此在多线程环境中使用时需要采取适当的同步措施。

总之，只有遵循这些注意事项，你才能更有效地使用map()函数，并避免常见的错误和问题。

三、如何用好map函数？

在Python中，map()函数是一个内置的高阶函数，用于将一个函数应用于一个或多个可迭代对象(如列表、元组等)的每个元素，并返回一个新的迭代器。为了用好map()函数，你需遵循以下建议：

1、理解map()函数的参数：第一个参数是一个函数，它将被应用于每个元素；第二个及之后的参数是可迭代对象，它们的元素将被传递给函数。

2、使用lambda表达式进行简单操作：对于简单的元素转换，你可以使用lambda表达式作为map()函数的第一个参数；Lambda表达式允许你定义一个匿名函数，直接在map()函数中使用。

3、使用已定义的函数：除了lambda表达式，你也可以使用已定义的函数作为map()的第一个参数，这在转换逻辑较复杂时特别有用。

4、处理多个可迭代对象：map()函数也可以接受多个可迭代对象，并将函数应用于它们中对应位置的元素，这在你需要对多个列表执行相同操作并获取结果时非常有用。

5、替代显式循环：在某些情况下，使用map()函数可以替代显式的循环，使代码更简洁易读，然而，请注意，当处理大型数据集时，显式循环可能具有更好的性能。

6、结合其他高阶函数：你可以将map()函数与其他高阶函数(如filter()和reduce())结合使用，以执行更复杂的操作，这允许你构建一系列的数据处理步骤。

7、返回值处理：记住map()函数返回的是一个迭代器，如果你需要一个列表或其他类型的集合，你需要将迭代器转换为相应的类型。

总之，只有通过遵循这些建议和最佳实践，你才能更有效地利用Python中的map()函数来处理数据和执行复杂的操作。

1、map函数：

1-1、Python：

# 1.函数：map
# 2.功能：用于将一个函数应用于一个或多个可迭代对象(如列表、元组等)的每个元素，并返回一个新的迭代器，即通过函数实现对可迭代对象的操作
# 3.语法：map(function, iterable, *iterables)
# 4.参数：
# 4-1、function:必须参数，表示函数
# 4-2、iterable(s):一个或多个可迭代对象，至少保证有1个
# 5.返回值：返回一个将function应用于iterable(s)的每一项，并产生其结果的迭代器
# 6.说明：
# 6-1、map()函数在Python 2.x返回得是列表，而在Python 3.x中返回得是可迭代器对象
# 6-2、当map()函数传入多个可迭代对象时，参数function必须能够接收足够多的参数，以保证每个可迭代对象同一索引的值均能正确传入函数，否则将提示TypeError异常
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(map))
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__',
# '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__',
# '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

# 用help()函数获取该函数的文档信息
help(map)

# 应用一：数据转换
# 示例1：将列表中的每个元素乘以一个常数
# 定义一个函数，将元素乘以常数2
def multiply_by_two(x):
    return x * 2
# 创建一个数字列表
numbers = [1, 2, 3, 4, 5]
# 使用map()函数将每个元素乘以 2
doubled_numbers = map(multiply_by_two, numbers)
# 将迭代器转换为列表以查看结果
doubled_numbers_list = list(doubled_numbers)
print(doubled_numbers_list)
# [2, 4, 6, 8, 10]

# 示例2：将字符串列表转换为大写
# 创建一个字符串列表
strings = ['myelsa', 'jimmy', 'python', 'bruce']
# 使用map()函数和内置的str.upper()方法将每个字符串转换为大写
uppercase_strings = map(str.upper, strings)
# 将迭代器转换为列表以查看结果
uppercase_strings_list = list(uppercase_strings)
print(uppercase_strings_list)
# ['MYELSA', 'JIMMY', 'PYTHON', 'BRUCE']

# 示例3：计算列表中每个字符串的长度
# 创建一个字符串列表
strings = ['apple', 'banana', 'cherry', 'date']
# 使用map()函数和内置的len()函数计算每个字符串的长度
lengths = map(len, strings)
# 将迭代器转换为列表以查看结果
lengths_list = list(lengths)
print(lengths_list)
# [5, 6, 6, 4]

# 示例4：将两个列表中的元素相加(假设它们长度相同)
# 定义两个列表
list1 = [3, 5, 6]
list2 = [8, 10, 11]
# 使用map()函数和lambda表达式将两个列表中的对应元素相加
sums = map(lambda x, y: x + y, list1, list2)
# 将迭代器转换为列表以查看结果
sums_list = list(sums)
print(sums_list)
# [11, 15, 17]

# 示例5：将两个列表中的元素相加(假设它们长度不相同)
# 定义两个列表
list1 = [3, 5, 6]
list2 = [8, 10]
# 使用map()函数和lambda表达式将两个列表中的对应元素相加
sums = map(lambda x, y: x + y, list1, list2)
# 将迭代器转换为列表以查看结果
sums_list = list(sums)
print(sums_list)
# [11, 15]

# 示例6：使用多个可迭代对象作为map()的参数
# 定义两个函数
def add(x, y):
    return x + y
def multiply(x, y):
    return x * y
# 创建两个数字列表
numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]
# 使用map()函数和lambda表达式，将两个函数应用于两个列表的对应元素
results_add = map(lambda x, y: add(x, y), numbers1, numbers2)
results_mul = map(lambda x, y: multiply(x, y), numbers1, numbers2)
# 将迭代器转换为列表以查看结果
results_add_list = list(results_add)
results_mul_list = list(results_mul)
print(results_add_list)
print(results_mul_list)
# [5, 7, 9]
# [4, 10, 18]

# 应用二：字符串处理
# 示例1：将字符串列表中的每个字符串转换为大写
# 定义一个字符串列表
strings = ['hello', 'world', 'python']
# 使用map()函数和内置的str.upper()方法将每个字符串转换为大写
uppercase_strings = map(str.upper, strings)
# 将迭代器转换为列表以查看结果
uppercase_strings_list = list(uppercase_strings)
print(uppercase_strings_list)
# ['HELLO', 'WORLD', 'PYTHON']

# 示例2：将字符串列表中的每个字符串的长度计算出来
# 定义一个字符串列表
strings = ['apple', 'banana', 'cherry']
# 使用map()函数和内置的len()函数计算每个字符串的长度
lengths = map(len, strings)
# 将迭代器转换为列表以查看结果
lengths_list = list(lengths)
print(lengths_list)
# [5, 6, 6]

# 示例3：将字符串列表中的每个字符串的首字母转换为大写(其余小写)
# 定义一个字符串列表
strings = ['hello', 'WORLD', 'python']
# 定义一个函数，将字符串的首字母转换为大写，其余转换为小写
def capitalize_first_letter(s):
    return s.capitalize()
# 使用map()函数将每个字符串的首字母转换为大写
capitalized_strings = map(capitalize_first_letter, strings)
# 将迭代器转换为列表以查看结果
capitalized_strings_list = list(capitalized_strings)
print(capitalized_strings_list)
# ['Hello', 'World', 'Python']

# 示例4：过滤字符串列表中的空字符串
# 定义一个包含空字符串的字符串列表
strings = ['apple', '', 'banana', '', 'cherry']
# 使用map()函数和filter()函数过滤掉空字符串
non_empty_strings = map(str.strip, filter(None, strings))
# 将迭代器转换为列表以查看结果
non_empty_strings_list = list(non_empty_strings)
print(non_empty_strings_list)
# ['apple', 'banana', 'cherry']

# 示例5：将字符串列表中的每个字符串拆分为字符列表
# 定义一个字符串列表
strings = ['myelsa', 'jimmy', 'bruce']

# 使用map()函数和内置的list()函数将每个字符串拆分为字符列表
char_lists = map(list, strings)

# 将迭代器转换为列表以查看结果
char_lists_list = list(char_lists)
print(
    char_lists_list)
# [['m', 'y', 'e', 'l', 's', 'a'], ['j', 'i', 'm', 'm', 'y'], ['b', 'r', 'u', 'c', 'e']]

# 应用三：过滤和筛选
# 示例1：使用map()和条件表达式过滤出非零元素
# 定义一个包含零和非零元素的数字列表
numbers = [0, 1, 2, 0, 3, 0, 4, 5, 0]
# 使用map()函数和条件表达式过滤出非零元素
non_zero_numbers = map(lambda x: x if x != 0 else None, numbers)
# 使用filter()函数去除None值
non_zero_numbers_filtered = filter(None.__ne__, non_zero_numbers)
# 将迭代器转换为列表以查看结果
non_zero_numbers_list = list(non_zero_numbers_filtered)
print(non_zero_numbers_list)
# [1, 2, 3, 4, 5]

# 示例2：使用map()和filter()筛选字符串列表中的非空字符串
# 定义一个包含空字符串的字符串列表
strings = ['apple', '', 'banana', ' ', 'cherry']
# 使用map()函数和strip()方法去除字符串两端的空白字符
stripped_strings = map(str.strip, strings)
# 使用filter()函数和lambda表达式过滤掉空字符串
non_empty_strings = filter(None, stripped_strings)
# 将迭代器转换为列表以查看结果
non_empty_strings_list = list(non_empty_strings)
print(non_empty_strings_list)
# ['apple', 'banana', 'cherry']

# 应用四：与其他函数结合使用
# 示例1：使用map()与内置函数abs()计算列表中每个数的绝对值
# 定义一个包含正负数的列表
numbers = [-1, 2, -3, 4, -5]
# 使用map()函数和abs()函数计算每个数的绝对值
absolute_values = map(abs, numbers)
# 将迭代器转换为列表以查看结果
absolute_values_list = list(absolute_values)
print(absolute_values_list)
# [1, 2, 3, 4, 5]

# 示例2：使用map()与自定义函数计算列表中每个数的平方
# 定义一个自定义函数，计算一个数的平方
def square(x):
    return x ** 2
# 定义一个数字列表
numbers = [1, 2, 3, 4, 5]
# 使用map()函数和自定义的square()函数计算每个数的平方
squares = map(square, numbers)
# 将迭代器转换为列表以查看结果
squares_list = list(squares)
print(squares_list)
# [1, 4, 9, 16, 25]

# 示例3：使用map()结合两个函数处理字符串列表
# 定义一个字符串列表
strings = ['  apple  ', ' banana ', '  cherry  ']
# 定义一个函数，用于去除字符串两端的空白字符
def strip_spaces(s):
    return s.strip()
# 定义一个函数，用于将字符串转换为大写
def to_uppercase(s):
    return s.upper()
# 使用map()函数结合两个函数处理字符串列表
processed_strings = map(to_uppercase, map(strip_spaces, strings))
# 将迭代器转换为列表以查看结果
processed_strings_list = list(processed_strings)
print(processed_strings_list)
# ['APPLE', 'BANANA', 'CHERRY']

# 示例4：使用map()与lambda表达式计算列表中每个元素的幂
# 定义一个数字列表
numbers = [1, 2, 3, 4, 5]
# 使用map()函数和lambda表达式计算每个数的三次幂
cubes = map(lambda x: x ** 3, numbers)
# 将迭代器转换为列表以查看结果
cubes_list = list(cubes)
print(cubes_list)
# [1, 8, 27, 64, 125]

# 应用五：并行处理多个序列
# 示例1：对两个列表中的元素进行相加
# 定义两个数字列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用zip()将两个列表的元素配对，然后使用map()和lambda表达式进行相加
sum_list = map(lambda x, y: x + y, list1, list2)
# 将迭代器转换为列表以查看结果
sum_list_result = list(sum_list)
print(sum_list_result)
# [5, 7, 9]

# 示例2：使用自定义函数处理多个列表中的元素
# 定义一个自定义函数，用于计算两个数的乘积并返回结果
def multiply(x, y):
    return x * y
# 定义两个数字列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
# 使用zip()将两个列表的元素配对，然后使用map()和自定义函数进行相乘
product_list = map(multiply, list1, list2)
# 将迭代器转换为列表以查看结果
product_list_result = list(product_list)
print(product_list_result)
# [4, 10, 18]

# 应用六：读取和处理文件数据
# 示例1：读取文件中的数据，并使用map()转换为整数列表
# 打开文件并读取所有行
with open('file.txt', 'r') as file:
    lines = file.readlines()
# 使用map()和str.split()以及int()将每一行的数字转换为整数列表
# 注意：这里假设每行都只有一个数字，如果有多个数字，你需要进一步处理
numbers_list = list(map(int, ''.join(lines).split()))
print(numbers_list)
# [121314536273838390, 123, 456, 789, 587, 1024]

# 示例2：读取文件中的字符串，并使用map()和自定义函数处理它们
# 定义一个函数，将字符串转换为大写
def to_uppercase(s):
    return s.upper()
# 打开文件并读取所有行
with open('file.txt', 'r') as file:
    lines = file.readlines()
# 使用map()和自定义函数将每行转换为大写
# 注意：这里假设每行都只有一个单词，如果有多个单词，你需要进一步处理
upper_words = list(map(to_uppercase, lines))
# 如果你想将每行的所有单词都转换为大写，可以使用列表推导式
upper_words_all = [word.upper() for line in lines for word in line.split()]
print(upper_words)
print(upper_words_all)
# ['121314536273838390\n', '123A\n', '456B\n', '789C\n', '587\n', '1024']
# ['121314536273838390', '123A', '456B', '789C', '587', '1024']

# 示例3：读取文件中的每行，并使用map()处理每个单词
# 定义一个函数，返回字符串的长度
def get_length(s):
    return len(s)
# 打开文件并读取所有行
with open('file.txt', 'r') as file:
    lines = file.readlines()
# 使用map()和自定义函数计算每行中每个单词的长度
# 这里我们使用了嵌套的map()和split()，以及列表推导式来展开结果
word_lengths = [list(map(get_length, line.split())) for line in lines]
# 打印每个单词的长度列表
for lengths in word_lengths:
    print(lengths)
# [18]
# [4]
# [4]
# [4]
# [3]
# [4]

# 应用七：结合可迭代对象使用
# 示例1：对三个列表中的元素进行运算
# 定义三个数字列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]
# 使用zip()将三个列表的元素配对，然后使用map()和自定义函数进行计算
def calculate(a, b, c):
    return a + b * c
results = map(calculate, list1, list2, list3)
# 将迭代器转换为列表以查看结果
result_list = list(results)
print(result_list)
# [29, 42, 57]

# 示例2：使用多个可迭代对象进行格式化字符串
# 定义多个列表
names = ['Myelsa', 'Jimmy', 'Bruce']
ages = [48, 35, 60]
occupations = ['Engineer', 'Doctor', 'Teacher']
# 使用zip()将这些列表的元素配对，然后使用map()和格式化字符串来创建描述
descriptions = map(lambda name, age, occupation: f'{name} is a {age} year old {occupation}.', names, ages, occupations)
# 将迭代器转换为列表以查看结果
description_list = list(descriptions)
print(description_list)
# ['Myelsa is a 48 year old Engineer.', 'Jimmy is a 35 year old Doctor.', 'Bruce is a 60 year old Teacher.']

# 应用八：数学运算
# 示例1：对列表中的每个元素应用自定义数学函数
# 定义一个自定义数学函数，计算一个数的立方根
def cube_root(x):
    return x ** (1 / 3)
# 定义一个数字列表
numbers = [8, 27, 64, 125, 216]
# 使用map()和自定义函数计算每个元素的立方根
cube_roots = map(cube_root, numbers)
# 将迭代器转换为列表以查看结果
cube_roots_list = list(cube_roots)
print(cube_roots_list)
# [2.0, 3.0, 3.9999999999999996, 5.0, 5.999999999999999]

# 示例4：使用map()对列表中的元素进行求和与求平均值
# 定义一个数字列表
numbers = [1, 2, 3, 4, 5]
# 使用map()和sum()计算列表元素的和
sum_of_numbers = sum(numbers)
# 使用len()和sum()计算列表元素的平均值(这里不使用map()，因为map()不适合这种聚合操作)
average_of_numbers = sum_of_numbers / len(numbers)
print(sum_of_numbers)
print(average_of_numbers)
# 15
# 3.0