How Do You Build Lists Dynamically?

There are several ways to turn an iterable into a list, and they differ in what they produce.

source = "abc"

print(list(source))             # ['a', 'b', 'c']
print([c for c in source])      # ['a', 'b', 'c'] - the comprehension
print(list(range(3)))           # [0, 1, 2]
print(sorted({3, 1, 2}))        # [1, 2, 3] - sorted always returns a list

# A generator expression gives an iterator, not a list
lazy = (c for c in source)
print(type(lazy).__name__)      # generator
print(list(lazy))               # ['a', 'b', 'c']

# Repetition builds a list of references
zeros = [0] * 5
print(zeros)                    # [0, 0, 0, 0, 0]

list(iterable) is the general conversion and works with any iterable, including generators and file objects. A list comprehension does the same job while letting you transform or filter each item on the way, and it is usually faster because the loop runs without the repeated method lookups that a Python-level for loop performs.

The generator expression in parentheses looks almost identical to a comprehension in square brackets, but the difference is what you get back. The comprehension evaluates immediately and produces a list. The generator expression produces a generator object that computes each item on demand, so nothing is stored and nothing is computed until you iterate.

The repetition form needs a warning. The list [0] * 5 is fine because integers are immutable and each slot holds a reference to the same zero. But [[]] * 3 creates three references to the same inner list, so appending to one of them changes all three. To build three independent lists you need a comprehension: [[] for _ in range(3)].

The same transformation can be written two ways, and the comprehension is usually the faster one.

import time

values = range(200_000)

start = time.perf_counter()
result = []
for value in values:
    result.append(value * 2)
loop_seconds = time.perf_counter() - start

start = time.perf_counter()
fast = [value * 2 for value in values]
comp_seconds = time.perf_counter() - start

print(f"loop:        {loop_seconds:.4f}s")
print(f"comprehension: {comp_seconds:.4f}s")
print(len(result), len(fast))

Both lines produce a list of 200,000 doubled values, and the comprehension is consistently the quicker of the two — often by a factor of two or more on CPython. The exact numbers vary by machine and by Python version, so treat the output as a demonstration rather than a benchmark to quote.

The reason is that the comprehension compiles to a dedicated bytecode loop that the interpreter can execute without the per-iteration overhead of a Python-level for statement — the repeated lookup of the append method, the bound-method call, and the loop bookkeeping. The comprehension also keeps the whole transformation in one expression, so there is no separate state to track.

The same principle applies to string building, where the stakes are higher. Concatenating with += inside a loop copies the accumulated string on every iteration, which is quadratic, while collecting the pieces in a list and calling join once at the end is linear. For a list of thousands of pieces that is the difference between instant and visibly slow.

One caveat: a comprehension that does a lot of work per item, or one that uses a nested function call with side effects, can be slower than the explicit loop, and generators beat comprehensions when you do not need all the results in memory at once.

There are five common ways, and the choice comes down to what you are building from and whether you need the results in memory.

The list constructor, list(iterable), converts any iterable into a list. It is the right choice for turning a generator, a file object, a set or a range into a concrete list.

The list comprehension, [expr for item in iterable if condition], is the default for building a list from another sequence. It applies a transformation, can filter as it goes, and runs faster than an equivalent loop with append.

The generator expression, (expr for item in iterable), is the same syntax in parentheses but produces a lazy iterator. Use it when you are passing the results straight to another function such as sum, any, or a database bulk insert, and you do not need to hold them all at once.

Multiplication, [value] * n, repeats references rather than values. It is fine for immutable values and a trap for mutable ones, as in [[]] * 3.

And the explicit loop with append, which is the slowest but the clearest when the logic is complicated, when there are several statements per iteration, or when you need to build the list conditionally with control flow inside the body.

The guidance to offer in an interview: use a comprehension for simple transformations and filters, a generator expression when memory matters or the result is consumed once, and an explicit loop whenever the body needs more than an expression. And when the list is being appended to repeatedly inside a loop, move the append out of the loop and collect into a list first.