Die Python-Funktion map(function, *iterables) wendet eine Funktion elementweise auf eines oder mehrere Iterables an und liefert einen Lazy-Iterator mit den Ergebnissen. Sie ist eines der drei klassischen funktionalen Werkzeuge — neben filter() und reduce(). Mit mehreren Iterables wird die Funktion mit je einem Element aus jedem aufgerufen, parallel iteriert wie zip().

01 · Abschnitt

Einleitung

map() löst eine sehr häufige Aufgabe: „Wende auf jedes Element diese Transformation an". Klassisch funktional formuliert:

map(f, [a, b, c]) → [f(a), f(b), f(c)]

map() ist lazy: Die Transformationen werden erst bei Bedarf berechnet — bei Iteration oder Materialisierung mit list(). Das macht map() speicher-effizient bei sehr großen oder unendlichen Iterables.

Mit mehreren Iterables wird map() zum „Zip + Apply" in einem Schritt: map(operator.add, [1, 2, 3], [10, 20, 30]) liefert [11, 22, 33]. Sobald das kürzeste Iterable erschöpft ist, endet die Iteration — wie bei zip().

In modernem Python wird map() oft durch List-/Generator-Comprehensions ersetzt, die meist lesbarer sind. map() glänzt vor allem mit vorhandenen, benannten Funktionen (map(int, strings)) — dort ist sie kürzer als [int(s) for s in strings].

02 · Abschnitt

Syntax

Python Syntax 
map(function, iterable)
map(function, iterable1, iterable2, ...)
Parameter
function

Eine Funktion, die so viele Argumente nimmt, wie Iterables übergeben werden.

iterable

Ein oder mehrere Iterables.

03 · Abschnitt

Rückgabewert

Ein map-Iterator. Lazy — wandelt erst bei Iteration oder mit list()/tuple() um.

04 · Abschnitt

Beispiele

Einfache Transformation

Python Beispiel 
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x * x, numbers))
print(squares)
Output 
[1, 4, 9, 16]

Mit benannter Funktion (idiomatisch)

Python Beispiel 
# Strings in int konvertieren — kompakter als Comprehension
raw = ["1", "2", "3", "42"]
numbers = list(map(int, raw))
print(numbers)
Output 
[1, 2, 3, 42]

Mehrere Iterables parallel

Python Beispiel 
from operator import add
a = [1, 2, 3]
b = [10, 20, 30]
sums = list(map(add, a, b))
print(sums)
Output 
[11, 22, 33]

Lazy verhalten

Python Beispiel 
def laut(x):
    print(f"  process {x}")
    return x * 10

m = map(laut, [1, 2, 3])
print("vor next:")
print(next(m))
print("vor weiterer iteration:")
for x in m:
    print(x)
Output 
vor next:
  process 1
10
vor weiterer iteration:
  process 2
20
  process 3
30
05 · Abschnitt

Praktische Beispiele

CSV-Zeilen in Tupel parsen

Python Beispiel 
lines = ["Alice,17", "Bob,24", "Cleo,31"]
records = [(name, int(alter)) for name, alter in (z.split(",") for z in lines)]
print(records)
Output 
[('Alice', 17), ('Bob', 24), ('Cleo', 31)]

Strings normalize

Python Beispiel 
input_value = ["  Alice ", "BOB", "Cleo\n"]
# str.strip ist eine ungebundene Methode → mit map natürlich nutzbar
cleaned = list(map(str.strip, map(str.lower, input_value)))
print(cleaned)
Output 
['alice', 'bob', 'cleo']

map vs. Comprehension

Python Beispiel 
# map: kompakt mit benannter Funktion
numbers = list(map(int, ["1", "2", "3"]))

# Comprehension: lesbarer mit Logik
squares_even = [x * x for x in range(10) if x % 2 == 0]
06 · Abschnitt

Praktische Hinweise

  • list(map(f, xs)) ≈ [f(x) for x in xs] — bei Lambda meist die Comprehension wählen, bei benannter Funktion map().
  • Lazy: map() verbraucht keinen Speicher bis Iteration. Materialisierung via list(), tuple() oder for-Schleife.
  • Mehrere Iterables: stoppt beim kürzesten — wie zip().
  • Verwandte Werkzeuge: filter() (Bedingung), functools.reduce() (Aggregation), itertools.starmap() (für Tupel-Argumente).
/ Weiter

Zurück zu Builtin Functions

Zur Übersicht