On Thu, Oct 13, 2016 at 08:15:36PM +0200, Martti Kühne wrote:
> Can I fix my name, though?
I don't understand what you mean. Your email address says your name is
Martti Kühne. Is that incorrect?
[...]
> I meant that statement in context of the examples which were brought up:
> the occurrence of a list comprehension inside an array have the
> following effect:
>
> 1) [ ..., [expr for t in iterable] ]
>
> is equivalent to:
>
> def expr_long(iterable, result):
> result.append(iterable)
> return result
>
> expr_long(iterable, [ ..., ])
The good thing about this example is that it is actual runnable code
that we can run to see if they are equivalent. They are not equivalent.
py> def expr_long(iterable, result):
... result.append(iterable)
... return result
...
py> iterable = (100, 200, 300)
py> a = [..., [2*x for x in iterable]]
py> b = expr_long(iterable, [...])
py> a == b
False
py> print(a, b)
[Ellipsis, [200, 400, 600]] [Ellipsis, (100, 200, 300)]
For this to work, you have to evaluate the list comprehension first,
then pass the resulting list to be appended to the result.
I don't think this is very insightful. All you have demonstrated is that
a list display [a, b, c, ...] is equivalent to:
result = []
for x in [a, b, c, ...]:
result.append(x)
except that you have written it in a slightly functional form.
> so, if you make the case for pep448, you might arrive at the following:
>
> 2) [ ..., *[expr for expr in iterable] ]
That syntax already works (in Python 3.5):
py> [1, 2, 3, *[x+1 for x in (100, 200, 300)], 4, 5]
[1, 2, 3, 101, 201, 301, 4, 5]
> which would be, if I'm typing it correctly, equivalent to, what
> resembles an external collection:
>
> def expr_star(list_comp, result):
> result.extend(list(list_comp))
> return result
>
> expr_star(iterable, [ ..., ])
>
> Having this in mind, the step to making:
>
> [ ..., [*expr for expr in iterable], ]
>
> from:
>
> def expr_insidestar(iterable, result):
> for expr in iterable:
> result.extend(expr)
> return result
>
> does not appear particularly far-fetched, at least not to me and a few
> people on this list.
But you don't have [..., list_comp, ] you just have the list comp.
You are saying:
(1) List displays [a, b, c, d, ...] are like this;
(2) we can sensibly extend that to the case [a, b, *c, d, ...]
I agree with (1) and (2). But then you have a leap:
(3) therefore [*t for t in iterable] should mean this.
There's a huge leap between the two.
To even begin to make sense of this, you have to unroll the list
comprehension into a list display. But that's not very helpful:
[expr for t in iterable]
Would you rather see that explained as:
[expr, expr, expr, expr, ...]
or as this?
result = []
for t in iterable:
result.append(expr)
The second form, the standard, documented explanation for
comprehensions, also applies easily to more complex examples:
[expr for t in iter1 for u in iter2 for v in iter3 if condition]
result = []
for t in iter1:
for u in iter2:
for v in iter3:
if condition:
result.append(expr)
--
Steve
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
