var $iframe = document.getElementByID('myIfreme');
var childDocument = iframe.contentDocument ? iframe.contentDocument : iframe.contentWindow.document;
childDocument.documentElement.scrollTop = 0;
map
не является особенно питоническим. Я бы рекомендовал вместо этого использовать списки:
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()
делает что-то вроде этого:
def mymap(func, lst):
result = []
for e in lst:
result.append(func(e))
return result
Как вы можете видеть, он принимает функцию и список и возвращает новый список с результатом применяя функцию к каждому из элементов во входном списке. Я сказал «упростить бит», потому что на самом деле map()
может обрабатывать более одного итеративного:
Если передаются дополнительные итеративные аргументы, функция должна принимать много аргументов и применяется к элементам из всех итераций параллельно. Если одно итерабельнее короче другого, предполагается, что он расширен с помощью элементов 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
создает новый список, применяя функцию к каждому элементу источника:
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
вообще не относится к декартовому произведению, хотя я представляю, что кто-то, хорошо разбирающийся в функциональном программировании, может придумать какое-то непонятное для понимания способ создания одного с помощью map
.
map
в Python 3 эквивалентен этому:
def map(func, iterable):
for i in iterable:
yield func(i)
, и единственная разница в Python 2 заключается в том, что он создаст полный список результатов, чтобы вернуть все в один раз вместо yield
ing.
Хотя соглашение Python обычно предпочитает использование списков (или выражений генератора) для достижения того же результата, что и вызов 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
здесь будет, если вы начнете с list строк вместо одной строки - map
могут их перечислять индивидуально:
>>> a = ["foo", "bar", "baz"]
>>> list(map(list, a))
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]
Обратите внимание, что map(list, a)
эквивалентно в Python 2, но в Python 3 вам нужен вызов list
, если вы хотите делать что угодно, кроме подачи в контур for
(или функцию обработки, такую как sum
, который требует только итерации, а не последовательности). Но также обратите внимание на то, что обычно предпочтительным является понимание списка:
>>> [list(b) for b in a]
[['f', 'o', 'o'], ['b', 'a', 'r'], ['b', 'a', 'z']]
Надеемся, что это поможет кому-то новому в программировании и python:
Функция map()
должна применять ту же процедуру для каждого item
в iterable data structure
, например lists
, generators
, strings
и другие материалы.
Давайте посмотрим на пример: map()
может iterate
по каждому item
в list
и применить function
к каждому item
, чем return
(вернет вас) new list
.
Подумайте, что у вас есть function
, который принимает число (integer
), добавляет 1 к этому номеру и возвращает его.
def add_one(num):
new_num = num + 1
return new_num
У вас также есть list
номеров (integers
)
my_list = [1,3,6,7,8,10]
, если вы хотите increment
присвоить каждому номеру (integer
) в list
, вы можете сделать следующее:
map(add_one, my_list)
Примечание: минимально map()
требуется два arguments
. Сначала имя function
и второе что-то вроде результата list
.
вышеприведенного примера, map()
вернет вам это:
[2, 4, 7, 8, 9, 11]
Позволяет увидеть некоторые другие прохладный вещи map()
можно сделать. map()
может принимать несколько iterables
(lists, strings, etc
) и передавать element
из каждого list
(я использую список в качестве примера) в function
как argument
.
У нас есть следующие списки:
list_one = [1, 2, 3, 4, 5]
list_two = [11, 12, 13, 14, 15]
list_three = [21, 22, 23, 24, 25]
map()
может сделать вас new list
, который содержит добавление элементов в конкретном index
(положение).
Теперь запомните map()
, ему понадобится function
.
def add_from_three_lists(num1, num2, num3):
total_num = num1 + num2 + num3
return total_num
теперь позволяет использовать функцию map()
map(add_from_three_lists, list_one, List_two, list_three)
, и вы получите:
[33, 36, 39, 42, 45]
] ПОМНИТЕ: В Python2 map()
будет iterate
(пройдите через элементы lists
) в соответствии с самым длинным list
и передайте NoneType
функции для более короткого lists
, поэтому ваш function
должен искать NoneType
и обрабатывать их, иначе вы получите errors
. В python 3 map()
будет идти только по кратчайшему list
. Кроме того, в Python 3, map()
возвращает итератор, а не список.
map
гораздо менее подробным, чем списки, по крайней мере, для случая, который вы демонстрируете. – marbel 14 December 2016 в 17:40map
-эквивалент[v.__name__ for v in (object, str)]
? – A Sz 19 July 2017 в 10:53map(lambda v: v.__name__, list)
? – Kilian Koeltzsch 13 October 2017 в 07:55map
был иногда i> быстрее, чем понимания, иногда нет, именно из-за накладных вызовов функции? В частности, эвристика, которую я узнал, заключается в том, что при использовании функцииmap
требуется ввести дополнительный вызов функции, понимание происходит быстрее? Например. Я был убежден, чтоmap(lambda foo: foo.bar, my_list)
медленнее, чемfoo.bar for foo in my_list
, и что дажеmap(operator.add, my_list_of_pairs)
медленнее, чемx + y for x, y in my_list_of_pairs
, именно из-за вызова дополнительной функции. – mtraceur 20 February 2018 в 23:21