A possible alternative would be a partition library function in the same vein
as `map` and `filter`
```
def partition(n, key, iter):
"""
Partitions a list.
Args: (n: the number of partitions), (key: function which takes elements
and returns the index of the partition to place them in), (iter: the iterable
to be partitioned)
Returns: A tuple of lists partitioned per the key function. If this were a
library function, this would likely return a tuple of generators instead in the
same vein as `map` and `filter`.
"""
lists = tuple([] for _ in range(n))
for x in iter:
lists[key(x)].append(x)
return lists
```
Except it would be optimized like a library function (which means written in C,
I believe)
On Tuesday, September 22, 2020 at 12:16:39 PM UTC-7, Yakov Shalunov wrote:
> Python list comprehension is substantially faster than plan iteration, to the
> point where
> ```
> l0, l1 = [],[]
> for x in l:
> if cond(x):
> l0.append(x)
> else:
> l1.append(x)
> ```
> runs at about the same speed as
> ```
> l0 = [x for x in l if cond(x)]
> l1 = [x for x in l if not cond(x)]
> ```
> assuming `cond` is a computationally light conditional.
> While this isn't an extremely common use, I suggest a "partition
> comprehension" syntax which extends normal filtered-generator syntax. Such
> as:
> ```
> l0, l1 = ([x for x in l if cond(x) else x])
> ```
> (parenthesis there to indicate that the output is a tuple)
> It could allow extension to n-way partitions as well. Because elif doesn't
> fit nicely in-line, it would probably be nicer to do it like:
> ```
> l0, l1, l2 = ([x for x in l if cond0(x) else x**2 if cond1(x) else x**3])
> ```
> So l0 would be all elements that match cond0, l1 would be squares of all that
> match cond1, and l2 would be cubes of everything that matches neither.
--
https://mail.python.org/mailman/listinfo/python-list
