Verstehen der Kartenfunktion

Question

In der Python 2 Dokumentation steht:

Eingebaute Funktionen: map(function, iterable, ...)

Wendet die Funktion auf jedes Element von iterable an und gibt eine Liste der Ergebnisse zurück. Wenn zusätzliche iterable-Argumente übergeben werden, muss die Funktion so viele Argumente annehmen und wird auf die Elemente aus allen Iterablen parallel angewendet.

Wenn eine Iterable kürzer als eine andere ist, wird angenommen, dass sie verlängert ist mit None-Elementen erweitert.

Wenn die Funktion None wird die Identitätsfunktion angenommen; wenn es mehrere Argumente, map() gibt eine Liste zurück, die aus Tupeln besteht die die entsprechenden Elemente aus allen Iterablen enthalten (eine Art Transponierungsoperation).

Die iterierbaren Argumente können eine Sequenz oder ein beliebiges iterierbares Objekt sein; das Ergebnis ist immer eine Liste.

Welche Rolle spielt dies bei der Herstellung eines kartesischen Produkts?

content = map(tuple, array)

Welche Auswirkungen hat es, wenn man ein Tupel irgendwo einfügt? Mir ist auch aufgefallen, dass die Ausgabe ohne die Map-Funktion wie folgt aussieht abc und damit ist es a, b, c .

Ich möchte diese Funktion vollständig verstehen. Die Referenzdefinitionen sind ebenfalls schwer zu verstehen. Zu viel Schnickschnack.

Answer 1

map ist nicht besonders pythonisch. Ich würde empfehlen, stattdessen Listenauflösungen zu verwenden:

map(f, iterable)

ist im Grunde gleichbedeutend mit:

[f(x) for x in iterable]

map allein kann kein kartesisches Produkt bilden, weil die Länge der Ausgabeliste immer gleich der Eingabeliste ist. Sie können jedoch trivialerweise ein kartesisches Produkt mit einem Listenverständnis erstellen:

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

Die Syntax ist etwas verwirrend - das ist im Grunde gleichbedeutend mit:

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

Answer 2

map hat überhaupt nichts mit einem kartesischen Produkt zu tun, obwohl ich mir vorstellen kann, dass jemand, der sich mit funktionaler Programmierung auskennt, einen unmöglich zu verstehenden Weg finden könnte, ein solches zu erzeugen, indem er map .

map in Python 3 ist äquivalent zu diesem:

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

und der einzige Unterschied in Python 2 besteht darin, dass eine vollständige Liste von Ergebnissen erstellt wird, die alle auf einmal zurückgegeben werden, anstatt yield ing.

Obwohl die Python-Konvention in der Regel Listenausdrücke (oder Generatorausdrücke) bevorzugt, um das gleiche Ergebnis zu erzielen wie ein Aufruf von map besonders wenn Sie einen Lambda-Ausdruck als erstes Argument verwenden:

[func(i) for i in iterable]

Als Beispiel für das, was Sie in den Kommentaren zur Frage gefragt haben - "eine Zeichenkette in ein Array umwandeln", mit 'Array' wollen Sie wahrscheinlich entweder ein Tupel oder eine Liste (beide verhalten sich ein wenig wie Arrays aus anderen Sprachen) -.

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

Eine Verwendung von map hier wäre, wenn Sie mit einer Liste von Zeichenketten anstelle einer einzigen Zeichenkette - map können sie alle einzeln aufgelistet werden:

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

Beachten Sie, dass map(list, a) ist in Python 2 gleichwertig, aber in Python 3 benötigen Sie die list aufzurufen, wenn Sie etwas anderes tun wollen, als ihn in eine for Schleife (oder eine Verarbeitungsfunktion wie sum die nur eine Iterable, aber keine Sequenz benötigt). Beachten Sie aber auch hier, dass ein Listenverständnis in der Regel vorzuziehen ist:

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

Answer 3

map erstellt eine neue Liste, indem es eine Funktion auf jedes Element der Quelle anwendet:

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-är map ist gleichbedeutend mit dem Zusammenzippen von Eingabewerten und der anschließenden Anwendung der Transformationsfunktion auf jedes Element dieser zwischengezippten Liste. Es ist no ein kartesisches Produkt:

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

Ich habe die zip hier, aber map unterscheidet sich geringfügig, wenn die Iterablen nicht dieselbe Größe haben - wie in der Dokumentation beschrieben, erweitert es die Iterablen um None .

Answer 4

Etwas vereinfacht kann man sich das so vorstellen map() etwas in dieser Art zu tun:

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

Wie Sie sehen können, nimmt es eine Funktion und eine Liste und gibt eine neue Liste mit dem Ergebnis der Anwendung der Funktion auf jedes der Elemente in der Eingabeliste zurück. Ich sagte "ein wenig vereinfachend", denn in Wirklichkeit map() kann verarbeiten mehr als eine iterierbar:

Wenn zusätzliche Iterabilitätsargumente übergeben werden, muss die Funktion so viele Argumente annehmen und wird auf die Elemente aller Iterabilitäten parallel angewendet. Ist eine Iterabel kürzer als eine andere, wird angenommen, dass sie um None-Elemente erweitert wurde.

Zum zweiten Teil der Frage: Welche Rolle spielt dies bei der Herstellung eines kartesischen Produkts? gut, map() könnte für die Erzeugung des kartesischen Produkts einer solchen Liste verwendet werden:

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

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

... Aber um die Wahrheit zu sagen, mit product() ist eine viel einfachere und natürlichere Art, das Problem zu lösen:

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

In jedem Fall ist das Ergebnis das kartesische Produkt aus lst wie oben definiert:

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

Answer 5

En map() Funktion ist dazu da, um die gleiche Prozedur auf jedes Element in einer iterierbaren Datenstruktur, wie Listen, Generatoren, Strings und andere Dinge, anzuwenden.

Schauen wir uns ein Beispiel an: map() kann über jedes Element in einer Liste iterieren und eine Funktion auf jedes Element anwenden, dann wird die neue Liste zurückgegeben (zurückgeben).

Stellen Sie sich vor, Sie haben eine Funktion, die eine Zahl nimmt, 1 zu dieser Zahl addiert und sie zurückgibt:

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

Sie haben auch eine Liste von Nummern:

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

Wenn Sie jede Zahl in der Liste erhöhen wollen, können Sie wie folgt vorgehen:

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

Anmerkung: Mindestens map() benötigt zwei Argumente. Erstens einen Funktionsnamen und zweitens etwas wie eine Liste.

Sehen wir uns einige andere coole Dinge an map() tun können. map() kann mehrere Iterablen (Listen, Strings usw.) annehmen und ein Element aus jeder Iterable als Argument an eine Funktion übergeben.

Wir haben drei Listen:

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

map() kann eine neue Liste erstellen, die die Addition von Elementen an einem bestimmten Index enthält.

Jetzt erinnern map() braucht eine Funktion. Dieses Mal verwenden wir die eingebaute Funktion sum() Funktion. Laufende map() ergibt das folgende Ergebnis:

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

VERGESSEN:
In Python 2 map() durchläuft die Elemente der Listen nach der längsten Liste und übergibt None an die Funktion für die kürzeren Listen, so dass Ihre Funktion nach None und behandeln Sie sie, sonst erhalten Sie Fehler. In Python 3 map() hört auf, wenn die kürzeste Liste fertig ist. Auch in Python 3, map() gibt einen Iterator zurück, keine Liste.