Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas ici ;-) ).
Voici :
-----------------------------------------------
def f1(fichier):
dict_of_infos_in_file = {"INFO_1" : "",
"INFO_2" : []
"INFO_3" : []}
...
dict_of_infos_in_file.__setitem__("INFO_1", "str")
...
dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...])
...
dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...])
...
...
return dict_of_infos_in_file
def f2(list_of_some_files):
dict_file = {}
...
for myFile in list_of_some_files :
res_dict = f1(myFile)
dict_file.__setitem__(myFile, res_dict)
...
return dict_file
dictionnaire = f2(liste_de_fichiers)
print dictionnaire
-----------------------------------------------
Et là ... c'est le drame !
J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de dict_file (les clés sont bonnes
heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis par f1()) vides,
sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi :
dict_file.__setitem__(myFile, res_dict.copy())
Mais le résultat est ... comment dire ... identique au précédent !
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer.
Cordialement.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Fouff
Fouff a écrit :
Bonjour à toutes et à tous.
Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas ici ;-) ). Voici : ----------------------------------------------- def f1(fichier): dict_of_infos_in_file = {"INFO_1" : "", "INFO_2" : [] "INFO_3" : []} ... dict_of_infos_in_file.__setitem__("INFO_1", "str") ... dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...]) ... dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...]) ... ... return dict_of_infos_in_file
def f2(list_of_some_files): dict_file = {} ... for myFile in list_of_some_files : res_dict = f1(myFile) dict_file.__setitem__(myFile, res_dict) ... return dict_file
dictionnaire = f2(liste_de_fichiers) print dictionnaire ----------------------------------------------- Et là ... c'est le drame ! J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de dict_file (les clés sont bonnes heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis par f1()) vides, sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi : dict_file.__setitem__(myFile, res_dict.copy()) Mais le résultat est ... comment dire ... identique au précédent !
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer. Cordialement.
Grrrrrrrr
Ayé j'ai trouvé. Je me suis fait avoir en beauté avec les "shallow" copies de M(biiiiiiiiiiiiiiiip) !!!
Ca me fatigue d'avoir ce genre de choses qui ne me sont pas tellement familières. Pour infos, la solution : def fQuiFoutLeBronx(di): import copy ... # dict_c = di.copy() dict_c = copy.deepcopy(di) ... del dict_c["INFO_2"][0] ... del dict_c
Et elle ne fiche plus le bazar !!! (donc éventuellement, on peut la renommer :D )
Par contre, je suis preneur si quelqu'un avait une explication/idée simple sur le pourquoi du comment il est fait par défaut une copie des références des éléments, plutôt que directement une copie "deep" des éléments.
MERCI pour les éventuelles réponses. Cordialement.
Fouff a écrit :
Bonjour à toutes et à tous.
Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas
ici ;-) ).
Voici :
-----------------------------------------------
def f1(fichier):
dict_of_infos_in_file = {"INFO_1" : "",
"INFO_2" : []
"INFO_3" : []}
...
dict_of_infos_in_file.__setitem__("INFO_1", "str")
...
dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...])
...
dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...])
...
...
return dict_of_infos_in_file
def f2(list_of_some_files):
dict_file = {}
...
for myFile in list_of_some_files :
res_dict = f1(myFile)
dict_file.__setitem__(myFile, res_dict)
...
return dict_file
dictionnaire = f2(liste_de_fichiers)
print dictionnaire
-----------------------------------------------
Et là ... c'est le drame !
J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de
dict_file (les clés sont bonnes heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis
par f1()) vides,
sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce
dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi :
dict_file.__setitem__(myFile, res_dict.copy())
Mais le résultat est ... comment dire ... identique au précédent !
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer.
Cordialement.
Grrrrrrrr
Ayé j'ai trouvé.
Je me suis fait avoir en beauté avec les "shallow" copies de M(biiiiiiiiiiiiiiiip) !!!
Ca me fatigue d'avoir ce genre de choses qui ne me sont pas tellement familières.
Pour infos, la solution :
def fQuiFoutLeBronx(di):
import copy
...
# dict_c = di.copy()
dict_c = copy.deepcopy(di)
...
del dict_c["INFO_2"][0]
...
del dict_c
Et elle ne fiche plus le bazar !!! (donc éventuellement, on peut la renommer :D )
Par contre, je suis preneur si quelqu'un avait une explication/idée simple sur le pourquoi
du comment il est fait par défaut une copie des références des éléments, plutôt que directement
une copie "deep" des éléments.
MERCI pour les éventuelles réponses.
Cordialement.
Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas ici ;-) ). Voici : ----------------------------------------------- def f1(fichier): dict_of_infos_in_file = {"INFO_1" : "", "INFO_2" : [] "INFO_3" : []} ... dict_of_infos_in_file.__setitem__("INFO_1", "str") ... dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...]) ... dict_of_infos_in_file.__setitem__("INFO_2", [elem_1, elem_2, ...]) ... ... return dict_of_infos_in_file
def f2(list_of_some_files): dict_file = {} ... for myFile in list_of_some_files : res_dict = f1(myFile) dict_file.__setitem__(myFile, res_dict) ... return dict_file
dictionnaire = f2(liste_de_fichiers) print dictionnaire ----------------------------------------------- Et là ... c'est le drame ! J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de dict_file (les clés sont bonnes heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis par f1()) vides, sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi : dict_file.__setitem__(myFile, res_dict.copy()) Mais le résultat est ... comment dire ... identique au précédent !
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer. Cordialement.
Grrrrrrrr
Ayé j'ai trouvé. Je me suis fait avoir en beauté avec les "shallow" copies de M(biiiiiiiiiiiiiiiip) !!!
Ca me fatigue d'avoir ce genre de choses qui ne me sont pas tellement familières. Pour infos, la solution : def fQuiFoutLeBronx(di): import copy ... # dict_c = di.copy() dict_c = copy.deepcopy(di) ... del dict_c["INFO_2"][0] ... del dict_c
Et elle ne fiche plus le bazar !!! (donc éventuellement, on peut la renommer :D )
Par contre, je suis preneur si quelqu'un avait une explication/idée simple sur le pourquoi du comment il est fait par défaut une copie des références des éléments, plutôt que directement une copie "deep" des éléments.
MERCI pour les éventuelles réponses. Cordialement.
Bruno Desthuilliers
Fouff a écrit :
Bonjour à toutes et à tous.
Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas ici ;-) ). Voici : ----------------------------------------------- def f1(fichier): dict_of_infos_in_file = {"INFO_1" : "", "INFO_2" : [] "INFO_3" : []} ... dict_of_infos_in_file.__setitem__("INFO_1", "str")
<hs> Tu gagnerais probablement en lisibilité en revoyant et harmonisant un peu le nommage de tes objets... </hs>
Et là ... c'est le drame ! J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de dict_file (les clés sont bonnes heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis par f1()) vides, sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi : dict_file.__setitem__(myFile, res_dict.copy()) Mais le résultat est ... comment dire ... identique au précédent !
Pas de raison qu'il en soit autrement. La programmation par accident, ça ne mène pas loin, en général...
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer.
Je ne vois pas très bien ce qu'on peut faire pour t'aider, vu que tu n'a manifestement pas posté le code posant problème (ou au moins le code minimum reproduisant le problème).
Pour ce que ça vaut, le code suivant fonctionne correctement:
Bref, le problème est manifestement dans le code que tu n'a *pas* posté.
Fouff a écrit :
Bonjour à toutes et à tous.
Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas
ici ;-) ).
Voici :
-----------------------------------------------
def f1(fichier):
dict_of_infos_in_file = {"INFO_1" : "",
"INFO_2" : []
"INFO_3" : []}
...
dict_of_infos_in_file.__setitem__("INFO_1", "str")
<hs>
Tu gagnerais probablement en lisibilité en revoyant et harmonisant un
peu le nommage de tes objets...
</hs>
Et là ... c'est le drame !
J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de
dict_file (les clés sont bonnes heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis
par f1()) vides,
sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce
dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi :
dict_file.__setitem__(myFile, res_dict.copy())
Mais le résultat est ... comment dire ... identique au précédent !
Pas de raison qu'il en soit autrement. La programmation par accident, ça
ne mène pas loin, en général...
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer.
Je ne vois pas très bien ce qu'on peut faire pour t'aider, vu que tu n'a
manifestement pas posté le code posant problème (ou au moins le code
minimum reproduisant le problème).
Pour ce que ça vaut, le code suivant fonctionne correctement:
Je me trouve confronté à un problème (sinon, je ne vous dérangerais pas ici ;-) ). Voici : ----------------------------------------------- def f1(fichier): dict_of_infos_in_file = {"INFO_1" : "", "INFO_2" : [] "INFO_3" : []} ... dict_of_infos_in_file.__setitem__("INFO_1", "str")
<hs> Tu gagnerais probablement en lisibilité en revoyant et harmonisant un peu le nommage de tes objets... </hs>
Et là ... c'est le drame ! J'ai globalement n'importe quoi dans les valeurs (retour de f1()) de dict_file (les clés sont bonnes heureusement).
J'ai principalement des dictionnaires (ceux qui sont censés être rmplis par f1()) vides, sauf des fois, 1 valeur est remplie mais elle n'appartient pas à ce dictionnaire ...
Bref, je ne comprend pas ce qui se passe !!!
J'ai donc essayé aussi : dict_file.__setitem__(myFile, res_dict.copy()) Mais le résultat est ... comment dire ... identique au précédent !
Pas de raison qu'il en soit autrement. La programmation par accident, ça ne mène pas loin, en général...
D'avance MERCI de toute l'aide pertinente que vous pourrez me procurer.
Je ne vois pas très bien ce qu'on peut faire pour t'aider, vu que tu n'a manifestement pas posté le code posant problème (ou au moins le code minimum reproduisant le problème).
Pour ce que ça vaut, le code suivant fonctionne correctement:
Bref, le problème est manifestement dans le code que tu n'a *pas* posté.
Bruno Desthuilliers
Fouff a écrit : (snip)
Grrrrrrrr
Ayé j'ai trouvé. Je me suis fait avoir en beauté avec les "shallow" copies de M(biiiiiiiiiiiiiiiip) !!!
(snip)
Par contre, je suis preneur si quelqu'un avait une explication/idée simple sur le pourquoi du comment il est fait par défaut une copie des références des éléments, plutôt que directement une copie "deep" des éléments.
Parce que la shallow copy est 1/ ce qu'on veut dans environ 99% des cas [*], et 2/ nettement moins coûteuse qu'une deep copy.
En général, dans le cas de figure illustré dans ton code, on préfère construire une nouvelle liste (voire un nouveau dict) par filtrage de l'original que de faire un deep copy puis des suppressions (nb : ce qui ne veut pas dire que ta solution soit mauvaise ou injustifié - ça dépend du cas d'utilisation, of course).
[*] et encore... De mémoire, je n'ai pas dû avoir l'usage de copy.deepcopy plus d'une dizaine de fois en 8 ans...
Fouff a écrit :
(snip)
Grrrrrrrr
Ayé j'ai trouvé.
Je me suis fait avoir en beauté avec les "shallow" copies de
M(biiiiiiiiiiiiiiiip) !!!
(snip)
Par contre, je suis preneur si quelqu'un avait une explication/idée
simple sur le pourquoi
du comment il est fait par défaut une copie des références des éléments,
plutôt que directement
une copie "deep" des éléments.
Parce que la shallow copy est 1/ ce qu'on veut dans environ 99% des cas
[*], et 2/ nettement moins coûteuse qu'une deep copy.
En général, dans le cas de figure illustré dans ton code, on préfère
construire une nouvelle liste (voire un nouveau dict) par filtrage de
l'original que de faire un deep copy puis des suppressions (nb : ce qui
ne veut pas dire que ta solution soit mauvaise ou injustifié - ça dépend
du cas d'utilisation, of course).
[*] et encore... De mémoire, je n'ai pas dû avoir l'usage de
copy.deepcopy plus d'une dizaine de fois en 8 ans...
Ayé j'ai trouvé. Je me suis fait avoir en beauté avec les "shallow" copies de M(biiiiiiiiiiiiiiiip) !!!
(snip)
Par contre, je suis preneur si quelqu'un avait une explication/idée simple sur le pourquoi du comment il est fait par défaut une copie des références des éléments, plutôt que directement une copie "deep" des éléments.
Parce que la shallow copy est 1/ ce qu'on veut dans environ 99% des cas [*], et 2/ nettement moins coûteuse qu'une deep copy.
En général, dans le cas de figure illustré dans ton code, on préfère construire une nouvelle liste (voire un nouveau dict) par filtrage de l'original que de faire un deep copy puis des suppressions (nb : ce qui ne veut pas dire que ta solution soit mauvaise ou injustifié - ça dépend du cas d'utilisation, of course).
[*] et encore... De mémoire, je n'ai pas dû avoir l'usage de copy.deepcopy plus d'une dizaine de fois en 8 ans...