Comment puis-je changer les touches dans un dictionnaire pour les majuscules et ajouter des valeurs de la clé dans le dictionnaire?

J'ai un dictionnaire qui ressemble à ceci:

d = {'A':110, 'a':100, 'T':50, 't':5}

Je veux changer les touches majuscules et de combiner A+a et T+t et ajouter leurs valeurs, de sorte que le dictionnaire ressemble à ceci:

d = {'A': 210, T: 55}

C'est ce que j'ai essayé:

for k, v in d.items():
    k.upper(), v

et le résultat est:

('A', 110)
('A', 100)
('T', 50)
('t', 5)

Je ressemble tuples, mais je veux le changer dans le dictionnaire, j'ai donc essayé d'écrire une fonction:

def Upper(d):
    for k, v in d.items:
        k.upper(), v
    return d

mais il renvoie le dictionnaire inchangé.

Après j'ai changé les touches majuscules, j'avais trouvé cette solution pour comment ajouter des valeurs de clés dans un dictionnaire:

dict([(x, a[x] + b[x]) if (x in a and x in b) else (x, a[x]) if (x in a) else (x, b[x])

mais d'abord, j'ai besoin d'obtenir les clés en majuscules!

Avec Python, vous devez être beaucoup plus attention à l'indentation. Vos deux "ce que j'ai essayé" exemples d'indentation erreurs qui ont empêché l'exécution de code à tous.

OriginalL'auteur edg | 2012-03-14

python

Counter fait cela très bien

>>> d = {'A':110, 'a':100, 'T':50, 't':5}
>>> from collections import Counter
>>> c = Counter()
>>> for k,v in d.items():
...     c.update({k.upper(): v})
... 
>>> c
Counter({'A': 210, 'T': 55})

cant importation Compteur 🙁
vous aurez besoin d'au moins Python2.7 pour Counter

OriginalL'auteur John La Rooy

5

upper() méthode ne permet pas de modifier quoi que ce soit. Vous pouvez utiliser le code suivant:
```
def capitalize_keys(d):
    result = {}
    for key, value in d.items():
        upper_key = key.upper()
        result[upper_key] = result.get(upper_key, 0) + value
    return result
```
Cela fonctionne très bien, mais pourquoi nest pas, le nouveau dictionnaire stockées dans d?
Il est possible d'écrire un code qui change (pastebin.com/FHgv9Y5p), mais cette mise en œuvre est moins transparente, et n'a approximativement le même nombre d'opérations. À l'aide de fonctions ci-dessus, vous pourriez écrire d = capitalize_keys(d).

OriginalL'auteur citxx
2

defaultdict est utile:
```
>>> from collections import defaultdict
>>> d = {'A':110, 'a':100, 'T':50, 't':5}
>>> new_d = defaultdict(int)
>>> for key, val in d.iteritems():
...     new_d[key.upper()] += val
...
>>> dict(new_d)
{'A': 210, 'T': 55}
```
Lorsque j'essaie de ne pas utiliser le defaultdict ('new_d = defaultdict(0)'), j'obtiens ce message d'erreur:
Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: premier argument doit être appelable
C'est parce qu'il doit être defaultdict(int).
fixe, utilisez int au lieu de 0 lors de l'initialisation defaultdict instance.

OriginalL'auteur Roman Bodnarchuk
1

Je pense que vous devez reconstruire votre dictionnaire. Exemple:
```
from collections import defaultdict

d={'A':110, 'a':100, 'T':50, 't':5}

def upper(d):
        nd=defaultdict(int)
        for k, v in d.iteritems():
                nd[k.upper()]+=v
        return dict(nd)

print d
print upper(d)
```
De sortie:
```
{'A': 110, 'a': 100, 'T': 50, 't': 5}
{'A': 210, 'T': 55}
```
Ou de l'utilisation de la solution de @citxx avec result.get(upper_key, 0) + value et d'éviter la defaultdict tout à fait.

merci, il renvoie le nouveau dictionnaire comme ça après l'utilisation de la fonction: defaultdict(<type 'int'>, {'A': 110, "T": 50}) et quand je regarde ce qui est dans d (le dictionnaire d'origine), j'ai toujours l'ancien... comment puis-je retourner/store le nouveau dictionnaire d?
Remplacer simplement d avec d=upper(d) et vous êtes fine.

OriginalL'auteur hochl

Avec cette fonction (corrigé):

>>> def upper_kdict(d):
...     r = {}
...     for k, v in d.items():
...             K = k.upper()
...             r[K] = v if not r.__contains__(K) else v + r[K]
...     return r
... 
>>> 
>>> d = {'a': 100, 'A': 110, 'b': 20, 'B': 1000, 'C': 150, 'c': 100, 'd': 180}
>>> upper_kdict(d)
{'A': 210, 'C': 250, 'B': 1020, 'D': 180}

"et de combiner Un+et T+t et d'ajouter leurs valeurs", ce qui signifie que upper_dict(dict(a=1, A=1)) doit retourner {'A': 2}; votre fonction retourne {'A': 1}.
c'est à dire s'il vous plaît corriger cette limitation ou la suppression de votre réponse.
Ok, fixer la limitation.

OriginalL'auteur SmartElectron

Utiliser une très longue dictionnaire de la compréhension: l'

d = {'A':110, 'a':100, 'T':50, 't':5}
d = dict((k, v + d.get(k.lower(), 0)) if (k == k.upper()) 
    else (k.upper(), v) for (k, v) in d.items() 
    if ((k == k.upper()) or (k == k.lower() and not (k.upper() in d))))
print d

De sortie:

{'A': 210, 'T': 55}

OriginalL'auteur fraxel

Vous devez vous connecter pour publier un commentaire.