Discussion :

[Nothus]

Bonjour à tous,

Tout est un peu dans le titre : codant une bête fonction de gestion de matrice (à dimensions multiples), et lançant le programme, j'ai fini par perdre patience à ne pas comprendre une erreur simple. Lorsque je décalais dans une matrice une colonne ou une ligne (ou d'une dimension à l'autre), je modifiais l'objet voulu mais aussi l'objet d'origine (qui devait lui, demeurer intact).

Non sans difficulté (sic !), j'ai fini par remettre la main sur l'erreur, un dictionnaire semblant ne pouvoir ""simplement"" se copier par affectation. En somme Dict2 = Dict1, Dict2 reste une référence de Dict1.
> Question 1: je suis dans le vrai ? Je n'ai pas trouvé spécialement clair la documentation à ce sujet (à ce propos si vous connaissez une bonne traduction...).

Python n'est pas mon langage de programmation "natif" (PHP), et j'avoue que je suis face à un abyme de perplexité face à ce comportement.
> Question 2: Comment dupliquer un dictionnaire (avec tout ce qu'il contient, ordre et affectation interne), sans créer juste une référence supplémentaire à son original? Pour la liste j'ai trouvé [:], mais qui ne fonctionne pas avec les dictionnaires. J'ai essayé Dict2 = dict(Dict1), mais sans résultat probant (création d'une référence). J'ai finalement essayé Dict2 = dict() puis boucler ligne à ligne les affectations de Dict1 dans Dict2 (et devinez quoi? Ben ça crée une référence).

J'ai même essayé Dict2 = dict((list(Dict1)[:])) - sait-on jamais...

Accessoirement, c'est ce genre de petit détail rageant qui vous dit que tous les langages ne sont pas tous aussi «accessibles» qu'on peut bien le lire parfois et, pour être honnête, ça donne l'impression d'un langage pas très abouti, même si je l'aime bien pour des petites routines... :/
> Question 3: Python, bon pour apprendre mais pas pour travailler? (ne me tapez pas)

Autrement dit, la copie d’une string (ou int, float, etc.) donne toujours un nouvel objet, alors que la copie d’une liste (ou d’un dict, ou n’importe quel objet évolué) est “shallow”, c’est le même objet qui est assigné à la copie…

D’où la vicieuse subtilité qui t’a posé problème : l’expression d’initialisation par défaut des variables d’une fonction est évaluée une seule fois, lors de la construction de cette fonction par le parseur, et les valeurs ainsi obtenues sont copiées à chaque appel de cette fonction, si nécessaire – donc, tu te retrouve toujours avec la même liste ! Oui, c’est vraiment vicieux, et bravo pour avoir trouvé une solution tout seul

Bonne fin d'après-midi!

[PauseKawa]

Bonjour,

En effet vous ne faite qu'ajouter une référence.
Vous pouvez faire dico2 = dict(dico1).

@+

[Nothus]

Déjà fait, même résultat. Cela fait une référence supplémentaire.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Matrice2 = dict(Matrice)
    for item in Matrice:
    if (item+pas)<=NbreLignes:
        Matrice2[item+pas][numero_colonne] = Matrice[item][numero_colonne]
    else:
        Matrice2[((item+pas)-NbreLignes)][numero_colonne] = Matrice[item][numero_colonne]

NB: je travaille dans une fonction. Mais je doute que ça change quelque chose ?

[PauseKawa]

Déjà fait, même résultat. Cela fait une référence supplémentaire.

Ne confondez vous pas ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
>>> dico2 = dict(dico1)
>>> id(dico1)
23011296
>>> id(dico2)
23722784

[Nothus]

Effectivement, autant pour moi, ça fait un objet différent.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
{1: '0', 2: '1', 3: '2', 4: '3', 5: '4', 6: '5', 7: '6'}
{1: '7', 2: '8', 3: '9', 4: '0', 5: '1', 6: '2', 7: '3'}
{1: '4', 2: '5', 3: '6', 4: '7', 5: '8', 6: '9', 7: '0'}
{1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7'}
{1: '8', 2: '9', 3: '0', 4: '1', 5: '2', 6: '3', 7: '4'}
{1: '5', 2: '6', 3: '7', 4: '8', 5: '9'}
37484992
---Fct---
---37499360
---37484992
---Fin Fct---
---37499360
---37484992
---------------
{1: '0', 2: '1', 3: '2', 4: '3', 5: '4', 6: '5', 7: '6'}
{1: '7', 2: '1', 3: '9', 4: '0', 5: '1', 6: '2', 7: '3'}
{1: '4', 2: '1', 3: '6', 4: '7', 5: '8', 6: '9', 7: '0'}
{1: '1', 2: '1', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7'}
{1: '8', 2: '1', 3: '0', 4: '1', 5: '2', 6: '3', 7: '4'}
{1: '5', 2: '1', 3: '7', 4: '8', 5: '9'}
37499360

Mais le résultat reste désespérément le même. Bon donc c'est juste que je me plante plus largement dans ma fonction !

Mais c'est un autre problème maintenant ! Merci beaucoup !

[Matthieu Brucher]

> Question 1: je suis dans le vrai ? Je n'ai pas trouvé spécialement clair la documentation à ce sujet (à ce propos si vous connaissez une bonne traduction...).

C'est ce qui se passe pour tout bon langage classique avec gestion de mémoire automatique, même PHP, l me semble. Tu travailles non pas avec les objets, mais avec des références sur ces objets. = ne fait qu'affecter, ça ne crée rien de nouveau

[Nothus]

Oui pour les objets (sous PHP5 tout au moins). Mais pour les tableaux non, c'est une assignation de valeur.

http://php.net/manual/fr/language.oop5.cloning.php

[Nothus]

Je vais paraître bête mais tant pis : un dictionnaire sous Python (3), c'est un type comme un autre (à savoir comme se comporte un tableau sous PHP) ou non ?

J'imagine, vu que l'on parle de référence, que Python le gère comme un objet, c-à-d une sorte de classe déguisée ?

[mont29]

Ce n’est même pas une “classe déguisée”, c’est une classe, d’où l’on peut dériver d’autres classes, et qui dérive elle-même de la classe de base 'object'… tout comme int, str, etc.

La seule “exception” à ce principe de référence, ce sont les types (ou classes) immutable (int, float, str, bytes, tuple), qui sont toujours passés par valeur (pour simplifier).

[Nothus]

Merci beaucoup de vos réponses. Il faut que je repasse par les bancs de la fac, encore quelques (grosses) lacunes dans les bases !

[Matthieu Brucher]

Même là, on peut considérer que tous les types sont des classes et toujours passés par valeur (c'est ce qui se passe derrière de toute manière). Un tableau est une classe, une chaîne de caractères est une classe. La seule différence est que certains objets ne sont pas modifiables (entiers, strings, set...)

[dividee]

Matrice2 = dict(Matrice) crée un nouveau dictionnaire, mais juste en-dessous on voit Matrice2[item+pas][numero_colonne] = Matrice[item][numero_colonne] qui montre que les valeurs du dictionnaires sont elles même des objets mutables (certainement des dictionnaires ou des listes, le code ne permet pas de le déterminer). La copie du dictionnaire crée un nouveau dictionnaire, mais les références qui sont les valeurs du dico sont copiées telles quelles. En d'autre le termes, la copie ne se fait que sur "un seul niveau".

Dans ce post, j'ai mis quelques schémas qui expliquent la situation pour une liste de listes, mais la situation est la même ici.

Remarquez que le problème ne se posent pas pour les clés du dictionnaires, car les clés doivent (devraient...) être immutables.

Pour faire une copie des valeurs, il faut le faire explicitement: Matrice2 = {k:v[:] for k,v in Matrice.items()} ... ou utiliser deepcopy.

La seule “exception” à ce principe de référence, ce sont les types (ou classes) immutable (int, float, str, bytes, tuple), qui sont toujours passés par valeur (pour simplifier).

Même là, on peut considérer que tous les types sont des classes et toujours passés par valeur (c'est ce qui se passe derrière de toute manière). Un tableau est une classe, une chaîne de caractères est une classe. La seule différence est que certains objets ne sont pas modifiables (entiers, strings, set...)

La terminologie "passage par valeur" ou "passage par référence" n'est pas bien adaptée à un langage comme Python. Effectivement, le passage d'argument se fait toujours par valeur, mais ce sont des références qui sont passées, comme l'explique Mathieur Brucher. Alors que mont29 utilise "passage par valeur" dans le sens "l'objet lui-même est passé, pas une référence", il me semble. Mais ce n'est pas juste, il n'y a pas de différence dans le façon dont un objet mutable ou immutable est passé. C'est vrai que, pour un objet immutable, ça ne changerait rien à la sémantique; on pourrait imaginer gagner en performance en passant une copie de certains objets "simples" au lieu d'une copie de la référence. Dans un langage statiquement typé (et compilé), cela pourrait être le cas, mais la dynamicité de Python empêche de pouvoir faire cela efficacement.