Python: key bekommen mit dem geringsten Wert aus einem Wörterbuch, SONDERN mehrere minimum-Werte

Ich versuche, das gleiche zu tun wie
Erhalten Sie die entsprechende Taste, um den minimalen Wert in einem Wörterbuchwo wir Sie haben wollen, bekommen Sie die entsprechende Taste, um den minimalen Wert in einem Wörterbuch.

Der beste Weg zu sein scheint:

min(d, key=d.get)

ABER ich möchte diese auf ein Wörterbuch mit mehreren minimalen Werte:

d = {'a' : 1, 'b' : 2, 'c' : 1}

Beachten Sie, dass die Antwort von den oben genannten wäre:

>>> min(d, key=d.get)
'a'

Allerdings muss ich beide die zwei Tasten, die einen minimalen Wert, nämlich a und c.

Was wäre die beste Herangehensweise?

(Letztendlich möchte ich wählen Sie eine der zwei nach dem Zufallsprinzip, aber ich glaube nicht, dass dies relevant ist).

InformationsquelleAutor der Frage gozzilli | 2012-03-30

12

Eine einfache Möglichkeit ist es, zuerst bestimmen Sie den minimalen Wert an, und wählen Sie dann alle Schlüssel-mapping auf, dass minimum:
```
min_value = min(d.itervalues())
min_keys = [k for k in d if d[k] == min_value]
```
Für Python 3 verwenden d.values() statt d.itervalues().

Dieser benötigt zwei Durchläufe durch das Wörterbuch, sollte aber eine der schnellsten Möglichkeiten, dies zu tun sowieso.

Mit reservoir samplingdie Sie implementieren können, ein single-pass-Ansatz, der wählt einen der Gegenstände nach dem Zufallsprinzip:
```
it = d.iteritems()
min_key, min_value = next(it)
num_mins = 1
for k, v in it:
    if v < min_value:
        num_mins = 1
        min_key, min_value = k, v
    elif v == min_value:
        num_mins += 1
        if random.randrange(num_mins) == 0:
            min_key = k
```
Nach dem schreiben unten dieser code, ich glaube, diese option ist von eher theoretischem Interesse... 🙂

InformationsquelleAutor der Antwort Sven Marnach
1
```
min_keys = [k for k in d if all(d[m] >= d[k] for m in d)]
```
oder leicht optimiert
```
min_keys = [k for k, x in d.items() if not any(y < x for y in d.values())]
```
Es ist nicht so effizient als andere Lösungen, sondern zeigt die Schönheit von python (naja, mich zumindest).

InformationsquelleAutor der Antwort georg
1

BEARBEITET: Jetzt mit setdefault wie vorgeschlagen 🙂

Ich weiß nicht, ob das hilft, aber du aufbauen könntest einen reverse dictionary mit den Werten als Schlüssel und den Schlüssel (in einer Liste als Werte).
```
d = {'a' : 1, 'b' : 2, 'c' : 1}
d2 = {}
for k, v in d.iteritems():
    d2.setdefault(v, []).append(k)
print d2[min(d2)]
```
Gedruckt:
```
['a', 'c']
```
Aber ich denke, die anderen Lösungen sind kompakter und wahrscheinlich auch eleganter...

InformationsquelleAutor der Antwort katzenversteher

def get_rand_min(d):
    min_val = min(d.values())
    min_keys = filter(lambda k: d[k] == min_val, d)
    return random.choice(min_keys)

InformationsquelleAutor der Antwort inspectorG4dget

0

Können Sie heapq.nsmallest, um die N kleinsten Mitglieder der dict, dann filtern alle, die nicht gleich dem niedrigsten ein. Das ist vorausgesetzt, Sie wissen, die maximale Anzahl der kleinsten Mitglieder, die Sie haben kann, nehmen wir an, es ist N hier. so etwas wie:
```
from heapq import nsmallest
from operator import itemgetter

#get the N smallest members
smallestN = nsmallest(N, myDict.iteritems(), itemgetter(1)))

#leave in only the ones with a score equal to the smallest one
smallest = [x for x in smallestN if x[1] == smallestN[0][1]]
```
InformationsquelleAutor der Antwort Not_a_Golfer
0
```
minValue,minKey = min((v,k) for k,v in d.items())
```
Wegen Ihrer Semantik müssen Sie gehen durch das gesamte Wörterbuch, mindestens einmal. Dieser ruft genau 1 minimale element.

Wenn Sie möchten, dass alle minimalen Elemente in O(log(N)), query Zeit, Sie können zum einfügen eines elements in eine Warteschlange, wie Sie ist, erzeugen Sie (wenn Sie können). Die Priorität muss haben O(1) einfügen Zeit und O(log(N)), extract-min Zeit. (Das wird so schlimm, wie Sortieren, wenn alle Ihre Elemente den gleichen Wert haben, aber ansonsten kann Sie ganz gut funktionieren.)

InformationsquelleAutor der Antwort ninjagecko

One-pass-Lösung wäre:

 >>> result = [100000, []]
>>> for key, val in d.items():
...  if val < result[0]:
...   result[1] = [key]; result[0]=val;
...  elif val == result[0]:
...   result[1].append(key)
... 
>>> result
[1, ['a', 'c']]

InformationsquelleAutor der Antwort Bogdan

Hier ist ein weiterer Weg, es zu tun in einem Durchgang:

d = {'foo': 2, 'a' : 1, 'b' : 2, 'c' : 1, 'z': 99, 'x': 1}
current_min = d[d.keys()[0]]
min_keys = []
for k, v in d.iteritems():
    if v < current_min:
        current_min = v
        min_keys = [k]
    elif v == current_min:
        min_keys.append(k)
print min_keys
['a', 'x', 'c']

InformationsquelleAutor der Antwort alan

0

Dies funktioniert:
```
d = {'a' :1, 'b' : 2, 'c' : 1}
min_value = min(d.values())
result = [x[0] for x in d.items() if x[1] == k]
```
Hmpf. Nach dem fixieren bis der code funktioniert, ich landete mit @Sven Marnach Antwort, so ignorieren Sie diese 😉

InformationsquelleAutor der Antwort Daren Thomas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.