Bagaimana cara melakukan beberapa argumen untuk memetakan fungsi di mana satu tetap sama dengan python?

Katakanlah kita memiliki fungsi add sebagai berikut

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

kami ingin menerapkan fungsi peta untuk sebuah array

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

Semantiknya adalah saya ingin menambahkan 2 ke setiap elemen array. Tetapi mapfungsinya membutuhkan daftar pada argumen ketiga juga.

Catatan: Saya menempatkan contoh tambahkan untuk kesederhanaan. Fungsi asli saya jauh lebih rumit. Dan tentu saja opsi pengaturan nilai default ydalam fungsi add tidak dipertanyakan karena akan diubah untuk setiap panggilan.

Salah satu opsi adalah pemahaman daftar:

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

Lebih banyak pilihan:

a = [1, 2, 3]

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

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

Dokumen secara eksplisit menyarankan ini adalah penggunaan utama untuk itertools.repeat:

Buat iterator yang mengembalikan objek berulang-ulang. Berjalan tanpa batas waktu kecuali argumen kali ditentukan. Digunakan sebagai argumen map()untuk parameter invarian untuk fungsi yang dipanggil. Juga digunakan dengan zip()untuk membuat bagian invarian dari catatan tuple.

Dan tidak ada alasan untuk lulus len([1,2,3])sebagai timesargumen; mapberhenti segera setelah iterable pertama dikonsumsi, sehingga iterable tak terbatas baik-baik saja:

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

Bahkan, ini setara dengan contoh repeatdalam dokumen:

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

Ini membuat solusi malas-fungsional-bahasa-y yang bagus yang juga dapat dibaca dengan sempurna dalam istilah Python-iterator.

Gunakan pemahaman daftar.

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

Jika Anda benar-benar , benar-benar , benar-benar ingin menggunakan map, memberikan fungsi anonim sebagai argumen pertama:

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

Peta dapat berisi banyak argumen, cara standarnya adalah

map(add, a, b)

Dalam pertanyaan Anda, seharusnya

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

Jawaban yang benar lebih sederhana dari yang Anda pikirkan. Cukup lakukan:

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

Dan mengubah implementasi add untuk mengambil tuple yaitu

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

Ini dapat menangani setiap kasus penggunaan yang rumit di mana kedua parameter add bersifat dinamis.

Kadang-kadang saya menyelesaikan situasi serupa (seperti menggunakan metode pandas. Apply ) menggunakan penutupan

Untuk menggunakannya, Anda mendefinisikan fungsi yang secara dinamis mendefinisikan dan mengembalikan pembungkus untuk fungsi Anda, secara efektif membuat salah satu parameter menjadi konstan.

Sesuatu seperti ini:

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

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

Lalu, add_constant(y)kembalikan fungsi yang bisa digunakan untuk menambah ynilai apa pun yang diberikan:

>>> add_constant(2)(3)
5

Yang memungkinkan Anda untuk menggunakannya dalam situasi apa pun di mana parameter diberikan satu per satu:

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

sunting

Jika Anda tidak ingin harus menulis fungsi penutupan di tempat lain, Anda selalu memiliki kemungkinan untuk membuatnya dengan menggunakan fungsi lambda:

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

Jika Anda memilikinya tersedia, saya akan mempertimbangkan menggunakan numpy. Ini sangat cepat untuk jenis operasi ini:

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

Ini dengan asumsi aplikasi nyata Anda melakukan operasi matematika (yang dapat di-vektor).

Jika Anda benar-benar perlu menggunakan fungsi peta (seperti tugas kelas saya di sini ...), Anda dapat menggunakan fungsi wrapper dengan 1 argumen, meneruskan sisanya ke yang asli di tubuhnya; yaitu:

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


map(myFunc, itterable)

Kotor & jelek, masih melakukan trik

Saya percaya starmap adalah yang Anda butuhkan:

from itertools import starmap


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

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

Untuk meneruskan beberapa argumen ke suatu mapfungsi.

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

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

Di sini q adalah fungsi dengan beberapa argumen yang memetakan () panggilan. Pastikan, panjang kedua rentang yaitu

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

Di :nums = [1, 2, 3]

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

Di luar:[3, 4, 5]

Anda dapat memasukkan lambda bersama dengan peta:

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

Dengan membungkus panggilan fungsi dengan lambda dan menggunakan membongkar bintang, Anda dapat melakukan peta dengan sejumlah argumen sewenang-wenang.

Pilihan lain adalah:

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

Format ini sangat berguna saat memanggil beberapa fungsi.