list()

Einleitung

Listen sind in Python die Allzweck-Container — geordnet, indexierbar (a[0]), veränderbar (a.append(x)), und sie können Werte beliebigen Typs gemischt enthalten. Intern sind sie als dynamische Arrays implementiert; Anhängen am Ende ist amortisiert O(1), Einfügen am Anfang dagegen O(n).

list() wird hauptsächlich genutzt, um:

1. Iterables zu materialisieren — Generatoren, map-/filter-Ergebnisse, dict.keys() usw. werden zu echten Listen mit Indexzugriff.
2. Strings in Zeichen zu zerlegen — list("Hallo") liefert ['H', 'a', 'l', 'l', 'o'].
3. Eine Kopie eines Iterables zu erzeugen — list(other) ist eine Shallow-Copy.

Die Literal-Syntax [] ist schneller und idiomatisch, wenn die Elemente zur Schreibzeit feststehen. list() bevorzugt man, wenn die Quelle ein Iterable ist.

Syntax

list()         # leere Liste
list(iterable) # Liste aus Iterable

Rückgabewert

Eine neue list-Instanz mit allen Elementen des Iterables in der Iterations-Reihenfolge.

Beispiele

Aus verschiedenen Quellen

print(list())                     # leer
print(list("Hallo"))               # String → Zeichen
print(list((1, 2, 3)))             # Tupel → Liste
print(list({"a": 1, "b": 2}))      # Dict → Keys
print(list({3, 1, 2}))             # Set → Liste (Reihenfolge nicht garantiert)
print(list(range(5)))               # Range → Liste

[]
['H', 'a', 'l', 'l', 'o']
[1, 2, 3]
['a', 'b']
[1, 2, 3]
[0, 1, 2, 3, 4]

Generator materialisieren

# map und filter geben Iteratoren back — list() macht sie sichtbar
doubled = list(map(lambda x: x * 2, [1, 2, 3]))
even = list(filter(lambda x: x % 2 == 0, range(10)))
print(doubled)
print(even)

[2, 4, 6]
[0, 2, 4, 6, 8]

Shallow-Copy

original = [1, 2, [3, 4]]
copy = list(original)
copy[0] = 99
copy[2].append(5)   # Achtung: nested list ist geteilt!
print(original)
print(copy)

[1, 2, [3, 4, 5]]
[99, 2, [3, 4, 5]]

Praktische Beispiele

Dict-Items als Listen-Tupel

config = {"host": "localhost", "port": 8080, "ssl": False}
entries = list(config.items())
for pair in entries[:2]:
    print(pair)

('host', 'localhost')
('port', 8080)

List vs. List-Comprehension

# list(map/filter) — funktional, oft kürzer:
squares = list(map(lambda x: x * x, range(5)))

# List-Comprehension — meist lesbarer und schneller:
squares = [x * x for x in range(5)]

Liste mit n Default-Werten

# Mit Multiplikation (Achtung bei mutables!):
zeros = [0] * 5
print(zeros)

# Bei mutables IMMER Comprehension nutzen:
matrix = [[0] * 3 for _ in range(2)]   # 2×3 Matrix
matrix[0][0] = 99
print(matrix)

[0, 0, 0, 0, 0]
[[99, 0, 0], [0, 0, 0]]

Praktische Hinweise

• [] bevorzugen, wenn Elemente bekannt — list() für Konvertierung von Iterables.
• Shallow Copy: list(other) kopiert die Liste, nicht die enthaltenen Objekte. Für tiefe Kopien copy.deepcopy().
• Mutables *-Multiplikation falle: [[]] * 3 erzeugt drei Referenzen auf dieselbe Liste. Stattdessen Comprehension nutzen.
• Performance: list.append(x) ist amortisiert O(1); list.insert(0, x) ist O(n) — für Front-Push lieber collections.deque nutzen.
• Verwandte Typen: tuple (immutable), set (eindeutig, ungeordnet), dict (Key-Value), array.array (typsiert).