Your example is interesting - `join`, a generator expression and a ternary, and Python requires us to write all of them inside-out. It's a shame we can't write that in a more natural order, something like:

    def f(template):
        return (for item in template:
            isinstance(item, str) then item else
            format(convert(item.value, item.conversion), item.format_spec)
        ).join('')

▲ davepeck 8 months ago | parent [-]

Yeah. `join` has forever been backwards to me in Python and I still sometimes get it wrong the first time out.

Comprehensions, though -- they are perfection. :-)

▲ pansa2 8 months ago | parent [-]

IMO comprehensions like `[x**2 for x in range(4)]` would be better written as `[for x in range(4): x**2]`.

That would make the mapping between a comprehension and the equivalent loop much clearer, especially once you use nested loops and/or conditionals.

For example, to flatten a list of lists `l = [[1, 2], [3], [4, 5, 6]]`:

    [item for sublist in l for item in sublist]

    [for sublist in l: for item in sublist: item]

▲

zahlman 8 months ago | parent | next [-]

I think it's very deliberate that these sorts of expressions are inside-out from the corresponding statements. It mixes and matches modes of thinking in my mind - the same kind of mistake as command-query separation violations. When I read a list comprehension, I can read it left to right: "A list (`[`) of each `item` that I get, if I look `for` each `sublist` that is `in l`, then `for` each `item` which is `in` that `sublist`." And the entire description is - well - descriptive, not imperative. With the other order, I have to think in terms of explicitly following the steps, and then mentally translating the last `item` into an imperative "... and put it into the result list".

▲

Hackbraten 8 months ago | parent | prev [-]

That would make dict comprehensions confusing due to two occurrences of colons with different semantics.

	▲	pansa2 8 months ago \| parent [-]
		Ah, yes - good point!