Når list comprehensions klikker for dig, vil du aldrig mere skrive en for-løkke, der tilføjer til en liste.
De er ikke blot syntaktisk sukker — de signalerer hensigt klart og kører hurtigere end den tilsvarende løkke i CPython
takket være bytecode-optimering. Ifølge
den officielle Python-tutorial,
giver comprehensions en kortfattet måde at oprette lister baseret på eksisterende sekvenser eller andre iterables.
Denne artikel opbygger den mentale model først, og dækker derefter hvert reelt mønster: filtrering, nesting,
dict- og set-comprehensions, og det ene tilfælde, hvor du bør bruge en simpel for-løkke i stedet.
Det grundlæggende mønster
Anatomien af en list comprehension er [udtryk for element i iterable].
Tre dele: outputudtrykket (hvad hvert element bliver), løkkevariablen
og iterablen at trække fra. Start med en velkendt løkke og fold den ned.
# Plain for loop — building a list of file sizes in KB
file_sizes_bytes = [1024, 204800, 51200, 3145728, 8192]
sizes_kb = []
for size in file_sizes_bytes:
sizes_kb.append(size / 1024)
# print(sizes_kb) → [1.0, 200.0, 50.0, 3072.0, 8.0]
# Same result as a list comprehension — one line, same meaning
sizes_kb = [size / 1024 for size in file_sizes_bytes]Comprehensionen læses næsten som dansk: "giv mig size / 1024 for hvert size
i file_sizes_bytes." Den klarhed er den reelle gevinst — en læser behøver ikke spore et
append-kald for at forstå, hvad du bygger.
# Another common pattern: deriving one list from another
usernames = ["alice", "bob", "carol"]
# Build a list of display names
display_names = [name.capitalize() for name in usernames]
# ['Alice', 'Bob', 'Carol']
# Or extract a single field from a list of dicts
users = [
{"id": 1, "name": "Alice", "role": "admin"},
{"id": 2, "name": "Bob", "role": "viewer"},
{"id": 3, "name": "Carol", "role": "editor"},
]
names = [user["name"] for user in users]
# ['Alice', 'Bob', 'Carol']Filtrering med if
Tilføj en betingelse til sidst, og kun elementer, der passerer, kommer med i outputlisten:
[udtryk for element i iterable if betingelse].
Dette er det mønster, der erstatter en for + if + append-kombination.
# Loop version — extract only active users
active_users = []
for user in users:
if user["active"]:
active_users.append(user["name"])
# Comprehension version — identical result
users = [
{"name": "Alice", "active": True},
{"name": "Bob", "active": False},
{"name": "Carol", "active": True},
{"name": "Dave", "active": False},
]
active_users = [user["name"] for user in users if user["active"]]
# ['Alice', 'Carol']# Filtering a raw CSV row — drop blanks and whitespace-only values
raw_row = ["[email protected]", "", " ", "editor", " "]
clean_row = [field.strip() for field in raw_row if field.strip()]
# ['[email protected]', 'editor']
# Filtering a list of log levels
log_lines = [
"INFO server started",
"DEBUG loading config",
"ERROR database timeout",
"DEBUG query took 450ms",
"ERROR disk space low",
]
errors = [line for line in log_lines if line.startswith("ERROR")]
# ['ERROR database timeout', 'ERROR disk space low']Arbejde med strenge
Strengbehandling er der, hvor comprehensions virkelig beviser deres værdi. Kombinationen af Pythons rige strengmetoder og comprehension-syntaks holder transformationspipelines læsbare uden mellemliggende variabler.
# Strip whitespace from tags coming out of a form field
raw_tags = [" python ", "data science", " machine-learning ", "API"]
tags = [tag.strip().lower() for tag in raw_tags]
# ['python', 'data science', 'machine-learning', 'api']
# Normalise email addresses from a signup CSV
raw_emails = ["[email protected]", " [email protected] ", "[email protected]"]
emails = [e.strip().lower() for e in raw_emails]
# ['[email protected]', '[email protected]', '[email protected]']
# Extract file extensions from a list of uploaded filenames
filenames = ["report.pdf", "avatar.PNG", "data.CSV", "archive.tar.gz", "notes.txt"]
extensions = [name.rsplit(".", 1)[-1].lower() for name in filenames if "." in name]
# ['pdf', 'png', 'csv', 'gz', 'txt']" [email protected] " bestå et .lower()-tjek på indholdet, men stadig have
foranstående mellemrum, der vil ødelægge et databaseopslag eller JSON-nøgleopslag.Dict- og set-comprehensions
Den samme idé udvides til dicts og sets. En
dict-comprehension
bruger krøllede parenteser med et nøgle: værdi-par: {nøgle: værdi for element i iterable}.
En set-comprehension dropper kolon og producerer en deduplikeret samling:
{udtryk for element i iterable}.
# Invert a dict — swap keys and values
permissions = {"alice": "admin", "bob": "viewer", "carol": "editor"}
by_role = {role: name for name, role in permissions.items()}
# {'admin': 'alice', 'viewer': 'bob', 'editor': 'carol'}
# Build a fast lookup dict from a list of user records
users = [
{"id": 101, "name": "Alice", "active": True},
{"id": 102, "name": "Bob", "active": False},
{"id": 103, "name": "Carol", "active": True},
]
# O(1) lookups by ID — much faster than scanning the list every time
user_by_id = {user["id"]: user for user in users}
# {101: {...}, 102: {...}, 103: {...}}
# Access a user directly
user_by_id[102]["name"] # 'Bob'# Set comprehension — deduplicate a list of file extensions
uploads = ["report.pdf", "data.csv", "summary.pdf", "export.CSV", "notes.txt"]
unique_extensions = {name.rsplit(".", 1)[-1].lower() for name in uploads if "." in name}
# {'pdf', 'csv', 'txt'} — order not guaranteedEn advarsel med sets: rækkefølge er ikke bevaret. Hvis du har brug for at deduplikere en liste, mens
du bevarer den oprindelige rækkefølge, er en set-comprehension det forkerte værktøj — brug
list(dict.fromkeys(items)) i stedet, som udnytter den indsættelsesordenede adfærd af
dicts i Python 3.7+.
Nestede comprehensions
Du kan neste comprehensions for at iterere over nestede strukturer. Den mest almindelige brugscase er at fladgøre en liste af lister — en matrix fra en CSV-parsing, sideopdelte API-svarsider eller grupperede forespørgselsresultater.
# Flatten a 2D list (e.g. paginated API results)
pages = [
[{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}],
[{"id": 3, "name": "Carol"}],
[{"id": 4, "name": "Dave"}, {"id": 5, "name": "Eve"}],
]
all_users = [user for page in pages for user in page]
# [{'id': 1, ...}, {'id': 2, ...}, {'id': 3, ...}, {'id': 4, ...}, {'id': 5, ...}]
# The order mirrors what nested for loops would produce:
# for page in pages:
# for user in page:
# all_users.append(user)Læs nestede comprehensions fra venstre til højre — den ydre løkke kommer først, den indre løkke anden.
Det matcher rækkefølgen af nestede for-løkker.
# Two levels — fine and readable
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [cell for row in matrix for cell in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
# Three levels — stop here. Use a plain loop or a helper function.
# This is the point where readability dies:
cube = [[[1,2],[3,4]],[[5,6],[7,8]]]
# Don't do this:
flat3 = [val for layer in cube for row in layer for val in row]
# Do this instead:
flat3 = []
for layer in cube:
for row in layer:
flat3.extend(row)(user["id"] for user in users). De evaluerer dovent — elementer produceres ét ad gangen
i stedet for at bygge den fulde liste i hukommelsen. Brug dem, når du kun behøver at iterere én gang, eller når du
sender resultatet direkte til sum(), max(), any() eller lignende funktioner.
Se generator-udtryksreferencen for de fulde detaljer.if/else-ternary inde i en comprehension
Når du har brug for at transformere elementer til en af to værdier — i stedet for at droppe dem — brug et ternart udtryk i outputpositionen. Positionen er vigtig: ternaren hører hjemme i starten, ikke efter iterablen.
# Correct: ternary is the output expression
users = [
{"name": "Alice", "active": True},
{"name": "Bob", "active": False},
{"name": "Carol", "active": True},
]
status = ["active" if user["active"] else "inactive" for user in users]
# ['active', 'inactive', 'active']
# Normalise a config value — replace None with a default
raw_config = ["/var/log", None, "/tmp", None, "/etc/app"]
paths = [path if path is not None else "/var/log/default" for path in raw_config]
# ['/var/log', '/var/log/default', '/tmp', '/var/log/default', '/etc/app']# Common mistake — putting the ternary after the iterable (SyntaxError)
# status = ["active" for user in users if user["active"] else "inactive"] # WRONG
# The trailing "if" is a filter — it drops non-matching items entirely.
# The ternary ("if ... else ...") in the output expression transforms all items.
# They serve different purposes. You can combine them:
# Keep only users, but show their status
status = ["active" if user["active"] else "inactive"
for user in users
if user["name"] != "Bob"]
# ['active', 'active'] — Bob was filtered out entirelyHvornår man bruger en for-løkke i stedet
List comprehensions er til at bygge lister. Hvis det, du virkelig gør, er at køre
sideeffekter, brug en for-løkke — ikke en comprehension. Dette betyder mere end stil: en comprehension
der kasserer sit resultat, spilder hukommelse ved at bygge en liste ingen bruger, og skjuler hensigten for læseren.
# Bad — comprehension for side effects (writing to a file, printing, calling an API)
[print(f"Processing user {user['name']}") for user in users] # don't do this
[requests.post("/api/notify", json=user) for user in users] # definitely don't do this
# Good — plain for loop makes the intent obvious
for user in users:
print(f"Processing user {user['name']}")
for user in users:
requests.post("/api/notify", json=user)# Bad — comprehension with logic complex enough to need comments or multiple steps
result = [
user["name"].strip().lower()
if user.get("active") and user.get("email_verified")
else user["name"].strip().lower() + " (unverified)"
for user in users
if user.get("role") in ("admin", "editor") and user.get("last_login") is not None
]
# Good — break it out when the logic is this involved
result = []
for user in users:
if user.get("role") not in ("admin", "editor"):
continue
if user.get("last_login") is None:
continue
name = user["name"].strip().lower()
if not (user.get("active") and user.get("email_verified")):
name += " (unverified)"
result.append(name)- Brug en comprehension, når du bygger en ny liste fra en eksisterende iterable med et klart udtryk og et valgfrit filter.
- Brug en for-løkke, når du kører sideeffekter — I/O, netværkskald, udskrivning, mutation af ekstern tilstand.
- Brug en for-løkke, når transformationslogikken har brug for flere linjer, mellemliggende variabler eller kommentarer for at forstås.
- Brug et generator-udtryk, når du kun behøver at iterere én gang eller sende direkte til
sum(),any(),max()— ingen liste nødvendig i hukommelsen.
Performance-bemærkning
List comprehensions er meningsfuldt hurtigere end en tilsvarende for + append
-løkke i CPython. Årsagen er bytecode: en comprehension kompilerer til en dedikeret LIST_APPEND
-opcode, der undgår attributopslaget på list.append ved hver iteration.
Python-performance-tips-wikien
dækker dette, og forskellen er typisk 10–40% for rent Python-arbejde afhængigt af listestørrelse.
import timeit
data = list(range(100_000))
# for + append
def with_loop():
result = []
for x in data:
result.append(x * 2)
return result
# list comprehension
def with_comprehension():
return [x * 2 for x in data]
# generator expression — no list built at all
def with_generator():
return sum(x * 2 for x in data)
# Typical results on CPython 3.12:
# with_loop(): ~7.2 ms
# with_comprehension(): ~4.8 ms (~33% faster)
# with_generator(): ~4.1 ms (and uses O(1) memory vs O(n))Hvis du ikke behøver en materialiseret liste — du sender resultatet til sum(),
any(), max(), eller itererer det én gang — brug et
generator-udtryk
i stedet. Det bruger konstant hukommelse uanset inputstørrelse, hvilket betyder noget, når der behandles store CSV-eksporter
eller JSON-payloads i en tæt løkke.
Opsummering
List comprehensions er en af de Python-funktioner, der føles akavet i cirka en uge og derefter bliver umulige at leve uden. Den mentale model er simpel: outputudtryk, løkkevariabel, iterable, valgfrit filter. Hold dig til det, og du skriver læsbar, idiomatisk Python. Når logikken bliver kompleks, er det signalet til at falde tilbage til en simpel løkke — ikke en fiasko, bare det rigtige værktøj til jobbet.
Hvis du arbejder med JSON-data i Python — omdanner API-svar til lister af værdier, udtrækker felter fra poster, bygger opslagsdict'er — passer værktøjerne på dette websted godt til, hvad du netop har lært. Prøv JSON Formatter til at inspicere og pretty-printe JSON-payloads inden du skriver den comprehension, der behandler dem, eller CSV Formatter til at validere CSV-data, inden du parser det til en liste af rækker. For den fulde sprogereference er Python-dokumentationen om list comprehensions og PEP 202 (det originale forslag) værd at læse.