Kartenfunktion verstehen

Die Python 2-Dokumentation sagt:

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

Wenden Sie die Funktion auf jedes iterierbare Element an und geben Sie eine Liste der Ergebnisse zurück. Wenn zusätzliche iterierbare Argumente übergeben werden, muss die Funktion so viele Argumente annehmen und wird parallel auf die Elemente aller iterierbaren Elemente angewendet.

Wenn ein Iterable kürzer als ein anderes ist, wird davon ausgegangen, dass es mit None-Elementen erweitert wird.

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

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)

Welchen Effekt hat es, irgendwo dort ein Tupel einzufügen? Mir ist auch aufgefallen, dass ohne die Kartenfunktion die Ausgabe erfolgt abc und damit ist es a, b, c.

Ich möchte diese Funktion vollständig verstehen. Die Referenzdefinitionen sind auch schwer zu verstehen. Zu viel schicker Flaum.

map ist nicht besonders pythonisch. Ich würde stattdessen die Verwendung von Listenverständnissen empfehlen:

map(f, iterable)

ist im Grunde gleichbedeutend mit:

[f(x) for x in iterable]

map allein kann kein kartesisches Produkt erstellen, da die Länge seiner Ausgabeliste immer gleich der Länge seiner 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 äquivalent zu:

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

map bezieht sich überhaupt nicht auf ein kartesisches Produkt, obwohl ich mir vorstelle, dass jemand, der sich mit funktionaler Programmierung auskennt, einen unmöglich verständlichen Weg finden könnte, eine Eins zu erzeugen 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 es eine vollständige Liste von Ergebnissen aufbaut, die alle auf einmal zurückgegeben werden yielding.

Obwohl die Python-Konvention normalerweise Listenverständnisse (oder Generatorausdrücke) bevorzugt, um das gleiche Ergebnis wie ein Aufruf von zu erzielen mapinsbesondere 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 zu der Frage angefordert haben – “verwandeln Sie eine Zeichenfolge in ein Array”, möchten Sie mit “Array” 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 a beginnen aufführen von Saiten statt einer einzelnen Saite – map kann alle einzeln auflisten:

>>> 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 äquivalent, aber in Python 3 benötigen Sie die list rufen Sie an, wenn Sie etwas anderes tun möchten, als es in eine einzuspeisen for Schleife (oder eine Verarbeitungsfunktion wie z sum das braucht nur ein Iterable und keine Sequenz). Beachten Sie aber auch noch einmal, dass in der Regel ein Listenverständnis bevorzugt wird:

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

map erstellt eine neue Liste, indem eine Funktion auf jedes Element der Quelle angewendet wird:

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 entspricht dem Komprimieren von Eingabe-Iterablen und dem anschließenden Anwenden der Transformationsfunktion auf jedes Element dieser gezippten Zwischenliste. Es ist nicht 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 verwendet zip hier aber map Das Verhalten unterscheidet sich tatsächlich geringfügig, wenn Iterables nicht die gleiche Größe haben – wie in der Dokumentation angegeben, erweitert es Iterables, um sie zu enthalten None.

Etwas vereinfacht, können Sie sich vorstellen map() so etwas 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 bisschen vereinfachen”, weil in Wirklichkeit map() verarbeiten kann mehr als eine wiederholbar:

Wenn zusätzliche iterierbare Argumente übergeben werden, muss die Funktion so viele Argumente annehmen und wird parallel auf die Elemente aller iterierbaren Elemente angewendet. Wenn ein Iterable kürzer als ein anderes ist, wird davon ausgegangen, dass es mit None-Elementen erweitert wird.

Für den zweiten Teil der Frage: Welche Rolle spielt dies bei der Herstellung eines kartesischen Produkts? Gut, map() könnte verwendet werden, um das kartesische Produkt einer Liste wie dieser zu erzeugen:

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 ein viel einfacherer und natürlicher Weg, um das Problem zu lösen:

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

In jedem Fall ist das Ergebnis das kartesische Produkt von 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)]

Das map() -Funktion ist dazu da, dasselbe Verfahren auf jedes Element in einer iterierbaren Datenstruktur anzuwenden, wie Listen, Generatoren, Zeichenfolgen und andere Dinge.

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

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

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

Sie haben auch eine Liste mit Zahlen:

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

Wenn Sie jede Nummer in der Liste erhöhen möchten, können Sie Folgendes tun:

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

Hinweis: Mindestens map() braucht zwei Argumente. Erstens ein Funktionsname und zweitens so etwas wie eine Liste.

Lass uns ein paar andere coole Dinge sehen map() tun können.
map() kann mehrere Iterables (Listen, Strings usw.) nehmen und ein Element von jedem 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() können Sie eine neue Liste erstellen, die das Hinzufügen von Elementen an einem bestimmten Index enthält.

Jetzt erinnere dich map(), braucht eine Funktion. Diesmal verwenden wir die eingebaute sum() Funktion. Betrieb map() ergibt folgendes Ergebnis:

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

DENKEN SIE DARAN:

Bei Python2 map()wird gemäß der längsten Liste iterieren (die Elemente der Listen durchlaufen) und übergeben None zu der Funktion für die kürzeren Listen, also sollte Ihre Funktion suchen None und behandeln Sie sie, sonst erhalten Sie Fehler. Bei Python3 map() stoppt nach Abschluss der kürzesten Liste. Auch in Python 3, map() gibt einen Iterator zurück, keine Liste.

Python3 – map(funktion, iterierbar)

Eine Sache, die nicht vollständig erwähnt wurde (obwohl @BlooB es irgendwie erwähnt hat), ist, dass map ein Kartenobjekt zurückgibt NICHT eine Liste. Dies ist ein großer Unterschied, wenn es um die Zeitleistung bei Initialisierung und Iteration geht. Betrachten Sie diese beiden Tests.

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

Wie Sie sehen können, dauert die Initialisierung der Kartenfunktion fast keine Zeit. Das Iterieren durch das Kartenobjekt dauert jedoch länger als das einfache Iterieren durch das Iterable. Das bedeutet, dass die an map() übergebene Funktion nicht auf jedes Element angewendet wird, bis das Element in der Iteration erreicht wird. Wenn Sie eine Liste wünschen, verwenden Sie list comprehension. Wenn Sie vorhaben, in einer for-Schleife zu iterieren und irgendwann abbrechen, verwenden Sie map.