webentwicklung-frage-antwort-db.com.de

Grundlegendes zur Kartenfunktion

map(function, iterable, ...)

Wenden Sie die Funktion auf jedes Element von iterable an und geben Sie eine Liste der Ergebnisse zurück. Wenn zusätzliche iterierbare Argumente übergeben werden, muss function so viele Argumente annehmen und wird von allen iterablen gleichzeitig auf die Elemente angewendet.

Wenn eine iterable kürzer als eine andere ist, wird angenommen, dass sie mit None-Elementen erweitert wird.

Wenn function None ist, wird die Identitätsfunktion angenommen. Wenn es mehrere Argumente gibt, gibt map() eine Liste mit Tupeln zurück, 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)

Wie wirkt es sich aus, wenn ein Tupel irgendwo dort abgelegt wird? Mir ist auch aufgefallen, dass die Ausgabe ohne die Map-Funktion abc und damit a, b, c ist.

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

280
Web Master

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 ein kartesisches Produkt nicht ausführen, da die Länge seiner Ausgabeliste immer der Länge seiner Eingabeliste entspricht. Sie können 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 entspricht im Wesentlichen:

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

map bezieht sich überhaupt nicht auf ein kartesisches Produkt, obwohl ich mir vorstellen kann, dass jemand, der sich mit funktionaler Programmierung auskennt, einen unerklärlichen Weg finden könnte, mit map eine Eins zu generieren.

map in Python 3 entspricht:

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 der Ergebnisse erstellt wird, die auf einmal zurückgegeben werden sollen, anstatt yielding.

Obwohl die Python - Konvention normalerweise Listenverständnisse (oder Generatorausdrücke) bevorzugt, um dasselbe Ergebnis wie ein Aufruf von map zu erzielen, insbesondere 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 "Verwandeln Sie einen String in ein Array" gefordert haben, 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 wäre hier, wenn Sie mit einem Liste von Zeichenfolgen anstelle einer einzelnen Zeichenfolge beginnen - 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) in Python 2 äquivalent ist, aber in Python 3 benötigen Sie den list -Aufruf, wenn Sie etwas anderes tun möchten, als es in ein einzuspeisen for-Schleife (oder eine Verarbeitungsfunktion wie sum, die nur eine iterable und keine Sequenz benötigt). 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']]
80
lvc

map erstellt eine neue Liste, indem auf jedes Element der Quelle eine Funktion 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-ary map entspricht dem Komprimieren von Eingabe-Iterablen und dem Anwenden der Transformationsfunktion auf jedes Element dieser zwischengeschalteten Komprimierungsliste. 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 hier Zip verwendet, aber das Verhalten von map unterscheidet sich geringfügig, wenn die Iterables nicht dieselbe Größe haben. Wie in der Dokumentation angegeben, werden die Iterables um None erweitert.

33
Cat Plus Plus

Vereinfacht gesagt, können Sie sich vorstellen, dass map() so etwas tut:

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

Wie Sie sehen, nimmt es eine Funktion und eine Liste an und gibt eine neue Liste mit dem Ergebnis zurück, dass die Funktion auf jedes der Elemente in der Eingabeliste angewendet wird. Ich sagte "ein bisschen vereinfachen", weil in Wirklichkeit map() verarbeiten kann mehr als eine iterable:

Wenn zusätzliche iterierbare Argumente übergeben werden, muss function so viele Argumente annehmen und wird von allen iterablen gleichzeitig auf die Elemente angewendet. Wenn eine iterable kürzer als eine andere ist, wird angenommen, dass sie mit None-Elementen erweitert wird.

Für den zweiten Teil der Frage: Welche Rolle spielt dies bei der Herstellung eines kartesischen Produkts? Nun, map()könnte verwendet werden, um das kartesische Produkt einer Liste wie der folgenden 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, ist die Verwendung von product() eine viel einfachere und natürlichere Möglichkeit, 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)]
20
Óscar López

Die Funktion map() wendet dieselbe Prozedur auf alle Elemente in einer iterierbaren Datenstruktur an, z. B. Listen, Generatoren, Zeichenfolgen und andere Elemente.

Schauen wir uns ein Beispiel an: map() kann jedes Element in einer Liste durchlaufen und auf jedes Element eine Funktion anwenden, um die neue Liste zurückzugeben (zurückzugeben).

Stellen Sie sich vor, Sie haben eine Funktion, die eine Zahl annimmt, dieser Zahl eine 1 hinzufügt 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 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() benötigt zwei Argumente. Erstens ein Funktionsname und zweitens so etwas wie eine Liste.

Lassen Sie uns einige andere coole Dinge sehen, die map() tun kann. map() kann mehrere Iterables (Listen, Strings usw.) annehmen 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() kann Sie zu einer neuen Liste machen, die das Hinzufügen von Elementen an einem bestimmten Index enthält.

Denken Sie jetzt daran, dass map() eine Funktion benötigt. Dieses Mal verwenden wir die eingebaute Funktion sum(). Wenn Sie map() ausführen, erhalten Sie das folgende Ergebnis:

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

REMEMBER:
In Python 2 map() werden die Elemente der Listen entsprechend der längsten Liste durchlaufen und None an die Funktion für die kürzere übergeben Listen, daher sollte Ihre Funktion nach None suchen und diese behandeln, da sonst Fehler auftreten. In Python 3 map() stoppt nach Beendigung mit der kürzesten Liste. In Python 3 gibt map() einen Iterator zurück, keine Liste.

14
BlooB

Python3 - Karte (func, iterable)

Eine Sache, die nicht vollständig erwähnt wurde (obwohl @BlooB es irgendwie erwähnt hat), ist, dass map ein Kartenobjekt zurückgibt NOT eine Liste. Dies ist ein großer Unterschied in Bezug auf die Zeitleistung bei der Initialisierung und Iteration. 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, dauert die Initialisierung der Kartenfunktion fast keine Zeit. Das Durchlaufen des Kartenobjekts dauert jedoch länger als das einfache Durchlaufen des iterablen Objekts. Dies bedeutet, dass die an map () übergebene Funktion nicht auf jedes Element angewendet wird, bis das Element in der Iteration erreicht ist. Wenn Sie eine Liste wünschen, verwenden Sie das Listenverständnis. Wenn Sie vorhaben, in einer for-Schleife zu iterieren und irgendwann abbrechen, verwenden Sie map.

4
Ranga