파이썬 맵 및 기타 기능성 도구 사용

파이썬 맵 및 기타 기능성 도구 사용

이것은 꽤 n00bish이지만, 저는 파이썬의 기능적 프로그래밍을 배우고 이해하려고 노력하고 있습니다.다음 코드:

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

def maptest(foo, bar):
    print foo, bar

map(maptest, foos, bars)

생성물:

1.0 1
2.0 2
3.0 3
4.0 None
5.0 None

Q. python에서 지도나 다른 기능적 도구를 사용하여 루프 등 없이 다음을 생성할 수 있는 방법이 있습니까?

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]

참고로 foo와 bar 사이에 의존성이 존재하는 경우 구현이 어떻게 변경될 것인지에 대해 설명합니다.

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

및 인쇄:

1.0 [2,3,4,5]
2.0 [1,3,4,5]
3.0 [1,2,4,5]
...

추신: if, loop 및/또는 발전기를 사용하여 순진하게 수행하는 방법을 알고 있지만, 기능적 도구를 사용하여 동일한 작업을 수행하는 방법을 배우고 싶습니다.맵 테스트에 if 문을 추가하거나 맵 테스트 내의 막대에 내부적으로 다른 필터 맵을 적용하는 경우뿐입니까?

다른 기능 언어에 익숙하십니까? 즉, 파이썬이 어떻게 기능적 프로그래밍을 하는지 배우려는 것입니까? 아니면 기능적 프로그래밍과 파이썬을 매개체로 사용하는 것에 대해 배우려는 것입니까?

또한, 당신은 목록 이해력이 있습니까?

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.

원본 지도 테스트를 사용합니다.

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

이를 위한 한 가지 방법은 사전에 목록을 명시적으로 작성하는 것입니다.

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

(*) 파이썬 3.0에서는 조금 다릅니다.여기서 map()은 기본적으로 생성자 식을 반환합니다.

가장 쉬운 방법은 통과하지 않는 것입니다.bars다른 기능을 통해, 그러나 그것에 직접 접근하는 것.maptest:

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

def maptest(foo):
    print foo, bars

map(maptest, foos)

원본과 함께maptest함수 람다 함수를 사용할 수도 있습니다.map:

map((lambda foo: maptest(foo, bars)), foos)

당신이 찾고 있는 솔루션은 다음과 같습니다.

>>> 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]부분) 맵을 사용하여 모든 반복에서 함수 호출의 오버헤드를 방지합니다(매우 중요할 수 있음).for 루프에서 사용하려는 경우 제너레이터 이해를 사용하여 속도를 향상시킬 수 있습니다.

>>> 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는 루프를 피하는 것이 아닙니다(각각의 항목을 방문하지 않고 목록의 모든 항목을 검사할 수 없습니다).부작용을 피하고 버그를 적게 작성하는 것입니다.

>>> 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이지만 다른 변수는 일정하게 안타깝게도 매개변다매른개변의수일유다니게합지정하를만지수이▁'다니▁and,▁constanteters유합▁others▁unfortun지s▁but의ately게▁param. 그리고 불행하게도.map그것을 지원하지 않습니다.저는 파이썬에 그러한 기능을 추가하자는 오래된 제안을 찾았지만, 지도 구성이 너무 깨끗하고 잘 확립되어 있어서 그런 것이 구현될 수 있을지 의심스럽습니다.

다른 사람들이 제안한 것처럼 글로벌 변수나 목록 이해와 같은 해결 방법을 사용합니다.

이렇게 하면 되나요?

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)

이거 어때:

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

def maptest(foo, bar):
    print foo, bar

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

언급URL : https://stackoverflow.com/questions/672172/using-python-map-and-other-functional-tools