Як зробити декілька аргументів для відображення функції, коли один залишається таким же у python?

Скажімо, у нас є функція додавання наступним чином

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

ми хочемо застосувати функцію map для масиву

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:

Зробіть ітератор, який повертає об’єкт знову і знову. Працює безстроково, якщо не вказано аргумент часу. Використовується як аргумент 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]

Це створює чудове ліниво-функціональне мовне рішення, яке також ідеально читається в термінах Python-iterator.

Використовуйте розуміння списку.

[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]])

І змінити реалізацію add, щоб взяти кортеж, тобто

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)

Брудно і потворно, все одно робить трюк

Я вважаю, що вам потрібно:

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)]

Цей формат дуже корисний при виклику декількох функцій.