PCAP Strings Practice Question

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

• ✗

  Using the % formatting operator

  Why it's wrong here

  Using the % formatting operator: The % operator is intended for one-time formatting of a template, not for incrementally assembling a larger string. Each application parses the format string, interpolates the arguments, and allocates a completely new string object. Repeating this in a loop—for example, s = s % (piece,)—discards every intermediate result and recreates the whole string from scratch, leading to O(n^2) time and avoidable garbage-collection churn.

• ✓

  Using the join() method on a list

  Why this is correct

  Using the join() method on a list: This is the canonical efficient technique. You collect all the pieces into a list, then call separator.join(list) once. The join() implementation precomputes the exact total length of the result, allocates a single buffer, and copies each piece into it in one straight pass, producing no intermediate strings. That makes it O(n) in both time and memory and is the fastest pure-Python way to assemble many separate string fragments.

• ✗

  Using the += operator

  Why it's wrong here

  Using the += operator: Although += looks like an in-place append, Python strings are immutable, so the operation allocates a brand-new string containing both the accumulator and the appended piece, then re-binds the variable to that fresh object. In a loop, every iteration copies the entire growing accumulator plus the new piece, so the total amount of copied data grows quadratically. It also churns the memory allocator because each previous string becomes garbage immediately; this is a classic performance trap when the loop runs many times.

• ✗

  Using the + operator

  Why it's wrong here

  Using the + operator: The + operator is the plain binary concatenation operator: each use copies both operand strings into a newly allocated result. When you write s = s + piece in a loop, the full running total is copied again on every iteration, so the accumulated work grows O(n^2) with the number of pieces. Unlike +=, + has no pseudo-in-place semantics—every call is an explicit pure function returning a brand-new object—and the old string is discarded instantly, making the inefficiency equally severe but more transparent.

• ✓

  Using StringIO from the io module

  Why this is correct

  Using StringIO from the io module: StringIO wraps a mutable in-memory buffer behind a file-like interface, so repeated .write() calls append data without creating temporary strings. After you finish writing, .getvalue() returns the final string in a single copy. This is a legitimate efficient approach for incremental concatenation, especially when the code already uses a stream-style API, though the per-write method-call overhead usually makes it slightly slower than a list plus join(); pick it when a write-stream abstraction is more natural.

Go deeper

Related to this question