Je sais que list objet peut être modifié sur place, mais list() devrait me renvoyer un objet list indépendant à chaque fois qu'il est appelé. Maintenant, je suis confus au sujet de la sortie:

L = [1, 2, 3, 4]
# list() should 
D = dict.fromkeys(L, list())
print(D) # {1: [], 2: [], 3: [], 4: []}
D[1].append(1989)
print(D) # {1: [1989], 2: [1989], 3: [1989], 4: [1989]}

La sortie requise doit être:

{1: [1989], 2: [], 3: [], 4: []}
1
O'Skywalker 16 juil. 2015 à 12:10

4 réponses

Meilleure réponse

Le problème avec votre code est que le constructeur fromkeys réutilise la même valeur pour chaque clé. Ainsi list() n'est évalué qu'une seule fois.

Vous pouvez utiliser soit une compréhension de dict:

D = {x:list() for x in L}

Ou, si vous savez que vous utiliserez toujours des listes dans votre dictionnaire, utilisez le Usine defaultdict:

from collections import defaultdict

D = defaultdict(list)
D[1].append(1989)
D[2].append(2001)

print(D) # {1: [1989], 2: [2001]}
4
301_Moved_Permanently 16 juil. 2015 à 09:22

list() n'est appelé qu'une seule fois. Pour une ancienne version de Python, vous pouvez utiliser le fait que vous pouvez initialiser un dict à partir d'une liste de paires clé / valeur:

D = dict([(x, list()) for x in L]

À partir de Python 2.5, vous pouvez utiliser des générateurs et laisser de côté la construction de la liste de l'exemple précédent:

D = dict((x, list()) for x in L)

À partir de python 2.7 et 3.0, vous pouvez utiliser la compréhension de dict, initialement rejetée pour python 2.3, à partir de PEP 274:

D = {x: list() for x in L}
1
Anthon 16 juil. 2015 à 11:40

Vous pourriez envisager d'utiliser un defaultdict de collections, il pourrait être plus approprié, et au moins il vaut la peine d'en apprendre davantage.

import collections
D = collections.defaultdict(list)

D[1].append(1989)
D[1].append(1990)

print D[1]
print D
print D[2]
print D

Cela imprimerait ce qui suit:

[1989, 1990]
defaultdict(<type 'list'>, {1: [1989, 1990]})
[]
defaultdict(<type 'list'>, {1: [1989, 1990], 2: []})
2
Martin Evans 16 juil. 2015 à 09:23

list() est appelé une fois, et ce même list est utilisé comme valeur pour toutes les clés.

Transcription de la console (vous pouvez voir le même id pour toutes les valeurs):

>>> dict.fromkeys(['a', 'b', 'c'])
{'a': None, 'c': None, 'b': None}
>>> dict.fromkeys(['a', 'b', 'c'], 5)
{'a': 5, 'c': 5, 'b': 5}
>>> dict.fromkeys(['a', 'b', 'c'], [1, 2])
{'a': [1, 2], 'c': [1, 2], 'b': [1, 2]}
>>> dict.fromkeys(['a', 'b', 'c'], [1, 2, 3])
{'a': [1, 2, 3], 'c': [1, 2, 3], 'b': [1, 2, 3]}
>>> d = dict.fromkeys(['a', 'b', 'c'], list())
{'a': [], 'c': [], 'b': []}
>>> for key in d: print id(d[key])
... 
4325657272
4325657272
4325657272
2
Roshan Mathews 16 juil. 2015 à 09:16