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 Wörterbuch) 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 an die Funktion list() oder einen anderen Sequenztyp übergeben, um ein Iterable zu erstellen.

Die Syntax der Funktion map() ist wie folgt:

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

Anstelle einer for-Schleife bietet die Funktion map() eine Möglichkeit, eine Funktion auf jedes Element in einem Iterable anzuwenden. Daher kann sie oft leistungsfähiger sein, da sie die Funktion nur auf ein Element gleichzeitig anwendet, 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 zur Arbeit mit map() überprüfen: mit einer lambda-Funktion, mit einer benutzerdefinierten Funktion und schließlich mit einer integrierten 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 an map() übergeben, und gibt das manipulierte Element in einem Map-Objekt 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 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 gegen 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:

print(mapped_numbers)

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

Wir haben list() verwendet, damit das Map-Objekt als Liste 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 könnten oder wir können list() verwenden, um es in eine Liste zu verwandeln. Wir tun dies hier, weil es eine gute Möglichkeit ist, die Ergebnisse zu überprüfen.

Letzten Endes 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() darauf anwenden.

Für kleinere Datensätze sind List Comprehensions möglicherweise geeigneter, 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 Funktion verwenden, die wir definiert haben, um sie auf ein Iterable anzuwenden. Während lambda-Funktionen nützlicher sind, wenn man mit einem einzeiligen Ausdruck arbeitet, sind benutzerdefinierte Funktionen geeigneter, wenn der Ausdruck an Komplexität zunimmt. Darüber hinaus können benutzerdefinierte Funktionen eine bessere Wahl für die Lesbarkeit sein, wenn wir ein weiteres Stück Daten an die Funktion übergeben müssen, die wir auf unser Iterable anwenden.

Zum Beispiel enthält in dem folgenden Iterable jedes Element ein Wörterbuch, das verschiedene Details über unsere Aquarienbewohner 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 Aquarienkreaturen tatsächlich in dasselbe Becken ziehen werden. Wir müssen unsere Aufzeichnungen aktualisieren, um widerzuspiegeln, 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, konstruieren 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 assign_to_tank()-Funktion, die aquarium_creatures und new_tank_number als Parameter entgegennimmt. In assign_to_tank() übergeben wir apply() als die Funktion an map() in der letzten Zeile. Die assign_to_tank-Funktion wird den Iterator zurückgeben, 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 Schlüssel "tank number" aus aquarium_creatures ist und dass er die übergebene new_tank_number speichern soll. Wir geben jedes Element zurück, nachdem wir die neue Beckennummer angewendet haben.

Wir rufen assign_to_tank() mit unserer Liste von Wörterbüchern und der neuen Beckennummer 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, das wir in eine Liste umwandeln und ausdrucken:

print(list(assigned_tanks))

Wir erhalten die folgende Ausgabe von diesem Programm:

Output
[{'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 Beckennummer auf unsere Liste von Wörterbüchern abgebildet. 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 Iterables

Auf die gleiche Weise wie bei lambda-Funktionen oder unseren eigenen definierten Funktionen können wir Python integrierte Funktionen mit map() verwenden. Um eine Funktion auf mehrere Iterables anzuwenden, geben wir einen weiteren Iterable-Namen nach dem ersten an. Zum Beispiel die Verwendung der pow()-Funktion, die zwei Zahlen annimmt, um die Potenz der Basiszahl zum angegebenen Exponenten zu finden.

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]

Dann geben wir pow() als unsere Funktion in map() ein und geben die beiden Listen als unsere Iterables an:

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

print(numbers_powers)

map() wendet die pow()-Funktion auf dasselbe Element in jeder Liste an, um die Potenz zu liefern. Daher zeigen unsere Ergebnisse 2**1, 4**2, 6**3 usw.:

Output
[2, 16, 216, 4096, 100000]

Wenn wir map() mit einem Iterable versehen würden, das länger ist als das andere, würde map() aufhören zu berechnen, sobald es das Ende des kürzesten Iterables erreicht. 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)

Als Ergebnis wird sich innerhalb der Berechnung dieses Programms nichts ändern, und es wird weiterhin das gleiche Ergebnis liefern:

Output
[2, 16, 216, 4096, 100000]

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

Fazit

In diesem Tutorial haben wir verschiedene Methoden zur Nutzung der map()-Funktion in Python erkundet. Sie haben nun 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 ihre 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 manipuliert werden, um spezifischen Bedürfnissen 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.
• Das Verständnis von Wörterbüchern in Python, um Ihr Wissen über Python-Datenstrukturen zu erweitern.
• Python-String-Funktionen, um verschiedene Techniken zur String-Manipulation zu erkunden.

Diese Ressourcen bieten Ihnen ein umfassendes Verständnis der Möglichkeiten von Python und wie Sie sie effektiv in Ihren Projekten nutzen können.

Wenn Sie mehr über Python lernen möchten, schauen Sie sich unsere How To Code in Python-Serie 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 filter()-Funktion.

Häufig gestellte Fragen

Was macht map() in Python?

Die Funktion map() in Python nimmt eine Funktion und ein oder mehrere Iterables entgegen und gibt einen Iterator zurück, der die angegebene Funktion auf jedes Element der bereitgestellten Iterables anwendet. Mit anderen Worten, sie „mapped“ die Funktion über jedes Element im Iterable. Zum Beispiel:

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

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

Wie erstellt man eine Map in Python?

Man erstellt ein Map-Objekt, indem man die integrierte Funktion map() mit einer Funktion und mindestens einem Iterable als Argument aufruft. Zum Beispiel:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Erstellt ein Map-Objekt

Man kann dann über das gemappte Objekt iterieren oder es in eine Liste umwandeln, um die Ergebnisse zu sehen:

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

Ist map in Python „lazy“?

Ja, in Python 3 gibt map() einen lazy Iterator zurück, was bedeutet, dass es nicht alle Ergebnisse auf einmal verarbeitet oder speichert. Stattdessen berechnet es jedes Ergebnis bei Bedarf, während man darüber iteriert. Dies kann besonders speichereffizient sein, insbesondere für große Datenmengen, bedeutet aber auch, dass man nicht direkt auf ein bestimmtes Element zugreifen oder wiederholt über dasselbe Map-Objekt iterieren kann, ohne es neu zu konstruieren.

Wie funktioniert die map()-Funktion?

Die map()-Funktion funktioniert wie folgt:

1. Sie geben eine Funktion und ein oder mehrere Iterables an.
2. map() ruft ein Element von jedem Iterable ab.
3. Es ruft die Funktion mit diesen Elementen als Argumente auf.
4. Es gibt das Ergebnis dieses Funktionsaufrufs zurück.
5. 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 persönlichen Vorlieben und Lesbarkeit ab:

Pros:

• Es kann in einigen Fällen prägnanter sein.
• Es kann in bestimmten Szenarien etwas schneller sein als List Comprehensions (obwohl oft nicht signifikant).

Cons:

• Code, der List Comprehensions oder Generatorausdrücke verwendet, wird oft als „Pythonic“ und leichter lesbar angesehen.
• Neuere Python-Programmierer finden Listenverständnisse intuitiver.

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

Wie konvertiert man in Python map 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 zuerst darüber iterieren. Übliche Ansätze sind:

• Konvertierung in eine Liste und dann in eine Stringdarstellung:

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

• Verknüpfen der Ergebnisse, wenn es sich um Stringelemente handelt:

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(...)) möchten.

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, weil 2*2=4 zweimal erscheint

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 dem Iterable zurück, für die function(element) wahr ist. Wenn die Funktion None ist, gibt sie Elemente zurück, 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 wandelt jedes Element um, während filter bestimmte Elemente basierend auf einer Bedingung auswählt.