Как сделать несколько аргументов для отображения функции, где один остается неизменным в Python?

Допустим, у нас есть функция add следующим образом

def add(x, y):
    return x + y

мы хотим применить функцию карты для массива

map(add, [1, 2, 3], 2)

Семантика я хочу добавить 2 к каждому элементу массива. Но mapфункция также требует списка в третьем аргументе.

Примечание: я добавляю пример добавления для простоты. Моя оригинальная функция намного сложнее. И, конечно, возможность установки значения по умолчанию для yфункции add не подлежит сомнению, так как она будет изменяться при каждом вызове.

Одним из вариантов является понимание списка:

[add(x, 2) for x in [1, 2, 3]]

Больше вариантов:

a = [1, 2, 3]

import functools
map(functools.partial(add, y=2), a)

import itertools
map(add, a, itertools.repeat(2, len(a)))

Документы явно предполагают, что это основное использование для itertools.repeat:

Сделайте итератор, который возвращает объект снова и снова. Работает бесконечно, если не указан аргумент times. Используется в качестве аргумента map()для инвариантных параметров вызываемой функции. Также используется zip()для создания инвариантной части записи кортежа.

И нет никаких оснований для передачи len([1,2,3])в качестве timesаргумента; mapостанавливается, как только первая итерация используется, поэтому бесконечная итерация вполне подходит:

>>> from operator import add
>>> from itertools import repeat
>>> list(map(add, [1,2,3], repeat(4)))
[5, 6, 7]

Фактически, это эквивалентно примеру для repeatв документах:

>>> list(map(pow, range(10), repeat(2)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Это создает хорошее решение для lazy-functions-language-y, которое также отлично читается в терминах Python-итераторов.

Используйте понимание списка.

[x + 2 for x in [1, 2, 3]]

Если вы действительно , действительно , действительно хотите использовать map, дайте ему анонимную функцию в качестве первого аргумента:

map(lambda x: x + 2, [1,2,3])

Карта может содержать несколько аргументов, стандартным способом является

map(add, a, b)

По вашему вопросу это должно быть

map(add, a, [2]*len(a))

Правильный ответ проще, чем вы думаете. Просто сделайте:

map(add, [(x, 2) for x in [1,2,3]])

И изменить реализацию добавить, чтобы взять кортеж, т.е.

def add(t):
   x, y = t
   return x+y

Это может обработать любой сложный случай использования, когда оба параметра добавления являются динамическими.

Иногда я разрешал подобные ситуации (например, используя метод pandas.apply ), используя замыкания

Чтобы использовать их, вы определяете функцию, которая динамически определяет и возвращает обертку для вашей функции, эффективно превращая один из параметров в константу.

Что-то вроде этого:

def add(x, y):
   return x + y

def add_constant(y):
    def f(x):
        return add(x, y)
    return f

Затем add_constant(y)возвращает функцию, которую можно использовать для добавления yк любому заданному значению:

>>> add_constant(2)(3)
5

Что позволяет использовать его в любой ситуации, когда параметры задаются по одному:

>>> map(add_constant(2), [1,2,3])
[3, 4, 5]

редактировать

Если вы не хотите писать функцию замыкания где-то еще, у вас всегда есть возможность построить ее на лету с помощью лямбда-функции:

>>> map(lambda x: add(x, 2), [1, 2, 3])
[3, 4, 5]

Если у вас есть в наличии, я бы рассмотрел использование NumPy. Это очень быстро для этих типов операций:

>>> import numpy
>>> numpy.array([1,2,3]) + 2
array([3, 4, 5])

Это предполагает, что ваше реальное приложение выполняет математические операции (которые могут быть векторизованы).

Если вам действительно нужно использовать функцию карты (например, мое присвоение класса здесь ...), вы можете использовать функцию-оболочку с 1 аргументом, передавая остальную часть исходной в своем теле; т.е.

extraArguments = value
def myFunc(arg):
    # call the target function
    return Func(arg, extraArguments)


map(myFunc, itterable)

Грязный и уродливый, все еще делает трюк

Я считаю, что вам нужен starmap:

from itertools import starmap


def test(x, y, z):
    return x + y + z

list(starmap(test, [(1, 2, 3), (4, 5, 6)]))

Чтобы передать несколько аргументов в mapфункцию.

def q(x,y):
    return x*y

print map (q,range(0,10),range(10,20))

Здесь q - это функция с несколькими аргументами, которую вызывает map () . Убедитесь, что длина обоих диапазонов, т.е.

len (range(a,a')) and len (range(b,b')) are equal.

В :nums = [1, 2, 3]

В :map(add, nums, [2]*len(nums))

Вне:[3, 4, 5]

Вы можете включить лямбду вместе с картой:

list(map(lambda a: a+2, [1, 2, 3]))

def func(a, b, c, d):
 return a + b * c % d

map(lambda x: func(*x), [[1,2,3,4], [5,6,7,8]])

Оборачивая вызов функции лямбда-выражением и распаковывая звездочку, вы можете создать карту с произвольным числом аргументов.

Другой вариант:

results = []
for x in [1,2,3]:
    z = add(x,2)
    ...
    results += [f(z,x,y)]

Этот формат очень полезен при вызове нескольких функций.