Python近似分组

Question

I want to group the keys of a dict by their values. However, the values are only approximately equal. What's the best approach to doing a groupby in this scenario. I have:

buckets = defaultdict(list)
for k, v in my_dict.iteritems():
    closest = next((rep for rep in buckets if abs(rep - v) < 1e-3), None)
    if closest:
        buckets[closest].append(k)
    else:
        buckets[v].append(k)

Any itertools magic or other stuff that could simplify this/make it more pythonic, or is this the best I can do?

Answer 1

Your algorithm is O(n**2) since it is performing O(n) operations inside an O(n) loop:

for k, v in my_dict.iteritems():
    closest = next((rep for rep in buckets if abs(rep - v) < 1e-3), None)

You could make it O(n log n) by sorting my_dict.items() by values, and then looping over the sorted items. Notice that instead of for rep in buckets , if buckets is an OrderedDict , you only have to look at the last bucket since the keys of OrderedDict will be in sorted order. So if the next value is close to any bucket, it has to be close to the last bucket. Thus, by using an OrderedDict , you do not need to loop over all the buckets. Just compare with the last one:

import random
random.seed(123)
N = 10
my_dict = dict(zip(range(N), [random.randint(0, 10)/10.0 for k in range(N)]))
print(my_dict)    
# {0: 0.0, 1: 0.0, 2: 0.4, 3: 0.1, 4: 0.9, 5: 0.0, 6: 0.5, 7: 0.3, 8: 0.9, 9: 0.1}

import operator
import collections
items = sorted(my_dict.items(), key=operator.itemgetter(1))
buckets = collections.OrderedDict([(items[0][1], [items[0][0]])])
for k, v in items[1:]:
    last_val = next(reversed(buckets))
    closest = last_val if abs(last_val - v) < 1e-3 else v
    buckets.setdefault(closest, []).append(k) 

print(buckets)

prints

OrderedDict([(0.0, [0, 1, 5]), (0.1, [3, 9]), (0.3, [7]), (0.4, [2]), (0.5, [6]), (0.9, [4, 8])])

Answer 2

This would be a slightly more "pythonic":

buckets = defaultdict(list)
for k, v in my_dict.iteritems():
    try:
        closest = next((rep for rep in buckets if abs(rep - v) < 1e-3))
        buckets[closest].append(k)
    except StopIteration:
        buckets[v].append(k)

Answer 3

Aside from your code being inefficient it doesn't guarantee same or any particular result each time since .itetitems() order could be arbitrary. To solve both of that you can simply use key function:

key = lambda x: round(x, 3)

And then you group the usual way, but using key(v) as index:

buckets = defaultdict(list)
for k, v in my_dict.iteritems():
    buckets[key(v)].append(k)