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