När list comprehensions klickar skriver du aldrig en for-slinga som lägger till en lista igen. De är inte bara syntaktiskt socker — de signalerar avsikt tydligt och körs snabbare än den ekvivalenta slingan i CPython tack vare bytekodoptimering. Enligt den officiella Python-handledningen tillhandahåller comprehensions ett kortfattat sätt att skapa listor baserade på befintliga sekvenser eller andra iterables. Den här artikeln bygger den mentala modellen först, och täcker sedan varje verkligt mönster: filtrering, kapsling, dict- och set-comprehensions, och det enda fallet där du bör nå efter en vanlig for-slinga istället.

Grundmönstret

Anatomin hos en list comprehension är [uttryck for objekt in iterable]. Tre delar: utdatauttrycket (vad varje element blir), slingvariabeln och iterable att hämta från. Börja med en bekant slinga och kollaps den.

python
# 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]

Comprehension läses nästan som engelska: "ge mig size / 1024 för varje size i file_sizes_bytes." Den tydligheten är den verkliga vinsten — en läsare behöver inte spåra ett append-anrop för att förstå vad du bygger.

python
# 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

Lägg till ett villkor i slutet och bara element som passerar hamnar i utdatalistan: [uttryck for objekt in iterable if villkor]. Det är mönstret som ersätter en for + if + append-kombination.

python
# 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']
python
# 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']

Arbeta med strängar

Strängbearbetning är där comprehensions verkligen lönar sig. Kombinationen av Pythons rika strängmetoder och comprehension-syntax håller transformationspipelines läsbara utan mellanliggande variabler.

python
# 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']
Tips: när du normaliserar användarinmatning, strippa innan du gör lowercase — annars passerar ett värde som " [email protected] " en .lower()-kontroll på innehållet men bär fortfarande inledande mellanslag som bryter en databasuppslagning eller JSON-nyckelmatchning.

Dict- och set-comprehensions

Samma idé sträcker sig till dicts och sets. En dict-comprehension använder klammerparenteser med ett nyckel: värde-par: {nyckel: värde for objekt in iterable}. En set-comprehension tar bort kolonen och producerar en deduplicerad samling: {uttryck for objekt in iterable}.

python
# 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'
python
# 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 guaranteed

En varning med sets: ordningen bevaras inte. Om du behöver deduplicera en lista och behålla den ursprungliga ordningen är en set-comprehension fel verktyg — använd list(dict.fromkeys(items)) istället, vilket utnyttjar insertionsordningsbeteendet hos dicts i Python 3.7+.

Kapslade comprehensions

Du kan kapsla comprehensions för att iterera över kapslade strukturer. Det vanligaste användningsfallet är att platta till en lista av listor — en matris från ett CSV-parse, sidindelade API-svarssidor eller grupperade frågeresultat.

python
# 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 kapslade comprehensions från vänster till höger — den yttre slingan kommer först, den inre slingan andra. Det matchar ordningen på kapslade for-slingor.

python
# 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)
Generatoruttryck använder samma syntax med parenteser istället för hakparenteser: (user["id"] for user in users). De utvärderas lätt — element produceras ett i taget snarare än att bygga hela listan i minnet. Använd dem när du bara behöver iterera en gång, eller när du skickar resultatet direkt till sum(), max(), any() eller liknande funktioner. Se referensen för generatoruttryck för fullständiga detaljer.

if/else-ternären inuti en comprehension

När du behöver omvandla element till ett av två värden — snarare än att ta bort dem — använd ett ternärt uttryck i utdatapositionen. Positionen spelar roll: ternären hör hemma i början, inte efter iterable.

python
# 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']
python
# 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 entirely

När man ska använda en for-slinga istället

List comprehensions är för att bygga listor. Om det du verkligen gör är att köra sidoeffekter, använd en for-slinga — inte en comprehension. Det här spelar roll bortom stil: en comprehension som kastar bort sitt resultat slösar minne på att bygga en lista som ingen använder, och det döljer avsikten från läsaren.

python
# 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)
python
# 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)
  • Använd en comprehension när du bygger en ny lista från en befintlig iterable med ett tydligt uttryck och ett valfritt filter.
  • Använd en for-slinga när du kör sidoeffekter — I/O, nätverksanrop, utskrift, mutering av externt tillstånd.
  • Använd en for-slinga när transformationslogiken behöver flera rader, mellanliggande variabler eller kommentarer för att förstås.
  • Använd ett generatoruttryck när du bara behöver iterera en gång eller skicka direkt till sum(), any(), max() — ingen lista behövs i minnet.

Prestandaanteckning

List comprehensions är meningsfullt snabbare än en ekvivalent for + append-slinga i CPython. Anledningen är bytekod: en comprehension kompileras till en dedikerad LIST_APPEND-opkod som undviker attributuppslagningen på list.append vid varje iteration. Pythons prestandatips-wiki täcker detta, och gapet är vanligtvis 10–40% för ren-Python-arbetsbelastningar beroende på liststorlek.

python
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))

Om du inte behöver en materialiserad lista — du skickar resultatet till sum(), any(), max() eller itererar det en gång — använd ett generatoruttryck istället. Det använder konstant minne oavsett indatastorlek, vilket spelar roll när man bearbetar stora CSV-exporter eller JSON-nyttolaster i en tät slinga.

Sammanfattning

List comprehensions är en av de Python-funktioner som känns klumpiga i ungefär en vecka och sedan blir omöjliga att leva utan. Den mentala modellen är enkel: utdatauttryck, slingvariabel, iterable, valfritt filter. Håll dig till det och du skriver läsbar, idiomatisk Python. När logiken blir komplex är det signalen att falla tillbaka på en vanlig slinga — inte ett misslyckande, bara rätt verktyg för jobbet.

Om du arbetar med JSON-data i Python — omvandlar API-svar till listor av värden, extraherar fält från poster, bygger uppslagsdict — passar verktygen på den här webbplatsen bra ihop med vad du just lärt dig. Prova JSON-formateraren för att inspektera och prettifiera JSON-nyttolaster innan du skriver comprehension som bearbetar dem, eller CSV-formateraren för att validera CSV-data innan du parsar den till en lista med rader. För fullständig språkreferens är Python-dokumentationen om list comprehensions och PEP 202 (det ursprungliga förslaget) värda att läsa.

← All Python articles Browse all categories →