Làm thế nào để thực hiện nhiều đối số cho hàm ánh xạ trong đó một đối số vẫn giữ nguyên trong python?

Hãy nói rằng chúng ta có một chức năng thêm như sau

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

chúng tôi muốn áp dụng chức năng bản đồ cho một mảng

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

Các ngữ nghĩa là tôi muốn thêm 2 vào mọi phần tử của mảng. Nhưng maphàm cũng yêu cầu một danh sách trong đối số thứ ba.

Lưu ý: Tôi đang đặt ví dụ thêm cho đơn giản. Chức năng ban đầu của tôi phức tạp hơn nhiều. Và tất nhiên tùy chọn thiết lập giá trị mặc định của yhàm add là không cần thiết vì nó sẽ được thay đổi cho mỗi cuộc gọi.

Một lựa chọn là một sự hiểu biết danh sách:

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

Lựa chọn khác:

a = [1, 2, 3]

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

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

Các tài liệu đề nghị rõ ràng đây là cách sử dụng chính cho itertools.repeat:

Tạo một trình vòng lặp trả lại đối tượng nhiều lần. Chạy vô thời hạn trừ khi đối số lần được chỉ định. Được sử dụng làm đối số map()cho các tham số bất biến cho hàm được gọi. Cũng được sử dụng zip()để tạo một phần bất biến của bản ghi tuple.

Và không có lý do để vượt qua len([1,2,3])như là timesđối số; mapdừng ngay khi lần lặp đầu tiên được tiêu thụ, do đó, lần lặp vô hạn là hoàn toàn tốt:

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

Trong thực tế, điều này tương đương với ví dụ cho repeattrong các tài liệu:

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

Điều này làm cho một giải pháp ngôn ngữ-chức năng-ngôn ngữ lười biếng tốt đẹp cũng hoàn toàn có thể đọc được bằng thuật ngữ Python-iterator.

Sử dụng một danh sách hiểu.

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

Nếu bạn thực sự , thực sự , thực sự muốn sử dụng map, hãy cung cấp cho nó một hàm ẩn danh làm đối số đầu tiên:

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

Bản đồ có thể chứa nhiều đối số, cách tiêu chuẩn là

map(add, a, b)

Trong câu hỏi của bạn, nó nên được

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

Câu trả lời đúng đơn giản hơn bạn nghĩ. Đơn giản chỉ cần làm:

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

Và thay đổi việc thực hiện add để mất một tuple tức là

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

Điều này có thể xử lý bất kỳ trường hợp sử dụng phức tạp nào trong đó cả hai tham số đều là động.

Đôi khi tôi đã giải quyết các tình huống tương tự (chẳng hạn như sử dụng phương thức pandas.apply ) bằng cách sử dụng các bao đóng

Để sử dụng chúng, bạn xác định một hàm tự động xác định và trả về một trình bao bọc cho hàm của bạn, làm cho một trong các tham số trở thành một hằng số một cách hiệu quả.

Một cái gì đó như thế này:

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

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

Sau đó, add_constant(y)trả về một hàm có thể được sử dụng để thêm yvào bất kỳ giá trị nào:

>>> add_constant(2)(3)
5

Điều này cho phép bạn sử dụng nó trong mọi tình huống trong đó các tham số được đưa ra cùng một lúc:

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

biên tập

Nếu bạn không muốn phải viết hàm đóng ở một nơi khác, bạn luôn có khả năng xây dựng nó một cách nhanh chóng bằng cách sử dụng hàm lambda:

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

Nếu bạn có sẵn nó, tôi sẽ xem xét sử dụng numpy. Nó rất nhanh cho các loại hoạt động này:

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

Điều này là giả sử ứng dụng thực sự của bạn đang thực hiện các hoạt động toán học (có thể được vector hóa).

Nếu bạn thực sự cần sử dụng chức năng bản đồ (như bài tập lớp của tôi ở đây ...), bạn có thể sử dụng hàm bao bọc với 1 đối số, chuyển phần còn lại cho phần gốc trong phần thân của nó; I E :

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


map(myFunc, itterable)

Dơ bẩn & xấu xí, vẫn làm trò bịp

Tôi tin rằng starmap là những gì bạn cần:

from itertools import starmap


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

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

Để truyền nhiều đối số cho một maphàm.

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

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

Ở đây q là hàm có nhiều đối số mà map () gọi. Hãy chắc chắn rằng, độ dài của cả hai phạm vi tức là

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

Trong :nums = [1, 2, 3]

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

Ngoài:[3, 4, 5]

Bạn có thể bao gồm lambda cùng với bản đồ:

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

Bằng cách gói hàm gọi bằng lambda và sử dụng giải nén sao, bạn có thể thực hiện bản đồ với số lượng đối số tùy ý.

Một lựa chọn khác là:

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

Định dạng này rất hữu ích khi gọi nhiều chức năng.