如何使用Python Map功能

旧城等待， 2022-11-28 15:22 189阅读 0赞

### 介绍 **(**Introduction**)** ###

We can use the Python built-in function `map()` to apply a function to each item in an iterable (like a [list][] or [dictionary][]) and return a new iterator for retrieving the results. `map()` returns a map object (an iterator), which we can use in other parts of our program. We can also pass the map object to the `list()` function, or another sequence type, to create an iterable.

我们可以使用Python内置函数`map()`将函数应用于可迭代项(例如[list][]或[dictionary][] )中的每个项目，并返回一个新的迭代器以检索结果。 `map()`返回一个地图对象(一个迭代器)，我们可以在程序的其他部分中使用它。 我们还可以将map对象传递给`list()`函数或其他序列类型，以创建一个可迭代的对象。

The syntax for the `map()` function is as follows:

`map()`函数的语法如下：

map(function, iterable, [iterable 2, iterable 3, ...])

Instead of using a [`for` loop][for_ loop], the `map()` function provides a way of applying a function to every item in an iterable. Therefore it can often be more performant since it is only applying the function one item at a time rather than making copies of the items into another iterable. This is particularly useful when working on programs processing large data sets. `map()` can also take multiple iterables as arguments to the function by sending one item from each iterable to the function at a time.

`map()`函数提供了一种将函数应用于可迭代对象中的每个项目的方法，而不是使用[`for`循环][for_ loop] 。 因此，由于每次仅将一项功能应用于一项功能，而不是将各项的副本复制到另一项中，因此通常可以提高性能。 在处理处理大数据集的程序时，这特别有用。 通过一次从每个可迭代对象向函数发送一项， `map()`还可以将多个可迭代对象作为函数的参数。

In this tutorial, we’ll review three different ways of working with `map()`: with a `lambda` function, with a user-defined function, and finally with a built-in function using multiple iterable arguments.

在本教程中，我们将介绍`map()`三种不同使用方式：使用`lambda`函数，使用用户定义的函数以及使用多个可迭代参数的内置函数。

## 使用Lambda函数 **(**Using a Lambda Function**)** ##

The first argument to `map()` is a function, which we use to apply to each item. Python calls the function once for every item in the iterable we pass into `map()` and it returns the manipulated item within a map object. For the first function argument, we can either pass a user-defined function or we can make use of `lambda` functions, particularly when the expression is less complex.

`map()`的第一个参数是一个函数，我们将其应用于每个项目。 Python对传递给`map()`的可迭代项中的每一项调用一次函数，并返回map对象内的操作项。 对于第一个函数参数，我们可以传递用户定义的函数，也可以使用`lambda`函数，尤其是当表达式不太复杂时。

The syntax of `map()` with a lambda function is as follows:

带lambda函数的`map()`的语法如下：

map(lambda item: item[] expression, iterable)

With a list like the following, we can implement a `lambda` function with an expression that we want to apply to each item in our list:

使用下面的列表，我们可以使用要应用于列表中每个项目的表达式来实现`lambda`函数：

numbers = [10, 15, 21, 33, 42, 55]

To apply an expression against each of our numbers, we can use `map()` and `lambda`:

要对每个数字应用表达式，可以使用`map()`和`lambda` ：

mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))

Here we declare an item in our list as `x`. Then we add our expression. We pass in our list of numbers as the iterable for `map()`.

在这里，我们将列表中的一项声明为`x` 。 然后添加表达式。 我们传入数字列表作为`map()`的可迭代对象。

In order to receive the results of this immediately we print a list of the `map` object:

为了立即接收结果，我们打印了`map`对象的列表：

print(mapped_numbers)

Output [23, 33, 45, 69, 87, 113]

We have used `list()` so that the map object is returned to us as a list, rather than a less human-readable object like: `<map object at 0x7fc250003a58>`. The map object is an iterator over our results, so we could loop over it with `for` or we can use `list()` to turn it into a list. We’re doing this here because it’s a good way to review the results.

我们使用了`list()`以便将地图对象作为列表返回给我们，而不是像人类这样`<map object at 0x7fc250003a58>`对象： `<map object at 0x7fc250003a58>` 。 map对象是结果的迭代器，因此我们可以使用`for`对其进行循环，也可以使用`list()`将其转换为列表。 我们在这里这样做是因为它是查看结果的好方法。

Ultimately `map()` is most useful when working with large datasets, so we would likely work with the map object further, and generally would not be using a constructor like `list()` on them.

最终， `map()`在处理大型数据集时最有用，因此我们可能会进一步处理map对象，并且通常不会在其上使用类似`list()`的构造函数。

For smaller datasets, list comprehensions may be more suitable, but for the purposes of this tutorial we’re using a small dataset to demonstrate `map()`.

对于较小的数据集，列表推导可能更合适，但是出于本教程的目的，我们使用一个小的数据集来演示`map()` 。

## 实施用户定义的功能 **(**Implementing a User-defined Function**)** ##

Similarly to a `lambda` we can use a function we have defined to apply to an iterable. While `lambda` functions are more useful to implement when you’re working with a one-line expression, user-defined functions are more appropriate when the expression grows in complexity. Furthermore, when we need to pass another piece of data to the function that you’re applying to your iterable, user-defined functions can be a better choice for readability.

与`lambda`类似，我们可以使用已定义的函数将其应用于可迭代对象。 当您使用单行表达式时， `lambda`函数对于实现更有用，而当表达式的复杂性增加时，用户定义的函数将更为合适。 此外，当我们需要将另一条数据传递给要应用于可迭代的函数时，用户定义函数可能是可读性更好的选择。

For example, in the following iterable, each item is a dictionary that contains different details about each of our aquarium creatures:

例如，在下面的迭代中，每个项目都是一个字典，其中包含有关我们每个水族馆生物的不同详细信息：

aquarium_creatures = [
        {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
        {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
        {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
        {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
        {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
        {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
    ]

We’ve decided that all the aquarium creatures are in fact going to move into the same tank. We need to update our records to reflect that all of our creatures are moving into tank `42`. To have `map()` access each dictionary and each key:value pair in the dictionaries, we construct a nested function:

我们已经决定所有的水族馆生物实际上都将移入同一个水箱。 我们需要更新记录，以反映出我们所有的生物都正在移入坦克`42` 。 为了使`map()`访问字典中的每个字典和每个key：value对，我们构造了一个嵌套函数：

def assign_to_tank(aquarium_creatures, new_tank_number):
        def apply(x):
            x["tank number"] = new_tank_number
            return x
        return map(apply, aquarium_creatures)

We define an `assign_to_tank()` function that takes `aquarium_creatures` and `new_tank_number` as parameters. In `assign_to_tank()` we pass `apply()` as the function to `map()` on the final line. The `assign_to_tank` function will return the iterator resulting from `map()`.

我们定义一个`assign_to_tank()`函数，该函数将`aquarium_creatures`和`new_tank_number`作为参数。 在`assign_to_tank()`我们在最后一行将`apply()`作为函数传递给`map()` 。 `assign_to_tank`函数将返回`map()`生成的迭代器。

`apply()` takes `x` as an argument, which represents an item in our list — a single dictionary.

`apply()`将`x`作为参数，表示我们列表中的一个项目-一个字典。

Next we define that `x` is the `"tank number"` key from `aquarium_creatures` and that it should store the passed in `new_tank_number`. We return each item after applying the new tank number.

接下来，我们定义`x`为`aquarium_creatures`的`"tank number"`键，并将其存储在`new_tank_number` 。 应用新的油箱编号后，我们将退还每个物品。

We call `assign_to_tank()` with our list of dictionaries and the new tank number we want to replace for each creature:

我们用字典列表和我们要为每种生物替换的新坦克编号来调用`assign_to_tank()` ：

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Once the function completes we have our map object stored in the `assigned_tanks` variable, which we turn into a list and print:

函数完成后，我们将地图对象存储在`assigned_tanks`变量中，将其转换为列表并打印：

print(list(assigned_tanks))

We’ll receive the following output from this program:

我们将从该程序接收以下输出：

Output [{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

We’ve mapped the new tank number to our list of dictionaries. Using a function that we define, we can incorporate `map()` to apply the function efficiently on each item of the list.

我们已将新的坦克编号映射到我们的词典列表中。 使用我们定义的函数，我们可以合并`map()`以将该函数有效地应用于列表的每个项目。

## 将内置函数与多个可迭代对象一起使用 **(**Using a Built-in Function with Multiple Iterables**)** ##

In the same way as `lambda` functions or our own defined functions, we can use Python built-in functions with `map()`. To apply a function with multiple iterables, we pass in another iterable name following the first one. For example, using the [`pow()` function][pow_ function] that takes in two numbers to find the power of the base number to the provided exponent.

与`lambda`函数或我们自己定义的函数相同，我们可以将Python内置函数与`map()` 。 要应用具有多个可迭代函数的函数，我们在第一个可迭代名字后传入另一个可迭代名字。 例如，使用带两个数字的[`pow()`函数][pow_ function]来查找基数对所提供指数的幂。

Here we have our lists of integers that we would like to use with `pow()`:

这是我们想要与`pow()`一起使用的整数列表：

base_numbers = [2, 4, 6, 8, 10]
    powers = [1, 2, 3, 4, 5]

Next we pass in `pow()` as our function into `map()` and provide the two lists as our iterables:

接下来，我们将`pow()`作为函数传递给`map()`并提供两个列表作为可迭代对象：

numbers_powers = list(map(pow, base_numbers, powers))
    
    print(numbers_powers)

`map()` will apply the `pow()` function to the same item in each list to provide the power. Therefore our results will show `2**1`, `4**2`, `6**3`, and so on:

`map()`会将`pow()`函数应用于每个列表中的相同项以提供功能。 因此，我们的结果将显示`2**1` `4**2` `6**3` ，依此类推：

Output [2, 16, 216, 4096, 100000]

If we were to provide `map()` with an iterable that was longer than the other, `map()` would stop calculating once it reaches the end of the shortest iterable. In the following program we’re extending `base_numbers` with three additional numbers:

如果我们要给`map()`提供一个比另一个更长的可迭代对象，则`map()`到达最短可迭代对象的末尾将停止计算。 在下面的程序中，我们用另外三个数字扩展`base_numbers` ：

base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
    powers = [1, 2, 3, 4, 5]
    
    numbers_powers = list(map(pow, base_numbers, powers))
    
    print(numbers_powers)

As a result, nothing will change within the calculation of this program and so it will still yield the same result:

结果，此程序的计算不会发生任何变化，因此仍会产生相同的结果：

Output [2, 16, 216, 4096, 100000]

We’ve used the `map()` function with a Python built-in function and have seen that it can handle multiple iterables. We’ve also reviewed that `map()` will continue to process multiple iterables until it has reached the end of the iterable with the fewest items.

我们已经将`map()`函数与Python内置函数一起使用，并且看到它可以处理多个可迭代对象。 我们还回顾了`map()`将继续处理多个可迭代对象，直到它以最少的项到达可迭代对象的末尾。

## 结论 **(**Conclusion**)** ##

In this tutorial, we’ve learned the different ways of using the `map()` function in Python. Now you can use `map()` with your own function, a `lambda` function, and with any other built-in functions. You can also implement `map()` with functions that require multiple iterables.

在本教程中，我们学习了在Python中使用`map()`函数的不同方法。 现在，您可以将`map()`与您自己的函数， `lambda`函数以及任何其他内置函数一起使用。 您还可以使用需要多个可迭代对象的函数来实现`map()` 。

In this tutorial, we printed the results from `map()` immediately to a list format for demonstration purposes. In our programs we would typically use the returned map object to further manipulate the data.

在本教程中，我们将`map()`的结果立即打印为列表格式，以进行演示。 在我们的程序中，我们通常将使用返回的map对象进一步处理数据。

If you would like to learn more Python, check out our [How To Code in Python 3][] series and our [Python topic page][]. To learn more about working with data sets in functional programming, check out our [article on the `filter()` function][article on the _filter_ function].

如果您想了解更多Python，请查看我们的“ [如何使用Python 3编码”][How To Code in Python 3]系列和[Python主题页面][Python topic page] 。 要了解有关在函数式编程中使用数据集的更多信息，请查看[关于`filter()`函数的文章][article on the _filter_ function] 。

> 翻译自: [https://www.digitalocean.com/community/tutorials/how-to-use-the-python-map-function][https_www.digitalocean.com_community_tutorials_how-to-use-the-python-map-function]

[list]: https://www.digitalocean.com/community/tutorials/understanding-lists-in-python-3
[dictionary]: https://www.digitalocean.com/community/tutorials/understanding-dictionaries-in-python-3
[for_ loop]: https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-in-python-3
[pow_ function]: https://www.digitalocean.com/community/tutorials/built-in-python-3-functions-for-working-with-numbers#power
[How To Code in Python 3]: https://www.digitalocean.com/community/tutorial_series/how-to-code-in-python-3
[Python topic page]: https://www.digitalocean.com/community/tags/python
[article on the _filter_ function]: https://www.digitalocean.com/community/tutorials/how-to-use-the-python-filter-function
[https_www.digitalocean.com_community_tutorials_how-to-use-the-python-map-function]: https://www.digitalocean.com/community/tutorials/how-to-use-the-python-map-function