Python map()-Funktion: Iterables mit Beispielen transformieren

Name

Soren Atelier

Updated on 10.2.2026

Das Transformieren jedes Elements in einer Liste ist eine der häufigsten Operationen in der Python-Programmierung. Sie haben eine Liste von Strings, die in Ganzzahlen konvertiert werden müssen. Eine Spalte mit Preisen, die gerundet werden müssen. Eine Menge von Dateinamen, die in Kleinbuchstaben umgewandelt werden sollen. Der Instinkt ist, eine for-Schleife zu schreiben, eine leere Liste zu erstellen, jedes Ergebnis anzuhängen und die Liste zurückzugeben. Es funktioniert, aber es ist ausführlich, fehleranfällig und vergräbt die eigentliche Transformationslogik in Standardcode.

Pythons eingebaute map()-Funktion eliminiert diesen Standardcode. Sie nimmt eine Funktion und ein oder mehrere Iterables, wendet die Funktion auf jedes Element an und gibt einen Iterator der Ergebnisse zurück. Eine Zeile ersetzt fünf. Der Code liest sich wie eine Beschreibung dessen, was Sie wollen, nicht wie Sie es tun.

Dieser Leitfaden behandelt jeden praktischen Aspekt der Python map-Funktion: die grundlegende Syntax, die Kombination von map mit Lambda und eingebauten Funktionen, das Arbeiten mit mehreren Iterables, Leistungsvergleiche mit List Comprehensions und praxisnahe Datenverarbeitungsmuster, die Sie in Produktionscode verwenden werden.

Grundlegende Syntax von map()

Die Signatur der map()-Funktion ist unkompliziert:

map(function, iterable, *iterables)

• function -- ein aufrufbares Objekt, das ein Argument akzeptiert (oder mehr, wenn Sie mehrere Iterables übergeben).
• iterable -- die Sequenz, deren Elemente an function übergeben werden.
• *iterables -- optionale zusätzliche Iterables. Wenn angegeben, muss function so viele Argumente akzeptieren.

map() gibt ein map-Objekt zurück, das ein verzögerter Iterator ist. Es berechnet nicht alle Ergebnisse sofort. Stattdessen erzeugt es Werte einzeln, wenn Sie sie verbrauchen.

Hier ist das einfachste mögliche Beispiel:

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
 
print(squared)
# <map object at 0x...>
 
print(list(squared))
# [1, 4, 9, 16, 25]

Das map-Objekt zeigt Ergebnisse nicht direkt an. Sie konvertieren es in eine Liste, ein Tupel oder eine andere Sammlung oder iterieren in einer Schleife darüber.

map() mit eingebauten Funktionen

Eine der saubersten Verwendungen von map() ist die Kombination mit Pythons eingebauten Funktionen. Kein Lambda nötig -- übergeben Sie einfach den Funktionsnamen direkt.

Typkonvertierung mit int, float, str

# Strings in Ganzzahlen konvertieren
string_numbers = ["10", "20", "30", "40"]
integers = list(map(int, string_numbers))
print(integers)
# [10, 20, 30, 40]
 
# Ganzzahlen in Fließkommazahlen konvertieren
values = [1, 2, 3, 4]
floats = list(map(float, values))
print(floats)
# [1.0, 2.0, 3.0, 4.0]
 
# Zahlen in Strings konvertieren
ids = [101, 102, 103]
string_ids = list(map(str, ids))
print(string_ids)
# ['101', '102', '103']

Längen ermitteln mit len

words = ["Python", "map", "function", "tutorial"]
lengths = list(map(len, words))
print(lengths)
# [6, 3, 8, 8]

Leerzeichen entfernen mit str.strip

raw_inputs = ["  hello  ", "  world ", " python  "]
cleaned = list(map(str.strip, raw_inputs))
print(cleaned)
# ['hello', 'world', 'python']

Andere nützliche eingebaute Kombinationen

# abs() für Absolutwerte
numbers = [-5, 3, -1, 7, -2]
absolutes = list(map(abs, numbers))
print(absolutes)
# [5, 3, 1, 7, 2]
 
# round() zum Runden (Einzelargument-Form)
prices = [19.995, 4.123, 99.876]
rounded = list(map(round, prices))
print(rounded)
# [20, 4, 100]
 
# bool() für Wahrheitswerte
values = [0, 1, "", "hello", None, [], [1]]
truthy = list(map(bool, values))
print(truthy)
# [False, True, False, True, False, False, True]

Wenn eine eingebaute Funktion bereits das tut, was Sie brauchen, übergeben Sie sie direkt an map(). Es gibt keinen Grund, sie in ein Lambda zu verpacken.

map() mit Lambda-Funktionen

Lambda-Funktionen erschließen die volle Leistung von map(). Sie ermöglichen es, Inline-Transformationen zu definieren, ohne eine benannte Funktion zu erstellen.

# Jede Zahl quadrieren
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)
# [1, 4, 9, 16, 25]
 
# Celsius in Fahrenheit
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: round(c * 9/5 + 32, 1), celsius))
print(fahrenheit)
# [32.0, 68.0, 98.6, 212.0]
 
# Domain aus E-Mail-Adressen extrahieren
emails = ["alice@gmail.com", "bob@company.org", "carol@university.edu"]
domains = list(map(lambda e: e.split("@")[1], emails))
print(domains)
# ['gmail.com', 'company.org', 'university.edu']
 
# Namen formatieren
names = ["alice smith", "bob jones", "carol white"]
formatted = list(map(lambda n: n.title(), names))
print(formatted)
# ['Alice Smith', 'Bob Jones', 'Carol White']

Das Muster ist konsistent: map(lambda x: transform(x), iterable). Halten Sie den Lambda-Körper auf einen einzigen, klaren Ausdruck. Wenn die Transformation mehrere Schritte erfordert, verwenden Sie stattdessen eine benannte Funktion.

map() mit mehreren Iterables

Wenn Sie mehrere Iterables übergeben, ruft map() die Funktion mit einem Element aus jedem Iterable parallel auf. Die Funktion muss so viele Argumente akzeptieren, wie es Iterables gibt. Die Iteration stoppt, wenn das kürzeste Iterable erschöpft ist.

# Entsprechende Elemente aus zwei Listen addieren
list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]
sums = list(map(lambda a, b: a + b, list_a, list_b))
print(sums)
# [11, 22, 33, 44]
 
# Gewichtete Punktzahlen berechnen
scores = [85, 92, 78, 95]
weights = [0.3, 0.3, 0.2, 0.2]
weighted = list(map(lambda s, w: round(s * w, 1), scores, weights))
print(weighted)
# [25.5, 27.6, 15.6, 19.0]
 
# Vor- und Nachnamen kombinieren
first_names = ["Ada", "Grace", "Alan"]
last_names = ["Lovelace", "Hopper", "Turing"]
full_names = list(map(lambda f, l: f"{f} {l}", first_names, last_names))
print(full_names)
# ['Ada Lovelace', 'Grace Hopper', 'Alan Turing']

Drei oder mehr Iterables

# Volumen aus drei Dimensionslisten berechnen
lengths = [2, 3, 4]
widths = [5, 6, 7]
heights = [8, 9, 10]
 
volumes = list(map(lambda l, w, h: l * w * h, lengths, widths, heights))
print(volumes)
# [80, 162, 280]

Umgang mit ungleichen Längen

map() stoppt beim kürzesten Iterable. Kein Fehler, kein Auffüllen -- es stoppt einfach:

a = [1, 2, 3, 4, 5]
b = [10, 20, 30]
result = list(map(lambda x, y: x + y, a, b))
print(result)
# [11, 22, 33]
# Elemente 4 und 5 aus 'a' werden stillschweigend ignoriert

Wenn Sie ungleiche Längen explizit behandeln müssen, verwenden Sie itertools.zip_longest:

from itertools import zip_longest
 
a = [1, 2, 3, 4, 5]
b = [10, 20, 30]
result = list(map(lambda pair: pair[0] + (pair[1] or 0), zip_longest(a, b, fillvalue=0)))
print(result)
# [11, 22, 33, 4, 5]

map() vs List Comprehension

Dies ist der wichtigste Vergleich. Sowohl map() als auch List Comprehensions transformieren Sequenzen, haben aber unterschiedliche Stärken.

Leistungsbenchmark

import timeit
 
data = list(range(100_000))
 
# map mit eingebauter Funktion
time_map_builtin = timeit.timeit(
    'list(map(str, data))',
    globals={'data': data},
    number=100
)
 
# List Comprehension mit eingebauter Funktion
time_comp_builtin = timeit.timeit(
    '[str(x) for x in data]',
    globals={'data': data},
    number=100
)
 
# map mit Lambda
time_map_lambda = timeit.timeit(
    'list(map(lambda x: x * 2, data))',
    globals={'data': data},
    number=100
)
 
# List Comprehension Äquivalent
time_comp_expr = timeit.timeit(
    '[x * 2 for x in data]',
    globals={'data': data},
    number=100
)
 
print(f"map + eingebaut:    {time_map_builtin:.4f}s")
print(f"Comprehension:      {time_comp_builtin:.4f}s")
print(f"map + Lambda:       {time_map_lambda:.4f}s")
print(f"Comprehension:      {time_comp_expr:.4f}s")
# Typische Ergebnisse:
# map + eingebaut:    ~0.85s (schneller)
# Comprehension:      ~1.05s
# map + Lambda:       ~0.95s
# Comprehension:      ~0.80s (schneller)

Die wichtigste Erkenntnis: map() mit einer eingebauten Funktion (wie int, str, float) ist schneller, da es vermeidet, bei jeder Iteration einen Python-Level-Funktionsaufruf zu erstellen. Aber map() mit einem Lambda ist ungefähr gleich schnell wie -- oder etwas langsamer als -- eine List Comprehension, da beide einen Python-Level-Funktionsaufruf pro Element beinhalten.

map() vs Generator-Ausdruck

Wenn Sie nicht die vollständige Ergebnisliste im Speicher benötigen, bieten sowohl map() als auch Generator-Ausdrücke verzögerte Auswertung:

# map-Objekt - verzögert
mapped = map(lambda x: x ** 2, range(1_000_000))
 
# Generator-Ausdruck - verzögert
generated = (x ** 2 for x in range(1_000_000))
 
# Beide verbrauchen Speicher nur bei der Iteration
for value in mapped:
    if value > 100:
        break

Der Unterschied ist stilistisch. Generator-Ausdrücke lesen sich für die meisten Python-Entwickler natürlicher und unterstützen das Filtern mit if-Klauseln. Verwenden Sie map(), wenn Sie bereits eine benannte Funktion zum Anwenden haben; verwenden Sie ansonsten einen Generator-Ausdruck.

# map ist sauber, wenn Sie eine benannte Funktion haben
import math
roots = map(math.sqrt, range(10))
 
# Generator ist sauber für Ausdrücke
roots = (x ** 0.5 for x in range(10))

map-Objekte in list, tuple und set konvertieren

Das map-Objekt ist ein Iterator. Um die Ergebnisse zu materialisieren, konvertieren Sie es explizit:

numbers = [1, 2, 3, 2, 4, 3, 5]
 
# Zu Liste (behält Reihenfolge, erlaubt Duplikate)
as_list = list(map(lambda x: x * 10, numbers))
print(as_list)
# [10, 20, 30, 20, 40, 30, 50]
 
# Zu Tupel (unveränderliche Sequenz)
as_tuple = tuple(map(lambda x: x * 10, numbers))
print(as_tuple)
# (10, 20, 30, 20, 40, 30, 50)
 
# Zu Set (entfernt Duplikate, ungeordnet)
as_set = set(map(lambda x: x * 10, numbers))
print(as_set)
# {10, 20, 30, 40, 50}

Wichtig: Ein map-Objekt kann nur einmal verbraucht werden. Nachdem Sie es in eine Liste konvertiert haben, ergibt erneutes Iterieren nichts:

mapped = map(str, [1, 2, 3])
first = list(mapped)
second = list(mapped)
print(first)   # ['1', '2', '3']
print(second)  # [] -- bereits erschöpft

map() mit benutzerdefinierten Funktionen

Für Transformationen, die zu komplex für ein Lambda sind, definieren Sie eine reguläre Funktion und übergeben Sie sie an map():

def parse_temperature(reading):
    """Konvertiert einen Temperatur-Lese-String in ein standardisiertes Dict."""
    value, unit = float(reading[:-1]), reading[-1]
    if unit == 'F':
        celsius = round((value - 32) * 5 / 9, 1)
    elif unit == 'C':
        celsius = value
    elif unit == 'K':
        celsius = round(value - 273.15, 1)
    else:
        raise ValueError(f"Unbekannte Einheit: {unit}")
    return {"original": reading, "celsius": celsius}
 
readings = ["98.6F", "37.0C", "310.0K", "72.0F"]
parsed = list(map(parse_temperature, readings))
 
for entry in parsed:
    print(f"{entry['original']} -> {entry['celsius']}°C")
# 98.6F -> 37.0°C
# 37.0C -> 37.0°C
# 310.0K -> 36.9°C
# 72.0F -> 22.2°C

Dieses Muster hält map()-Aufrufe sauber und verlagert komplexe Logik in testbare, dokumentierte Funktionen.

def normalize_record(record):
    """Standardisiert einen Benutzerdatensatz für die Datenbank-Einfügung."""
    return {
        "name": record["name"].strip().title(),
        "email": record["email"].strip().lower(),
        "age": int(record["age"]),
        "active": record.get("active", True),
    }
 
raw_records = [
    {"name": "  alice smith ", "email": "ALICE@Email.COM", "age": "30"},
    {"name": "bob jones", "email": "Bob@Work.ORG  ", "age": "25"},
]
 
clean_records = list(map(normalize_record, raw_records))
for r in clean_records:
    print(r)
# {'name': 'Alice Smith', 'email': 'alice@email.com', 'age': 30, 'active': True}
# {'name': 'Bob Jones', 'email': 'bob@work.org', 'age': 25, 'active': True}

map()-Aufrufe verketten

Da map() einen Iterator zurückgibt, können Sie mehrere map()-Aufrufe verketten, um Transformations-Pipelines aufzubauen. Jeder Schritt verarbeitet ein Element gleichzeitig, ohne Zwischenlisten zu erstellen:

raw_data = ["  42  ", " 17 ", "  89  ", " 3  "]
 
# Verkettung: Leerzeichen entfernen -> in int konvertieren -> Wert verdoppeln
result = map(str.strip, raw_data)
result = map(int, result)
result = map(lambda x: x * 2, result)
 
print(list(result))
# [84, 34, 178, 6]

Für bessere Lesbarkeit können Sie die Aufrufe verschachteln (von innen nach außen lesen):

raw_data = ["  42  ", " 17 ", "  89  ", " 3  "]
 
result = list(map(lambda x: x * 2, map(int, map(str.strip, raw_data))))
print(result)
# [84, 34, 178, 6]

Die verschachtelte Version ist kompakt, aber schwerer zu lesen. Die sequenzielle Version ist klarer für mehrstufige Pipelines. Keine der beiden erstellt Zwischenlisten -- alle drei map-Objekte werden verzögert ausgewertet.

map() in Datenverarbeitungs-Pipelines

Reale Datenverarbeitung umfasst oft das Lesen, Bereinigen, Transformieren und Aggregieren von Daten. map() passt natürlich in dieses Muster.

Log-Einträge verarbeiten

log_lines = [
    "2026-02-10 INFO User logged in",
    "2026-02-10 ERROR Database timeout",
    "2026-02-10 WARNING Disk space low",
    "2026-02-10 INFO File uploaded",
]
 
def parse_log(line):
    parts = line.split(" ", 2)
    return {"date": parts[0], "level": parts[1], "message": parts[2]}
 
parsed = list(map(parse_log, log_lines))
errors = list(filter(lambda entry: entry["level"] == "ERROR", parsed))
print(errors)
# [{'date': '2026-02-10', 'level': 'ERROR', 'message': 'Database timeout'}]

Stapel-Dateiumbenennungslogik

import os
 
filenames = ["Report Q1.PDF", "data export.CSV", "NOTES 2026.TXT"]
 
def sanitize_filename(name):
    base, ext = os.path.splitext(name)
    return base.strip().lower().replace(" ", "_") + ext.lower()
 
cleaned = list(map(sanitize_filename, filenames))
print(cleaned)
# ['report_q1.pdf', 'data_export.csv', 'notes_2026.txt']

Numerische Daten-Pipeline

import math
 
raw_measurements = ["3.14159", "2.71828", "1.41421", "1.73205"]
 
# Pipeline: parsen -> quadrieren -> Logarithmus nehmen -> auf 3 Dezimalstellen runden
pipeline = map(lambda x: round(x, 3),
           map(math.log,
           map(lambda x: x ** 2,
           map(float, raw_measurements))))
 
print(list(pipeline))
# [2.292, 2.003, 0.693, 1.099]

Wann map() vs List Comprehension verwenden: Ein Entscheidungsleitfaden

Verwenden Sie diese Kurzreferenz, um zu entscheiden, welches Werkzeug zu Ihrer Situation passt:

Verwenden Sie map() wenn:

• Sie eine einzelne eingebaute Funktion anwenden: map(int, strings), map(str.strip, lines)
• Sie bereits eine benannte Funktion haben, die die Transformation durchführt
• Sie verzögerte Auswertung wollen und nicht die vollständige Liste im Speicher benötigen
• Sie mehrere Iterables für elementweise Operationen übergeben

Verwenden Sie eine List Comprehension wenn:

• Die Transformation ein einfacher Ausdruck ist: [x * 2 for x in numbers]
• Sie im selben Schritt filtern müssen: [x for x in items if x > 0]
• Die Logik mehrere Bedingungen oder verschachtelte Operationen beinhaltet
• Sie das Ergebnis sofort als Liste wollen
• Lesbarkeit wichtiger ist als Mikro-Optimierung

Verwenden Sie einen Generator-Ausdruck wenn:

• Sie verzögerte Auswertung benötigen, aber die Lesbarkeit der Comprehension-Syntax wollen
• Das Ergebnis nur einmal verbraucht wird (übergeben an sum(), max(), join(), etc.)

# map -- am saubersten für Typkonvertierung
integers = list(map(int, ["1", "2", "3"]))
 
# List Comprehension -- am saubersten für Transformation + Filter
even_squares = [x ** 2 for x in range(20) if x % 2 == 0]
 
# Generator-Ausdruck -- am saubersten für einmaligen Verbrauch
total = sum(x ** 2 for x in range(1000))

Mit map() in RunCell experimentieren

Wenn Sie Datentransformations-Pipelines mit map() aufbauen, ist das interaktive Testen jeder Stufe essenziell. Sie müssen Zwischenergebnisse sehen, Grenzfälle prüfen und verifizieren, dass verkettete Maps die erwartete Ausgabe produzieren.

RunCell (opens in a new tab) ist ein KI-Agent, der direkt in Jupyter-Notebooks läuft. Er versteht Ihren Notebook-Kontext -- die Variablen, DataFrames und Imports, die bereits im Speicher sind -- und hilft Ihnen, map()-Pipelines Schritt für Schritt aufzubauen und zu debuggen:

• Zwischenergebnisse visualisieren. Bitten Sie RunCell zu zeigen, was jede Stufe eines verketteten map() produziert, ohne Ihre Pipeline zu unterbrechen.
• Vektorisierte Alternativen vorschlagen. Wenn Sie map() auf pandas Series verwenden, kann RunCell native pandas-Operationen empfehlen, die 10-100x schneller laufen.
• Zwischen map und Comprehension konvertieren. Beschreiben Sie die Transformation und RunCell generiert beide Versionen, damit Sie die lesbarere wählen können.
• Grenzfälle debuggen. Füttern Sie unerwartete Eingaben (None-Werte, leere Strings, gemischte Typen) in Ihre map-Pipeline und sehen Sie genau, wo sie bricht.

FAQ

Was macht die map()-Funktion in Python?

Die map()-Funktion wendet eine gegebene Funktion auf jedes Element in einem oder mehreren Iterables (wie Listen, Tupel oder Strings) an und gibt einen Iterator der Ergebnisse zurück. Es ist eine eingebaute Funktion, die funktionalen Stil der Datentransformation ermöglicht, ohne explizite Schleifen zu schreiben. Die Syntax ist map(function, iterable), und das zurückgegebene map-Objekt ist verzögert -- es berechnet Ergebnisse bei Bedarf statt alle auf einmal.

Ist map() schneller als eine for-Schleife in Python?

Ja, map() ist im Allgemeinen schneller als eine äquivalente for-Schleife, die eine Liste mit append() aufbaut. Der Geschwindigkeitsvorteil kommt daher, dass map() auf Interpreter-Ebene in C implementiert ist, was den Overhead der Python-Level-Schleifeniteration und Methodenaufrufe vermeidet. Wenn Sie map() mit einer eingebauten Funktion wie int oder str verwenden, ist der Leistungsgewinn am deutlichsten -- typischerweise 20-40% schneller. Mit einem Lambda verringert sich der Unterschied, da das Lambda selbst einen Python-Level-Funktionsaufruf einführt.

Wie konvertiere ich ein map-Objekt in eine Liste?

Umschließen Sie den map()-Aufruf mit list(): result = list(map(int, strings)). Sie können auch in andere Sammlungen konvertieren: tuple(map(...)) für Tupel, set(map(...)) für Sets. Denken Sie daran, dass ein map-Objekt ein Einmal-Iterator ist. Einmal verbraucht (durch Konvertierung in eine Liste oder Durchlaufen), ist es erschöpft und kann nicht wiederverwendet werden.

Kann map() mit mehreren Listen arbeiten?

Ja. Übergeben Sie mehrere Iterables nach der Funktion: map(func, list1, list2, list3). Die Funktion muss so viele Argumente akzeptieren, wie es Iterables gibt. Zum Beispiel gibt list(map(lambda a, b: a + b, [1, 2], [10, 20])) [11, 22] zurück. Die Iteration stoppt beim kürzesten Iterable, sodass Listen ungleicher Länge keine Fehler auslösen -- zusätzliche Elemente werden stillschweigend ignoriert.

Sollte ich map() oder eine List Comprehension verwenden?

Verwenden Sie map(), wenn Sie eine einzelne existierende Funktion (eingebaut oder benannt) auf ein Iterable anwenden, besonders für Typkonvertierungen wie map(int, strings). Verwenden Sie eine List Comprehension, wenn die Transformation einen Ausdruck beinhaltet, wenn Sie mit einer if-Klausel filtern müssen oder wenn Lesbarkeit Priorität hat. In modernem Python sind List Comprehensions die Standardwahl für die meisten Entwickler, aber map() mit eingebauten Funktionen bleibt schneller und prägnanter für einfache Ein-Funktions-Transformationen.

Fazit

Die Python map()-Funktion ist ein präzises Werkzeug für eine bestimmte Aufgabe: eine einzelne Funktion auf jedes Element eines Iterables anzuwenden, ohne eine Schleife zu schreiben. Sie glänzt in Kombination mit eingebauten Funktionen wie int, str, float und len, wo sie den lesbarsten und schnellsten Code produziert. Mit Lambda-Funktionen behandelt sie Inline-Transformationen sauber. Mit mehreren Iterables verarbeitet sie elementweise Operationen, die sonst zip() und eine Schleife erfordern würden.

Hier sind die Regeln für die effektive Nutzung von map():

• Übergeben Sie eingebaute Funktionen direkt: map(int, strings) nicht map(lambda x: int(x), strings).
• Verwenden Sie Lambda nur für einfache Transformationen mit einem einzigen Ausdruck.
• Wechseln Sie zu einer benannten Funktion, wenn die Transformation Fehlerbehandlung, mehrere Schritte oder Dokumentation benötigt.
• Bevorzugen Sie List Comprehensions, wenn Sie filtern müssen oder wenn der Ausdruck inline klarer ist.
• Denken Sie daran, dass map() einen verzögerten, einmalig verwendbaren Iterator zurückgibt -- konvertieren Sie in list(), wenn Sie Ergebnisse wiederverwenden oder inspizieren müssen.
• Verketten Sie map()-Aufrufe für mehrstufige Pipelines ohne Zwischenlisten zu erstellen.

map() ist kein Ersatz für List Comprehensions, und List Comprehensions sind kein Ersatz für map(). Sie überschneiden sich, dienen aber unterschiedlichen Stärken. Der beste Python-Code verwendet jedes dort, wo es natürlich passt: map() zum Anwenden existierender Funktionen, List Comprehensions für Ausdrücke und Filterung und Generator-Ausdrücke für verzögerten einmaligen Verbrauch.