Ultimativer Leitfaden zur Python-Kartenfunktion für die Datenverarbeitung

Einführung

Wir können die in Python integrierte Funktion map() verwenden, um eine Funktion auf jedes Element in einem Iterable (z. B. einer Liste oder einem Wörterbuch) anzuwenden und einen neuen Iterator zum Abrufen der Ergebnisse zurückzugeben. map() gibt ein Kartenobjekt (einen Iterator) zurück, das wir in anderen Teilen unseres Programms verwenden können. Wir können das Map-Objekt auch an die Funktion list() oder einen anderen Sequenztyp übergeben, um eine Iteration zu erstellen.

Die Syntax für die Funktion map() lautet wie folgt:

map(function, iterable, [iterable 2, iterable 3, ...])

Anstatt eine for-Schleife zu verwenden, bietet die Funktion map() eine Möglichkeit, eine Funktion auf jedes Element in einem Iterable anzuwenden. Daher kann es häufig leistungsfähiger sein, da die Funktion jeweils nur auf ein Element angewendet wird, anstatt Kopien der Elemente in ein anderes iterierbares Element zu erstellen. Dies ist besonders nützlich, wenn Sie an Programmen arbeiten, die große Datenmengen verarbeiten. map() kann auch mehrere Iterables als Argumente für die Funktion verwenden, indem jeweils ein Element von jedem Iterable an die Funktion gesendet wird.

In diesem Tutorial besprechen wir drei verschiedene Möglichkeiten, mit map() zu arbeiten: mit einer lambda-Funktion, mit einer benutzerdefinierten Funktion und schließlich mit einer integrierten in Funktion mit mehreren iterierbaren Argumenten.

Verwenden einer Lambda-Funktion

Das erste Argument für map() ist eine Funktion, die wir verwenden, um auf jedes Element anzuwenden. Python ruft die Funktion einmal für jedes Element in der Iterable auf, die wir an map() übergeben, und gibt das manipulierte Element innerhalb eines Kartenobjekts zurück. Als erstes Funktionsargument können wir entweder eine benutzerdefinierte Funktion übergeben oder lambda-Funktionen verwenden, insbesondere wenn der Ausdruck weniger komplex ist.

Die Syntax von map() mit einer Lambda-Funktion lautet wie folgt:

map(lambda item: item[] expression, iterable)

Mit einer Liste wie der folgenden können wir eine lambda-Funktion mit einem Ausdruck implementieren, den wir auf jedes Element in unserer Liste anwenden möchten:

numbers = [10, 15, 21, 33, 42, 55]

Um einen Ausdruck auf jede unserer Zahlen anzuwenden, können wir map() und lambda verwenden:

mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))

Hier deklarieren wir ein Element in unserer Liste als x. Dann fügen wir unseren Ausdruck hinzu. Wir übergeben unsere Zahlenliste als Iterable für map().

Um die Ergebnisse sofort zu erhalten, drucken wir eine Liste des map-Objekts aus:

print(mapped_numbers)

[23, 33, 45, 69, 87, 113]

Wir haben list() verwendet, damit uns das Kartenobjekt als Liste zurückgegeben wird und nicht als weniger lesbares Objekt wie: . Das Kartenobjekt ist ein Iterator über unsere Ergebnisse, daher können wir es mit for durchlaufen oder mit list() in eine Liste umwandeln. Wir machen das hier, weil es eine gute Möglichkeit ist, die Ergebnisse zu überprüfen.

Letztendlich ist map() am nützlichsten, wenn mit großen Datensätzen gearbeitet wird, daher würden wir wahrscheinlich weiter mit dem Kartenobjekt arbeiten und im Allgemeinen keinen Konstruktor wie list() verwenden auf sie.

Für kleinere Datensätze sind möglicherweise Listenverständnisse besser geeignet, aber für die Zwecke dieses Tutorials verwenden wir einen kleinen Datensatz, um map() zu demonstrieren.

Implementieren einer benutzerdefinierten Funktion

Ähnlich wie bei einem lambda können wir eine von uns definierte Funktion verwenden, um sie auf eine iterierbare Funktion anzuwenden. Während die Implementierung von lambda-Funktionen nützlicher ist, wenn Sie mit einem einzeiligen Ausdruck arbeiten, sind benutzerdefinierte Funktionen besser geeignet, wenn der Ausdruck komplexer wird. Wenn wir außerdem ein weiteres Datenelement an die Funktion übergeben müssen, die Sie auf Ihre iterierbaren Funktionen anwenden, können benutzerdefinierte Funktionen aus Gründen der Lesbarkeit eine bessere Wahl sein.

In der folgenden Iterable ist beispielsweise jedes Element ein Wörterbuch, das unterschiedliche Details zu jedem unserer Aquarienlebewesen enthält:

aquarium_creatures = [
 {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
 {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
 {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
 {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
 {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
 {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
]

Wir haben beschlossen, dass tatsächlich alle Aquarienbewohner in dasselbe Becken umziehen. Wir müssen unsere Aufzeichnungen aktualisieren, um zu berücksichtigen, dass alle unsere Kreaturen in Tank 42 umziehen. Damit map() auf jedes Wörterbuch und jedes Schlüssel-Wert-Paar in den Wörterbüchern zugreifen kann, erstellen wir eine verschachtelte Funktion:

def assign_to_tank(aquarium_creatures, new_tank_number):
 def apply(x):
  x["tank number"] = new_tank_number
  return x
 return map(apply, aquarium_creatures)

Wir definieren eine Funktion assign_to_tank(), die aquarium_creatures und new_tank_number als Parameter verwendet. In assign_to_tank() übergeben wir apply() als Funktion an map() in der letzten Zeile. Die Funktion assign_to_tank gibt den aus map() resultierenden Iterator zurück.

apply() verwendet x als Argument, das ein Element in unserer Liste darstellt – ein einzelnes Wörterbuch.

Als nächstes definieren wir, dass x der Schlüssel "tank number" von aquarium_creatures ist und dass er die in new_tank_number übergebenen Werte speichern soll . Wir senden jeden Artikel unter Angabe der neuen Tanknummer zurück.

Wir rufen assign_to_tank() mit unserer Liste von Wörterbüchern und der neuen Tanknummer auf, die wir für jede Kreatur ersetzen möchten:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Sobald die Funktion abgeschlossen ist, haben wir unser Kartenobjekt in der Variablen assigned_tanks gespeichert, die wir in eine Liste umwandeln und ausdrucken:

print(list(assigned_tanks))

Wir erhalten die folgende Ausgabe von diesem Programm:

[{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

Wir haben die neue Tanknummer unserer Wörterbuchliste zugeordnet. Mithilfe einer von uns definierten Funktion können wir map() integrieren, um die Funktion effizient auf jedes Element der Liste anzuwenden.

Verwenden einer integrierten Funktion mit mehreren Iterables

Genauso wie lambda-Funktionen oder unsere eigenen definierten Funktionen können wir in Python integrierte Funktionen mit map() verwenden. Um eine Funktion mit mehreren Iterables anzuwenden, übergeben wir nach dem ersten einen weiteren Iterable-Namen. Verwenden Sie beispielsweise die Funktion pow(), die zwei Zahlen verwendet, um die Potenz der Basiszahl mit dem angegebenen Exponenten zu ermitteln.

Hier haben wir unsere Listen mit Ganzzahlen, die wir mit pow() verwenden möchten:

base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]

Als nächstes übergeben wir pow() als unsere Funktion an map() und stellen die beiden Listen als unsere Iterables bereit:

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

map() wendet die Funktion pow() auf dasselbe Element in jeder Liste an, um die Leistung bereitzustellen. Daher werden in unseren Ergebnissen 2**1, 4**2, 6**3 usw. angezeigt:

[2, 16, 216, 4096, 100000]

Wenn wir map() ein Iterable bereitstellen würden, das länger als das andere ist, würde map() die Berechnung stoppen, sobald das Ende des kürzesten Iterables erreicht ist. Im folgenden Programm erweitern wir base_numbers um drei zusätzliche Zahlen:

base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
powers = [1, 2, 3, 4, 5]

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

Dadurch ändert sich an der Berechnung dieses Programms nichts und es kommt immer noch zum gleichen Ergebnis:

[2, 16, 216, 4096, 100000]

Wir haben die Funktion map() mit einer in Python integrierten Funktion verwendet und festgestellt, dass sie mehrere Iterables verarbeiten kann. Wir haben auch überprüft, dass map() weiterhin mehrere Iterables verarbeitet, bis das Ende des Iterables mit den wenigsten Elementen erreicht ist.

Abschluss

In diesem Tutorial haben wir verschiedene Methoden zur Verwendung der Funktion map() in Python untersucht. Sie haben jetzt die Möglichkeit, map() mit benutzerdefinierten Funktionen, Lambda-Ausdrücken und anderen integrierten Funktionen zu verwenden. Darüber hinaus kann map() auf Funktionen angewendet werden, die mehrere Iterables erfordern, was seine Vielseitigkeit bei Datenverarbeitungsaufgaben erhöht.

Zu Demonstrationszwecken haben wir die Ergebnisse von map() direkt in eine Liste umgewandelt. In praktischen Anwendungen kann das zurückgegebene Kartenobjekt weiter bearbeitet werden, um es an bestimmte Anforderungen anzupassen.

Um Ihr Verständnis von Python zu vertiefen, nutzen Sie bitte die folgenden Ressourcen:

Tutorial zur Python-Funktion map() für detailliertere Beispiele und Anwendungsfälle.
Verstehen Sie Wörterbücher in Python, um Ihr Wissen über Python-Datenstrukturen zu erweitern.
Python-String-Funktionen zum Erkunden verschiedener String-Manipulationstechniken.

Diese Ressourcen vermitteln Ihnen ein umfassendes Verständnis der Funktionen von Python und wie Sie diese effektiv in Ihren Projekten nutzen können.

Wenn Sie mehr über Python erfahren möchten, schauen Sie sich unsere Serie „How To Code in Python“ und unsere Python-Themenseite an. Um mehr über die Arbeit mit Datensätzen in der funktionalen Programmierung zu erfahren, lesen Sie unseren Artikel über die Funktion filter().

FAQs

Was macht map() in Python?

Die Funktion map() in Python übernimmt eine Funktion und ein oder mehrere Iterables und gibt einen Iterator zurück, der die angegebene Funktion auf jedes Element der bereitgestellten Iterables anwendet. Mit anderen Worten: Es „ordnet“ die Funktion jedem Element im Iterable zu. Zum Beispiel:

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)

Hier ist squares ein Iterator von 1, 4, 9, 16.

Wie erstellt man eine Karte in Python?

Sie erstellen ein Kartenobjekt, indem Sie die integrierte Funktion map() mit einer Funktion und mindestens einer Iterable als Argumenten aufrufen. Zum Beispiel:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Creates a map object

Anschließend können Sie über die Zuordnung iterieren oder sie in eine Liste konvertieren, um die Ergebnisse anzuzeigen:

print(list(mapped))  # [2, 3, 4]

Ist die Karte in Python faul?

Ja, in Python 3 gibt map() einen lazy iterator zurück, was bedeutet, dass nicht alle Ergebnisse auf einmal verarbeitet oder im Speicher gespeichert werden. Stattdessen wird jedes Ergebnis bei Bedarf berechnet, während Sie darüber iterieren. Dies kann insbesondere bei großen Datensätzen speichereffizienter sein, bedeutet aber auch, dass Sie dasselbe Kartenobjekt nicht direkt indizieren oder wiederholt iterieren können, ohne es zu rekonstruieren.

Wie funktioniert die Funktion `map()`?

Die Funktion map() funktioniert wie folgt:

Sie stellen eine Funktion und eine oder mehrere Iterables bereit.
map() ruft ein Element aus jedem Iterable ab.
Es ruft die Funktion mit diesen Elementen als Argumenten auf.
Es liefert das Ergebnis dieses Funktionsaufrufs.
Dieser Vorgang wird wiederholt, bis eines der Iterables erschöpft ist.

Wenn mehrere Iterables angegeben sind, stoppt map(), wenn das kürzeste Iterable erschöpft ist. Zum Beispiel:

numbers = [1, 2, 3]
others = [10, 20, 30]
result = map(lambda x, y: x + y, numbers, others)
print(list(result))  # [11, 22, 33]

Sollte ich `map` in Python verwenden?

Ob Sie map() verwenden sollten, hängt von Ihren persönlichen Vorlieben und der Lesbarkeit ab:

Vorteile:

In manchen Fällen kann es prägnanter sein.
In bestimmten Szenarien kann es etwas schneller sein als das Listenverständnis (wenn auch oft nicht wesentlich).

Nachteile:

Code, der Listenverständnisse oder Generatorausdrücke verwendet, wird oft als „pythonischer“ und leichter lesbar angesehen.
Neuere Python-Programmierer finden das Verständnis von Listen möglicherweise intuitiver.

Kurz gesagt: Verwenden Sie map(), wenn Ihr Code dadurch klarer und direkter wird. Ansonsten sind Listenverständnisse oder Generatorausdrücke eine sehr häufige Alternative.

Wie konvertiert man `map` in Python in einen String?

Ein map-Objekt ist ein Iterator, kein String. Wenn Sie die Ergebnisse eines map()-Aufrufs in einen String konvertieren möchten, müssen Sie ihn zunächst durchlaufen. Zu den gängigen Ansätzen gehören:

Konvertieren in eine Liste und dann in eine String-Darstellung:

mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"

Zusammenfügen der Ergebnisse, wenn es sich um String-Elemente handelt:

mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

Die beste Methode hängt davon ab, ob Sie eine für Menschen lesbare Listendarstellung (str(list(...))) oder eine Verkettung der Ergebnisse (''.join(...) wünschen. )).

Was macht `map count()`?

map-Objekte in Python verfügen nicht über eine integrierte count()-Methode. Die Methode count() ist für Listen, Zeichenfolgen und bestimmte andere Sammlungen verfügbar. Wenn Sie das Vorkommen eines von einem Kartenobjekt erzeugten Werts zählen möchten, müssen Sie ihn zunächst in eine Liste konvertieren (die den Iterator verbraucht):

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2, because 2*2=4 appears twice

Wenn Sie eine Zählung ohne Konvertierung in eine Liste benötigen, können Sie manuell iterieren:

count_of_value = sum(1 for x in map(lambda x: x*2, [1, 2, 3, 2]) if x == 4)

Was machen `map` und `filter` in Python?

map(function, iterable): Wendet eine Funktion auf jedes Element von iterable an und gibt einen Iterator der Ergebnisse zurück.
filter(function, iterable): Gibt einen Iterator von Elementen aus iterable zurück, für die function(element) True ist. Wenn die Funktion „None“ ist, werden Elemente zurückgegeben, die für sich genommen wahr sind.

Zum Beispiel:

nums = [1, 2, 3, 4, 5]
mapped_nums = map(lambda x: x*2, nums)        # [2, 4, 6, 8, 10]
filtered_nums = filter(lambda x: x > 2, nums) # [3, 4, 5]

map transformiert jedes Element, während filter bestimmte Elemente basierend auf einer Bedingung auswählt.