L'initialisation d'un dictionnaire en python, avec une valeur de clé et ne correspond à aucune des valeurs

Je me demandais si il y avait un moyen d'initialiser un dictionnaire en python, avec les touches, mais ne correspond à aucune des valeurs jusqu'à ce que je les ai. Tels que:

Definition = {'apple': , 'ball': }

et puis plus tard, je peux les définir:

Definition[key] = something

Je ne veux initialiser les touches, mais je ne sais pas les valeurs correspondantes jusqu'à ce que j'ai à régler plus tard. Fondamentalement, je sais ce que les touches que je veux ajouter les valeurs qu'ils sont trouvés. Merci.

Pourquoi voulez-vous initialiser les touches?
Il n'y a pas une telle chose comme une clé sans une valeur dans un dict. Il vous suffit de définir la valeur None, si.
Que signifie le fait de définir une clé avec aucune valeur? Si vous essayez d'accéder à l'élément en question, serait-il générer une erreur (comme si vous n'aviez jamais défini que les principaux), ou de céder à quelque chose (dans ce cas, que quelque chose est sa valeur)?
Puisque vous savez que vous allez remplacer les valeurs plus tard, il n'a vraiment pas d'importance ce que vous définissez pour.
J'ai été la création d'un dictionnaire qui passe par un autre dictionnaire pour seulement saisir les valeurs des clés je voulais, si je voulais être en mesure de comparer les clés et de les définir si elles sont égales. Pourrait de fait d'une mauvaise façon, mais il fonctionne! Merci encore!

InformationsquelleAutor user2989027 | 2013-11-19

54

Vous pourriez les initialiser à None.
- Ou si Aucun n'est une valeur légitime pour un ou plusieurs de vos clé-valeur de n-uplets, vous pouvez utiliser quelque chose comme "SENTINELLE = object()" et l'utilisation de SENTINELLE que vos sentinelles de la valeur, de l'essai avec "est" au lieu de "==".
- Yep d'accord, Regardez votre portée globale des données et de déterminer la valeur doit jamais être disponibles à jamais. -1, false, aucun, aléatoire int, chaîne aléatoire et ainsi de suite.. une Vieille question, mais de meilleurs résultats encore.
InformationsquelleAutor Scott Hunter
70

Utiliser le fromkeys fonction pour initialiser un dictionnaire avec toute la valeur par défaut. Dans votre cas, vous devrez initialiser avec None puisque vous n'avez pas une valeur par défaut à l'esprit.
```
empty_dict = dict.fromkeys(['apple','ball'])
```
cela permettra d'initialiser empty_dict comme:
```
empty_dict = {'apple': None, 'ball': None}
```
Comme une alternative, si vous voulez initialiser le dictionnaire avec une certaine valeur par défaut autre que None, vous pouvez le faire:
```
default_value = 'xyz'
nonempty_dict = dict.fromkeys(['apple','ball'],default_value)
```
- Lors de l'utilisation de dict.fromkeys(..., default_value), assurez-vous que default_value n'est pas d'un type qui nécessite un constructeur (comme la liste), sinon vous allez obtenir des références pour le même objet dans tous vos seaux.
InformationsquelleAutor codegeek
8

vous pouvez utiliser un defaultdict. Il vous permettra de définir le dictionnaire des valeurs sans se soucier de savoir si la clé existe déjà. Si vous avez accès à une clé qui n'a pas été initialisé mais il sera de retour une valeur que vous spécifiez (dans l'exemple ci-dessous, elle sera de retour Aucun)
```
from collections import defaultdict
your_dict = defaultdict(lambda : None)
```
InformationsquelleAutor Hammer
6

Il serait bon de savoir ce que votre but est, pourquoi vous voulez initialiser les touches en premier lieu. Je ne suis pas sûr que vous devez faire.

1) Si vous voulez compter le nombre d'occurrences de clés, il vous suffit de faire:
```
Definition = {}
# ...
Definition[key] = Definition.get(key, 0) + 1
```
2) Si vous souhaitez obtenir Aucun (ou une autre valeur) plus tard pour les touches que vous n'avez pas de rencontre, encore une fois, vous pouvez simplement utiliser la méthode get ():
```
Definition.get(key)  # returns None if key not stored
Definition.get(key, default_other_than_none)
```
3) Pour toutes les autres fins, vous pouvez utiliser une liste de l'clés, et de vérifier si les clés trouvés par la suite correspondent à ceux que l'.

Par exemple, si vous souhaitez stocker les valeurs de ces clés:
```
expected_keys = ['apple', 'banana']
# ...
if key_found in expected_keys:
    Definition[key_found] = value
```
Ou si vous voulez vous assurer que toutes les clés ont été trouvés:
```
assert(all(key in Definition for key in expected_keys))
```
InformationsquelleAutor
4

Vous pouvez initialiser les valeurs des chaînes vides et les remplir plus tard qu'ils sont trouvés.
```
dictionary = {'one':'','two':''}
dictionary['one']=1
dictionary['two']=2
```
InformationsquelleAutor creggnog

q = input("Apple")
w = input("Ball")
Definition = {'apple': q, 'ball': w}

InformationsquelleAutor Aktufono

0

Basé sur la clarification commentaire par @user2989027, je pense qu'une bonne solution est la suivante:
```
definition = ['apple', 'ball']
data = {'orange':1, 'pear':2, 'apple':3, 'ball':4}
my_data = {}
for k in definition:
  try:
    my_data[k]=data[k]
  except KeyError:
    pass
print my_data
```
J'ai essayé de ne pas faire quelque chose de compliqué ici. J'ai paramétré mes données et un dictionnaire vide. J'ai ensuite une boucle sur une liste de chaînes de caractères qui représentent les clés dans mon dictionnaire de données. Je copie chaque valeur de données à my_data, mais considérons le cas où les données peuvent ne pas avoir la clé que je veux.

InformationsquelleAutor Robert Lugg

Vous devez vous connecter pour publier un commentaire.