지도 기능 이해

map(function, iterable, ...)

반복 가능한 모든 항목에 함수를 적용하고 결과 목록을 리턴하십시오. 반복 가능한 추가 인수가 전달되면 함수는 많은 인수를 가져와 모든 반복 가능한 항목의 항목에 병렬로 적용됩니다.

하나의 iterable이 다른 iterable보다 짧으면 None 항목으로 확장 된 것으로 가정합니다.

function이 None인 경우 항등 함수가 가정됩니다. 인수가 여러 개인 경우 map()모든 반복 가능 항목에서 해당 항목을 포함하는 튜플로 구성된 목록을 반환합니다 (일치 전치 연산).

반복 가능한 인수는 시퀀스 또는 반복 가능한 객체 일 수 있습니다. 결과는 항상 목록입니다.

이것이 직교 곱을 만드는 데 어떤 역할을합니까?

content = map(tuple, array)

튜플을 어디에나 배치하면 어떤 효과가 있습니까? 또한 map 함수가 없으면 출력이 abc이고 출력이임을 알았 습니다 a, b, c.

이 기능을 완전히 이해하고 싶습니다. 참조 정의도 이해하기 어렵습니다. 너무 많은 멋진 보풀.

map특히 pythonic이 아닙니다. 대신 목록 이해를 사용하는 것이 좋습니다.

map(f, iterable)

기본적으로 다음과 같습니다.

[f(x) for x in iterable]

map출력리스트의 길이는 항상 입력리스트와 동일하기 때문에 자체적으로 카티 전 곱을 수행 할 수 없습니다. 다음과 같은 목록 이해 기능을 갖춘 데카르트 제품을 간단하게 수행 할 수 있습니다.

[(a, b) for a in iterable_a for b in iterable_b]

문법은 약간 혼란 스럽습니다. 기본적으로 다음과 같습니다.

result = []
for a in iterable_a:
    for b in iterable_b:
        result.append((a, b))

map함수형 프로그래밍에 정통한 사람이를 사용하여 생성하는 방법을 이해하는 것이 불가능할 수 있다고 생각하지만, 직교 제품과 전혀 관련이 없습니다 map.

map 파이썬 3에서는 다음과 같습니다.

def map(func, iterable):
    for i in iterable:
        yield func(i)

파이썬 2의 유일한 차이점은 전체 결과 목록을 작성하여 yielding 대신 한 번에 모두 반환한다는 것입니다.

파이썬 규칙은 일반적으로 map람다 식을 첫 번째 인수로 사용하는 경우에 대한 호출과 동일한 결과를 달성하기 위해 목록 이해 (또는 생성자 식)를 선호하지만 :

[func(i) for i in iterable]

질문에 대한 의견에서 "문자열을 배열로 바꾸십시오"라는 질문의 예로 '배열'을 사용하면 아마도 튜플이나 목록을 원할 것입니다 (둘 다 다른 언어의 배열과 비슷하게 동작합니다) -

 >>> a = "hello, world"
 >>> list(a)
['h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd']
>>> tuple(a)
('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd')

단일 문자열 대신 문자열 목록 으로 map시작하는 경우 여기를 사용 하면 모든 문자열을 개별적으로 나열 할 수 있습니다.map

>>> a = ["foo", "bar", "baz"]
>>> list(map(list, a))
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

참고 map(list, a)파이썬 2에서 동일하지만 파이썬 3에서 당신이 필요 list당신이에 피드를 이외의 수행하려는 경우 전화를 for루프 (또는 같은 처리 기능 sum즉 만 반복 가능한, 그리고 일련의 필요를). 그러나 목록 이해가 일반적으로 선호된다는 것을 다시 언급하십시오.

>>> [list(b) for b in a]
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]

map 소스의 모든 요소에 함수를 적용하여 새 목록을 만듭니다.

xs = [1, 2, 3]

# all of those are equivalent — the output is [2, 4, 6]
# 1. map
ys = map(lambda x: x * 2, xs)
# 2. list comprehension
ys = [x * 2 for x in xs]
# 3. explicit loop
ys = []
for x in xs:
    ys.append(x * 2)

n-ary map는 입력 이터 러블을 함께 압축 한 다음 해당 중간 압축 목록의 모든 요소에 변환 함수를 적용하는 것과 같습니다. 직교 제품 이 아닙니다 .

xs = [1, 2, 3]
ys = [2, 4, 6]

def f(x, y):
    return (x * 2, y // 2)

# output: [(2, 1), (4, 2), (6, 3)]
# 1. map
zs = map(f, xs, ys)
# 2. list comp
zs = [f(x, y) for x, y in zip(xs, ys)]
# 3. explicit loop
zs = []
for x, y in zip(xs, ys):
    zs.append(f(x, y))

zip여기에서 사용 했지만 map이터 러블의 크기가 같지 않으면 동작이 실제로 약간 다릅니다. 문서에서 언급했듯이 이터 러블을 포함하도록 확장 가능합니다 None.

조금 단순화하면 map()다음과 같은 일 을 상상할 수 있습니다 .

def mymap(func, lst):
    result = []
    for e in lst:
        result.append(func(e))
    return result

보시다시피, 함수와 목록을 가져오고 입력 목록의 각 요소에 함수를 적용한 결과와 함께 새 목록을 반환합니다. 실제로 "비트 단순화"라고 말 했지만 실제로 map()는 여러 반복 가능한 것을 처리 할 수 ​​있습니다 .

반복 가능한 추가 인수가 전달되면 함수는 많은 인수를 가져와 모든 반복 가능한 항목의 항목에 병렬로 적용됩니다. 하나의 iterable이 다른 iterable보다 짧으면 None 항목으로 확장 된 것으로 가정합니다.

문제의 두 번째 부분 : 카티 전 곱을 만드는 데 이것이 어떤 역할을합니까? 또한, map() 수 같은 목록의 직교 제품을 생성하기 위해 사용할 수 :

lst = [1, 2, 3, 4, 5]

from operator import add
reduce(add, map(lambda i: map(lambda j: (i, j), lst), lst))

... 그러나 진실을 말하면, 사용 product()은 문제를 해결하는 훨씬 간단하고 자연스러운 방법입니다.

from itertools import product
list(product(lst, lst))

어느 쪽이든 결과는 lst위에서 정의한 데카르트 곱입니다 .

[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
 (2, 1), (2, 2), (2, 3), (2, 4), (2, 5),
 (3, 1), (3, 2), (3, 3), (3, 4), (3, 5),
 (4, 1), (4, 2), (4, 3), (4, 4), (4, 5),
 (5, 1), (5, 2), (5, 3), (5, 4), (5, 5)]

이 map()함수는 목록, 생성기, 문자열 및 기타 항목과 같은 반복 가능한 데이터 구조의 모든 항목에 동일한 절차를 적용합니다.

예를 보자 : map()새로운 목록을 반환 (돌아 가기)하는 것보다 목록의 모든 항목을 반복하고 각 항목에 함수를 적용 할 수 있습니다.

숫자를 취해 그 숫자에 1을 더한 함수를 반환한다고 가정 해 봅시다.

def add_one(num):
  new_num = num + 1
  return new_num

숫자 목록도 있습니다.

my_list = [1, 3, 6, 7, 8, 10]

목록의 모든 숫자를 늘리려면 다음을 수행하십시오.

>>> map(add_one, my_list)
[2, 4, 7, 8, 9, 11]

참고 : 최소한 map()두 개의 인수가 필요합니다. 먼저 함수 이름이고 두 번째는 목록과 같습니다.

다른 멋진 일들을 map()할 수 있습니다. map()여러 반복 가능 항목 (목록, 문자열 등)을 가져 와서 각 반복 가능 요소에서 인수로 함수에 요소를 전달할 수 있습니다.

우리는 세 가지 목록이 있습니다.

list_one = [1, 2, 3, 4, 5]
list_two = [11, 12, 13, 14, 15]
list_three = [21, 22, 23, 24, 25]

map() 특정 색인에 요소를 추가하는 새로운 목록을 만들 수 있습니다.

기억하십시오 map(), 기능이 필요합니다. 이번에는 내장 sum()함수를 사용하겠습니다 . 실행 map()하면 다음과 같은 결과가 나타납니다.

>>> map(sum, list_one, list_two, list_three)
[33, 36, 39, 42, 45]

기억하십시오 :
Python 2에서는 map()가장 긴 목록에 따라 목록의 요소를 반복 None하고 짧은 목록의 함수로 전달 하므로 함수가 찾아서 None처리해야합니다. 그렇지 않으면 오류가 발생합니다. Python 3에서는 map()가장 짧은 목록으로 완료 한 후 중지됩니다. 또한 Python 3에서는 map()목록이 아닌 반복자를 반환합니다.

Python3-맵 (펑크, 반복 가능)

@BlooB가 언급했지만 완전히 언급되지 않은 한 가지는 map 이 목록이 아닌 맵 객체를 반환한다는 것 입니다. 이는 초기화 및 반복시 시간 성능 측면에서 큰 차이입니다. 이 두 가지 테스트를 고려하십시오.

import time
def test1(iterable):
    a = time.clock()
    map(str, iterable)
    a = time.clock() - a

    b = time.clock()
    [ str(x) for x in iterable ]
    b = time.clock() - b

    print(a,b)


def test2(iterable):
    a = time.clock()
    [ x for x in map(str, iterable)]
    a = time.clock() - a

    b = time.clock()
    [ str(x) for x in iterable ]
    b = time.clock() - b

    print(a,b)


test1(range(2000000))  # Prints ~1.7e-5s   ~8s
test2(range(2000000))  # Prints ~9s        ~8s

보시다시피지도 기능을 초기화하는 데 거의 시간이 걸리지 않습니다. 그러나 맵 객체를 반복하는 것은 단순히 반복 가능한 것을 반복하는 것보다 시간이 오래 걸립니다. 이는 map ()에 전달 된 함수가 요소가 반복에서 도달 할 때까지 각 요소에 적용되지 않음을 의미합니다. 리스트를 원한다면리스트 이해를 사용하십시오. for 루프에서 반복하고 어느 시점에서 중단되는 경우 map을 사용하십시오.