Python-Dictionary Comprehension

Ist es möglich, erstellen Sie eine dictionary comprehension in Python (für die Schlüssel)?

Ohne Liste Verstehens, die Sie verwenden können, so etwas wie dieses:

l = []
for n in range(1, 11):
    l.append(n)

Können wir diese kürzen, um eine Liste Verständnis: l = [n for n in range(1, 11)].

Allerdings sagen, dass ich möchte, um eine dictionary-keys mit dem gleichen Wert.
Kann ich tun:

d = {}
for n in range(1, 11):
     d[n] = True # same value for each

Habe ich versucht, dieses:

d = {}
d[i for i in range(1, 11)] = True

Allerdings bekomme ich eine SyntaxError auf die for.

Zusätzlich (brauche ich nicht dieses Teil, sondern nur Fragen), können Sie festlegen, dass eine Wörterbuch-Tasten, um eine Reihe von verschiedenen Werten wie diesen:

d = {}
for n in range(1, 11):
    d[n] = n

Ist das möglich mit einem Wörterbuch Verständnis?

d = {}
d[i for i in range(1, 11)] = [x for x in range(1, 11)]

Dies wirft auch ein SyntaxError auf die for.

Für zukünftige Leser, info: NumPy-arrays tun, können Sie mehrere Elemente zu einem einzigen Wert oder eine Liste von Werten, die Art und Weise Sie zu tun versuchen. Obwohl, wenn Sie nicht bereits ein Grund für die Verwendung von NumPy, ist es vermutlich nicht Wert, nur für dieses feature.

InformationsquelleAutor Rushy Panchal | 2013-01-24

468

Gibt es Wörterbuch Verstehens in Python 2.7+, aber Sie funktioniert nicht ganz so, wie Sie sind, es zu versuchen. Wie eine list comprehension, erstellen Sie eine neue Wörterbuch;, die Sie nicht verwenden können Sie Tasten hinzufügen, um ein vorhandenes Wörterbuch. Auch, müssen Sie die Schlüssel und Werte, obwohl natürlich, können Sie einen dummy-Wert ein, wenn Sie möchten.
```
>>> d = {n: n**2 for n in range(5)}
>>> print d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
```
Wenn Sie möchten, um Sie alle setzen auf True:
```
>>> d = {n: True for n in range(5)}
>>> print d
{0: True, 1: True, 2: True, 3: True, 4: True}
```
Was Sie scheinen zu Fragen, ist eine Möglichkeit, um mehrere Tasten auf einmal auf einem vorhandenen Wörterbuch. Es gibt keine direkte Verknüpfung. Sie können entweder die Schleife, wie du bereits gezeigt, oder Sie können ein Wörterbuch Verständnis zu schaffen, ein neues dict mit den neuen Werten, und führen Sie dann oldDict.update(newDict) Zusammenführen, werden die neuen Werte in den alten dict.

FWIW, dict.update können auch akzeptieren eine iterierbar von Schlüssel-Wert-Paare genau wie die dict Konstruktor
Beachten Sie, dass, wenn Sie um ein Wörterbuch zu erstellen, bei der alle Werte gleich ist, verwenden Sie dict.fromkeys(). So setzen Sie alle Werte auf True verwenden dict.fromkeys(range(5), True). Vorsicht, der Wert ist nicht kopiert, so können Sie dies vermeiden wollen, wenn Sie einen änderbaren Wert; es wird gemeinsam für alle Tasten.
Hinweis: die Schlüssel können das Ergebnis einer Methode: { n*2 : n for n in range(3) } => {0: 0, 2: 1, 4: 2}. Beide kann man in der gleiche Ausdruck: { n*2 : n*3 for n in range(3) } => { 0: 0, 2: 3, 4: 6 }.

InformationsquelleAutor BrenBarn
145

Können Sie die dict.fromkeys Methode der Klasse ...
```
>>> dict.fromkeys(range(5), True)
{0: True, 1: True, 2: True, 3: True, 4: True}
```
Dies ist der Schnellste Weg, um ein Wörterbuch zu erstellen, wo alle Schlüssel anzeigen, um den gleichen Wert.

Aber jedoch nicht verwenden Sie diese mit veränderlichen Objekten:
```
d = dict.fromkeys(range(5), [])
# {0: [], 1: [], 2: [], 3: [], 4: []}
d[1].append(2)
# {0: [2], 1: [2], 2: [2], 3: [2], 4: [2]} !!!
```
Wenn Sie nicht wirklich müssen zu initialisieren aller Tasten, ein defaultdict könnte nützlich sein, als gut:
```
from collections import defaultdict
d = defaultdict(True)
```
Zu beantworten, der zweite Teil, der einen dict-comprehension ist genau das, was Sie brauchen:
```
{k: k for k in range(10)}
```
Sollten Sie wahrscheinlich nicht tun, aber Sie können auch erstellen Sie eine Unterklasse von dict die funktioniert ähnlich wie eine defaultdict wenn Sie überschreiben __missing__:
```
>>> class KeyDict(dict):
...    def __missing__(self, key):
...       #self[key] = key  # Maybe add this also?
...       return key
... 
>>> d = KeyDict()
>>> d[1]
1
>>> d[2]
2
>>> d[3]
3
>>> print(d)
{}
```
Beachten Sie, dass im Fall von d = defaultdict(lambda: True), die lambda ist nicht erforderlich, da Wahr ist (oder nicht) werden verändert.

InformationsquelleAutor mgilson

>>> {i:i for i in range(1, 11)}
{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10}

InformationsquelleAutor NPE

19

Ich mag die @mgilson Kommentar, wenn man da ein zwei iterables, entspricht den Tasten und die andere die Werte, können Sie auch Folgendes tun.
```
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
```
geben

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

InformationsquelleAutor ehontz
11

Verwenden dict() auf eine Liste von Tupeln, die diese Lösung ermöglicht es Ihnen, beliebige Werte in jeder Liste, solange Sie die gleiche Länge
```
i_s = range(1, 11)
x_s = range(1, 11)
# x_s = range(11, 1, -1) # Also works
d = dict([(i_s[index], x_s[index], ) for index in range(len(i_s))])
```
Als Seite beachten, dies ist die gleiche Sache wie d = dict(zip(i_s,x_s))

InformationsquelleAutor Bryan
10

Beachten Sie in diesem Beispiel das zählen der vorkommen der Wörter in einer Liste, Wörterbuch Verständnis
```
my_list = ['hello', 'hi', 'hello', 'today', 'morning', 'again', 'hello']
my_dict = {k:my_list.count(k) for k in my_list}
print(my_dict)
```
Und das Ergebnis ist
```
{'again': 1, 'hi': 1, 'hello': 3, 'today': 1, 'morning': 1}
```
Dies ist interessant, wenn auch nicht die effizienteste, da Sie sich zählen, Tasten wie 'Hallo' mehrfach

InformationsquelleAutor adonese
7

Den Hauptzweck einer Liste Verständnis ist das erstellen einer neuen Liste basierend auf einem anderen eins, ohne Veränderung oder Zerstörung der ursprünglichen Liste.

Statt zu schreiben
```
    l = []
    for n in range(1, 11):
        l.append(n)
```
oder
```
    l = [n for n in range(1, 11)]
```
sollten Sie nur schreiben
```
    l = range(1, 11)
```
In den oberen zwei code-Blöcke, die Sie erstellen eine neue Liste Durchlaufen und es einfach wieder jedes element. Es ist nur eine teure Art und Weise der Erstellung einer Liste kopieren.

Um ein neues Wörterbuch mit allen Schlüsseln auf den gleichen Wert gesetzt, basierend auf einem anderen dict, dies zu tun:
```
    old_dict = {'a': 1, 'c': 3, 'b': 2}
    new_dict = { key:'your value here' for key in old_dict.keys()}
```
Sie erhalten eine SyntaxError-weil, wenn Sie schreiben
```
    d = {}
    d[i for i in range(1, 11)] = True
```
du bist im Grunde sagen: "meine Taste" i for i in range(1, 11)' auf "True" und "i for i in range(1, 11)" ist keine gültige Schlüssel, es ist nur ein syntax-Fehler. Wenn dicts unterstützten Listen als Schlüssel, Sie möchte etwas tun, wie
```
    d[[i for i in range(1, 11)]] = True
```
und nicht
```
    d[i for i in range(1, 11)] = True
```
aber Listen sind nicht hashable, so dass Sie nicht verwenden können Sie als dict-Schlüssel.

InformationsquelleAutor Bonifacio2
-3

können Sie nicht hash so einer Liste.
versuchen Sie, diese stattdessen verwendet es Tupeln
```
d[tuple([i for i in range(1,11)])] = True
```
Dies nicht zu tun, was der OP wollte...

InformationsquelleAutor Aditya Sihag

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.