Ultimativer Leitfaden zur Python Map-Funktion für die Datenverarbeitung

Einführung

Wir können die eingebaute Python-Funktion map() verwenden, um eine Funktion auf jedes Element in einem Iterable (wie einer Liste oder einem Dictionary) anzuwenden und einen neuen Iterator zurückzugeben, um die Ergebnisse abzurufen. map() gibt ein Map-Objekt (einen Iterator) zurück, das wir in anderen Teilen unseres Programms verwenden können. Wir können das Map-Objekt auch der Funktion list() oder einem anderen Sequenztyp übergeben, um ein Iterable zu erstellen.

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

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

Anstatt eine for-Schleife zu verwenden, bietet die map()-Funktion eine Möglichkeit, eine Funktion auf jedes Element in einem Iterable anzuwenden. Daher kann es oft leistungsfähiger sein, da die Funktion nur auf ein Element gleichzeitig angewendet wird, anstatt Kopien der Elemente in ein anderes Iterable zu erstellen. Dies ist besonders nützlich, wenn man an Programmen arbeitet, die große Datensätze verarbeiten. map() kann auch mehrere Iterables als Argumente an die Funktion übergeben, indem jeweils ein Element aus jedem Iterable an die Funktion gesendet wird.

In diesem Tutorial werden wir drei verschiedene Möglichkeiten durchgehen, wie man mit map() arbeitet: mit einer lambda-Funktion, mit einer benutzerdefinierten Funktion und schließlich mit einer eingebauten Funktion, die mehrere iterable Argumente verwendet.

Verwendung einer Lambda-Funktion

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

Die Syntax von map() mit einer Lambda-Funktion ist 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 erklären wir ein Element in unserer Liste als x. Dann fügen wir unseren Ausdruck hinzu. Wir übergeben unsere Liste von Zahlen als das iterierbare Element 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 das Map-Objekt als Liste an uns zurückgegeben wird, anstatt als ein weniger menschenlesbares Objekt wie: <map object at 0x7fc250003a58>. Das Map-Objekt ist ein Iterator über unsere Ergebnisse, sodass wir es mit for durchlaufen oder list() verwenden können, um es in eine Liste umzuwandeln. Wir machen das hier, weil es eine gute Möglichkeit ist, die Ergebnisse zu überprüfen.

Letztendlich ist map() am nützlichsten, wenn man mit großen Datensätzen arbeitet, daher würden wir wahrscheinlich weiter mit dem Map-Objekt arbeiten und allgemein keinen Konstruktor wie list() dafür verwenden.

Für kleinere Datensätze können List Comprehensions geeigneter sein, aber für die Zwecke dieses Tutorials verwenden wir einen kleinen Datensatz, um map() zu demonstrieren.

Implementierung einer benutzerdefinierten Funktion

Ähnlich wie bei einer lambda können wir eine von uns definierte Funktion verwenden, um sie auf ein iterierbares Objekt anzuwenden. Während lambda-Funktionen nützlicher sind, wenn Sie mit einem einzeiligen Ausdruck arbeiten, sind benutzerdefinierte Funktionen besser geeignet, wenn der Ausdruck komplexer wird. Darüber hinaus können benutzerdefinierte Funktionen die bessere Wahl für die Lesbarkeit sein, wenn wir ein weiteres Stück Daten an die Funktion übergeben müssen, die Sie auf Ihr iterierbares Objekt anwenden.

Zum Beispiel enthält in der folgenden Iterierbaren jeder Artikel ein Wörterbuch, das verschiedene Details über jede unserer Aquarienkreaturen 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 alle Aquarientiere tatsächlich in dasselbe Becken ziehen werden. Wir müssen unsere Aufzeichnungen aktualisieren, um zu zeigen, dass alle unsere Kreaturen in das Becken 42 ziehen. Um map() den Zugriff auf jedes Wörterbuch und jedes Schlüssel:Wert-Paar in den Wörterbüchern zu ermöglichen, erstellen wir eine geschachtelte 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 annimmt. In assign_to_tank() übergeben wir apply() als die Funktion, die auf der letzten Zeile von map() angewendet wird. Die Funktion assign_to_tank gibt den Iterator zurück, der aus map() resultiert.

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

Als nächstes definieren wir, dass x der "Tanknummer" Schlüssel aus aquarium_creatures ist und dass er die übergebene new_tank_number speichern soll. Wir geben jeden Artikel zurück, nachdem wir die neue Tanknummer angewendet haben.

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

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

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

print(list(assigned_tanks))

Wir werden die folgende Ausgabe von diesem Programm erhalten:

[{'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 Liste von Wörterbüchern zugeordnet. Mit einer Funktion, die wir definieren, können wir map() verwenden, um die Funktion effizient auf jedes Element der Liste anzuwenden.

Verwendung einer integrierten Funktion mit mehreren Iterierbaren

Auf die gleiche Weise wie lambda-Funktionen oder unsere eigenen definierten Funktionen können wir auch in Python eingebaute Funktionen mit map() verwenden. Um eine Funktion mit mehreren Iterables anzuwenden, geben wir einen weiteren Iterablen-Namen nach dem ersten an. Zum Beispiel können wir die pow()-Funktion verwenden, die zwei Zahlen entgegennimmt, um die Potenz der Basiszahl zur angegebenen Exponente zu berechnen.

Hier haben wir unsere Listen von 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 zur Verfügung:

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

print(numbers_powers)

map() wird die pow()-Funktion auf dasselbe Element in jeder Liste anwenden, um die Potenz bereitzustellen. Daher werden unsere Ergebnisse 2**1, 4**2, 6**3 usw. anzeigen:

[2, 16, 216, 4096, 100000]

Wenn wir map() ein iterierbares Objekt übergeben würden, das länger ist als das andere, würde map() die Berechnung stoppen, sobald es das Ende des kürzesten iterierbaren Objekts erreicht. In dem folgenden Programm erweitern wir base_numbers um drei weitere 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)

Infolgedessen wird sich innerhalb der Berechnung dieses Programms nichts ändern, und es wird weiterhin dasselbe Ergebnis liefern:

[2, 16, 216, 4096, 100000]

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

Schlussfolgerung

In diesem Tutorial haben wir verschiedene Methoden zur Verwendung der map()-Funktion in Python untersucht. Sie haben jetzt die Möglichkeit, map() mit benutzerdefinierten Funktionen, lambda-Ausdrücken und anderen eingebauten Funktionen zu verwenden. Darüber hinaus kann map() auf Funktionen angewendet werden, die mehrere Iterierbare 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 Map-Objekt weiter bearbeitet werden, um spezifischen Anforderungen gerecht zu werden.

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

Python map() Funktion Tutorial für detailliertere Beispiele und Anwendungsfälle.
Verstehen von Dictionaries in Python, um Ihr Wissen über Datenstrukturen in Python zu erweitern.
Python-Zeichenfolgenfunktionen zur Erkundung verschiedener Techniken zur Zeichenfolgenmanipulation.

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

Wenn Sie mehr über Python lernen möchten, werfen Sie einen Blick auf unsere Reihe "Wie man in Python programmiert" und unsere Themenseite zu Python. Um mehr über die Arbeit mit Datensätzen in der funktionalen Programmierung zu erfahren, lesen Sie unseren Artikel zur filter()-Funktion.

Häufig gestellte Fragen

Was macht map() in Python?

Die map()-Funktion in Python nimmt eine Funktion und ein oder mehrere Iterable und gibt einen Iterator zurück, der die gegebene Funktion auf jedes Element der bereitgestellten Iterables anwendet. Mit anderen Worten, sie "ordnet" die Funktion jedem Element im Iterable zu. Zum Beispiel:

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

Hier wird squares ein Iterator von 1, 4, 9, 16. sein.

Wie erstellt man eine Karte in Python?

Sie erstellen ein Kartenobjekt, indem Sie die eingebaute map()-Funktion mit einer Funktion und mindestens einem iterierbaren Objekt als Argumente 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

Sie können dann darüber iterieren oder es in eine Liste umwandeln, um die Ergebnisse zu sehen:

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

Ist die Map-Funktion faul in Python?

Ja, in Python 3 gibt map() einen faulen Iterator zurück, was bedeutet, dass nicht alle Ergebnisse auf einmal verarbeitet oder im Speicher gespeichert werden. Stattdessen wird jedes Ergebnis nach Bedarf berechnet, während Sie über ihn iterieren. Dies kann speichereffizienter sein, insbesondere bei großen Datensätzen, bedeutet jedoch auch, dass Sie ein Map-Objekt nicht direkt indizieren oder mehrmals durchlaufen können, ohne es neu zu konstruieren.

Wie funktioniert die `map()`-Funktion?

Die map()-Funktion funktioniert wie folgt:

Sie stellen eine Funktion und ein oder mehrere Iterierbare zur Verfügung.
map() ruft ein Element aus jedem iterierbaren Objekt ab.
Es ruft die Funktion mit diesen Elementen als Argumente auf.
Es liefert das Ergebnis dieses Funktionsaufrufs.
Es wiederholt diesen Prozess, 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 der persönlichen Vorliebe und der Lesbarkeit ab:

Vorteile:

In einigen Fällen kann es prägnanter sein.
In bestimmten Szenarien kann es etwas schneller sein als Listenkompositionen (obwohl oft nicht signifikant).

Nachteile:

Code, der List Comprehensions oder Generatorausdrücke verwendet, wird oft als "pythonesk" und leichter lesbar betrachtet.
Neuere Python-Programmierer könnten Listenverständnisse intuitiver finden.

Kurz gesagt, verwenden Sie map(), wenn es Ihren Code klarer und direkter macht. Andernfalls sind List Comprehensions oder Generatorausdrücke eine sehr verbreitete Alternative.

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

Ein map Objekt ist ein Iterator, keine Zeichenkette. Wenn Sie die Ergebnisse eines map() Aufrufs in eine Zeichenkette umwandeln möchten, müssen Sie zuerst darüber iterieren. Häufige Ansätze sind:

Umwandlung in eine Liste und dann in eine stringdarstellung:

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

Die Ergebnisse zusammenfügen, wenn sie Zeichenfolgen-Elemente sind:

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

Die beste Methode hängt davon ab, ob Sie eine menschenlesbare Listenrepräsentation (str(list(...))) oder eine Verkettung der Ergebnisse (''.join(...)) wünschen.

Was macht `map count()`?

map-Objekte in Python haben keine eingebaute count()-Methode. Die count()-Methode ist für Listen, Strings und bestimmte andere Sammlungen verfügbar. Wenn Sie Vorkommen eines Wertes zählen möchten, der von einem map-Objekt erzeugt wird, müssen Sie es zuerst in eine Liste umwandeln (was 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 benötigen, ohne in eine Liste umzuwandeln, könnten 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 die Funktion auf jedes Element des Iterables 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 function None ist, gibt es Elemente zurück, die für sich selbst 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.