Использование карты Python и других функциональных инструментов

Вот решение, которое Вы ищете:

>>> foos = [1.0, 2.0, 3.0, 4.0, 5.0]
>>> bars = [1, 2, 3]
>>> [(x, bars) for x in foos]
[(1.0, [1, 2, 3]), (2.0, [1, 2, 3]), (3.0, [1, 2, 3]), (4.0, [1, 2, 3]), (5.0, [
1, 2, 3])]

я рекомендовал бы использовать понимание списка ([(x, bars) for x in foos] часть) по использованию карты, поскольку это избегает издержек вызова функции на каждом повторении (который может быть очень значительным). Если Вы просто соберетесь использовать его в для цикла, то Вы получите лучшие скорости при помощи понимания генератора:

>>> y = ((x, bars) for x in foos)
>>> for z in y:
...     print z
...
(1.0, [1, 2, 3])
(2.0, [1, 2, 3])
(3.0, [1, 2, 3])
(4.0, [1, 2, 3])
(5.0, [1, 2, 3])

различие - то, что понимание генератора , лениво загрузился .

ОБНОВЛЕНИЕ В ответ на этот комментарий:

, Конечно, Вы знаете, что Вы не копируете панели, все записи являются тем же списком панелей. Таким образом, при изменении кого-либо из них (включая исходные панели), Вы изменяете всех их.

я предполагаю, что это - актуальный вопрос. Существует два решения этого, что я могу думать. Самое эффективное является, вероятно, чем-то вроде этого:

tbars = tuple(bars)
[(x, tbars) for x in foos]

, Так как кортежи неизменны, это будет препятствовать тому, чтобы панели были изменены через результаты этого понимания списка (или понимание генератора, если Вы пойдете тем путем). Если действительно необходимо изменить каждый из результатов, можно сделать это:

from copy import copy
[(x, copy(bars)) for x in foos]

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

Функциональное программирование о создании кода без побочных эффектов.

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

Вы пытаетесь использовать его в качестве итератора. Не делайте этого.:)

Вот пример того, как Вы могли бы использовать карту для создания списка, который Вы хотите. Существуют более короткие решения (я просто использовал бы понимания), но это поможет Вам понять то, что карта делает немного лучше:

def my_transform_function(input):
    return [input, [1, 2, 3]]

new_list = map(my_transform, input_list)

Уведомление в этой точке, Вы только сделали манипулирование данными. Теперь можно распечатать его:

for n,l in new_list:
    print n, ll

- я не уверен, под чем Вы подразумеваете 'без циклов'. fp не о предотвращении циклов (Вы не можете исследовать каждый объект в списке, не посещая каждого). Это о предотвращении побочных эффектов, таким образом пишущий меньше ошибок.

Действительно ли Вы знакомы с другими функциональными языками? т.е. Вы пытаетесь изучить, как Python делает функциональное программирование, или Вы пытаетесь узнать о функциональном программировании и используете Python в качестве механизма?

кроме того, Вы понимаете понимания списка?

map(f, sequence)

непосредственно эквивалентен (*) к:

[f(x) for x in sequence]

На самом деле, я думаю map(), был когда-то намечен для удаления из python 3.0, как являющегося избыточным (которого не произошло).

map(f, sequence1, sequence2)

главным образом эквивалентно:

[f(x1, x2) for x1, x2 in zip(sequence1, sequence2)]

(существует различие в том, как оно обрабатывает случай, где последовательности имеют другую длину. Как Вы видели, map() не заполняет Ни один, когда одна из последовательностей заканчивается, тогда как zip() остановки, когда самая короткая последовательность останавливается)

Так, для обращения к конкретному вопросу Вы пытаетесь привести к результату:

foos[0], bars
foos[1], bars
foos[2], bars
# etc.

Вы могли сделать это путем записи функции, которая берет отдельный аргумент и печатает его, сопровождаемый панелями:

def maptest(x):
     print x, bars
map(maptest, foos)

, С другой стороны, Вы могли создать список, который похож на это:

[bars, bars, bars, ] # etc.

и использование Ваш исходный maptest:

def maptest(x, y):
    print x, y

Один способ сделать, которым это было бы к explicitely, создает список заранее:

barses = [bars] * len(foos)
map(maptest, foos, barses)

, С другой стороны, Вы могли вытянуть в itertools модуль. itertools содержит много умных функций, которые помогают Вам сделать программирование отложенных вычислений функционального стиля в Python. В этом случае мы хотим itertools.repeat, который произведет его аргумент неограниченно долго, поскольку Вы выполняете итерации по нему. Этот последний факт означает это, если Вы делаете:

map(maptest, foos, itertools.repeat(bars))

Вы получите бесконечный вывод, так как map() продолжает идти, целый один из аргументов все еще производит вывод. Однако itertools.imap точно так же, как map(), но останавливается как только самые короткие повторяемые остановки.

itertools.imap(maptest, foos, itertools.repeat(bars))

Hope это помогает:-)

(*), Это немного отличается в python 3.0. Там, карта () по существу возвращает выражение генератора.

>>> from itertools import repeat
>>> for foo, bars in zip(foos, repeat(bars)):
...     print foo, bars
... 
1.0 [1, 2, 3]
2.0 [1, 2, 3]
3.0 [1, 2, 3]
4.0 [1, 2, 3]
5.0 [1, 2, 3]

import itertools

foos=[1.0, 2.0, 3.0, 4.0, 5.0]
bars=[1, 2, 3]

print zip(foos, itertools.cycle([bars]))

Вот обзор параметров к эти map(function, *sequences) функция:

• function название Вашей функции.
• sequences любое количество последовательностей, которые обычно являются списками или кортежами. map выполнит итерации по ним одновременно и даст текущие значения function. Вот почему количество последовательностей должно равняться количеству параметров к Вашей функции.

Это кажется, что Вы пытаетесь выполнить итерации для некоторых из function, параметры, но сохранять других постоянными, и к сожалению map не поддерживают это. Я нашел старое предложение добавить такую опцию к Python, но конструкция карты является столь чистой и известной, что я сомневаюсь, что что-то как этот будет когда-либо реализовываться.

Использование обходное решение как глобальные переменные или понимания списка, как другие предположили.

Это сделало бы это?

foos = [1.0,2.0,3.0,4.0,5.0]
bars = [1,2,3]

def maptest2(bar):
  print bar

def maptest(foo):
  print foo
  map(maptest2, bars)

map(maptest, foos)