Filter out empty strings and compute the length of each remaining string.

Express a transformation that filters out empty strings and maps each remaining string to its length.

When you need to compute the lengths of only the non-empty strings in a collection, e.g., before calculating average length or filtering out blanks.

Data cleaning, text preprocessing, preparing data for statistical analysis, filtering out empty entries before computing lengths.

[len(s) for s in strings if s]

[len(s) for s in iterable if condition]

{"strings": "list of strings", "s": "element variable", "condition": "truthiness test (e.g., if s)"}

• ["strings"
• "len"
• "list comprehension"
• "filter"
• "non-empty\[\ \(empty string\)\[/\]"]
• "common_substitutions": "[\"[len(s) for s in strings]\"
• \"[len(x) for x in strings if x]\"
• \"[len(s) for s in strings if s != ''\\)\ \"
• "common_substitutions": "[\"[len(s) for s in strings]\"
• \"[len(x) for x in strings if x]\"
• \"[len(s) for s in strings if s != ''\\)]"]
• "variations": "[\"[len(s) for s in strings if s.strip()]\"
• \"[len(s) for s in strings if s is not None]\"
• \"[len(s) for s in strings if len(s) > 0]\\)\n\n"
• "common_mistakes": "[\"Forgetting the filter and getting zero-length entries for empty strings\"
• \"Applying len() to None values causing TypeError\"
• \"Using filter(None
• ...) which returns an iterator in Python 3
• not a list\\)\n\n"
• "similar_contrasting": "[\"[len(s) for s in strings]\" (includes zero-length entries)
• \"[len(s) for s in strings if s.strip()]\" (also filters whitespace-only)
• \"list(map(len
• filter(None
• strings)))\" (lazy iterator)]\n\n"
• "interference_warnings": "Confusing with map(len
• filter(None
• strings)) which returns an iterator in Python 3
• forgetting that empty string is falsy but whitespace-only strings are not filtered."\n\n"
• "nuance": "Filters out only falsy strings (empty string)
• whitespace-only strings are retained because they are truthy."\n\n"
• "pragmatic_effect": "Produces a list of integer lengths representing the lengths of meaningful (non-empty) strings."\n\n"
• "note": "Useful for preprocessing before calculating statistics like average length or filtering out blanks."\n\n"
• "recall_cue": "Lengths of non-empty strings."\n\n"
• "spacing_tag": "medium"\n\n"
• "upgrade_path": "Consider using map(len
• filter(None
• strings)) for lazy evaluation
• or a generator expression if only iterating."\n\n"
• "chunk_family": "list comprehension filtering"\n\n"
• "register": "technical"\n\n"
• "type_label": "list comprehension"\n\n"
• "semantic_transparency": "transparent"\n\n"
• "discourse_function": "referential"\n\n"}]} {

• list(map(len
• strings)) – eager evaluation
• less readable [len(s) for s in strings if s != ""] – explicit empty‑string check list(filter(None
• strings)) then map(len
• ...) – two‑step approach

Omitting the filter clause, resulting in zeros for empty strings – leads to inaccurate statistics Applying len to None values because the list may contain None – raises TypeError Using filter(None, strings) in Python 3 and expecting a list – gets an iterator and later errors when indexed

[len(s) for s in strings] – includes empty strings list(map(len, filter(None, strings))) – lazy iterator version [len(s) for s in strings if s.strip()] – also removes whitespace‑only entries

Coming from JavaScript: using strings.filter(Boolean).map(s => s.length) returns a new array but may miss None‑like values – Python’s truthiness rules differ.

• list comprehension filtering
• list comprehension mapping
• generator expression

1) Do not use when you need to keep empty strings for positional alignment. 2) List comprehensions create a full list in memory; for large datasets consider a generator. 3) Whitespace‑only strings are truthy, so they pass the filter unless you explicitly strip.

Provides a concise, readable way to obtain lengths of only meaningful strings, enabling downstream analytics without manual loops.

Think of the comprehension as a factory line: it discards empty boxes before measuring the size of each remaining package.

The comprehension is evaluated eagerly; if you only need to iterate once, a generator expression (len(s) for s in strings if s) is more memory‑efficient.

After mastering this, move to a generator expression for lazy evaluation or use map/filter for functional style processing.