I believe CPython has some optimizations that make `+=` fast, but that's an implementation detail (and isn't the motivating reason behind my point), but you should avoid depending on implementation details.

Before you get into the TL;DR below, note that if you're iterating over the columns, then you're okay. What I wrote still holds, but there usually aren't enough columns in practice for this to matter a whole lot.

Consider strings `s1 ... sN` each with length `n1 ... nN`.

Then if you concatenate with `+=` (assuming it behaves like `s1 = s1 + s2`, since strings are immutable and thus must be copied each time) then the time complexity will be:

`n1 + (n1 + n2) + (n1 + n2 + n3) + ... + (n1 + n2 + ... + nN)`

which is

`N * n1 + (N - 1) * n2 + ... + nN`

Now let's say that `n1 = n2 = ... = nN = 1`, i.e., all strings are length 1, then the previous reduces to

`N * (N + 1) / 2`

which is `O(N ^ 2)`

whereas building up a list of `N` strings will require `O(N)` time because no extra copies are being made each time.

For example, you can allocate the length of the final string by doing `n1 + n2 ... + nN` which is `O(N)` plus filling in the allocated memory (another `O(N)`) so the resulting time complexity is `2O(N) == O(N)`.