L'aléatoire est trop logique

Bonjour,

À la base j'ai ce code :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# -*- coding : utf-8 -*-

from random import randint

class Terrain:

    def __init__(self, largeur, hauteur):

        self.largeur = largeur
        self.hauteur = hauteur

        self.terrain = [[0] * self.largeur] * self.hauteur

    def display(self):

        for ligne in self.terrain:
            print(ligne)

    def place_mines(self, nombre=10):

        for y in range(self.hauteur):

            for x in range(self.largeur):

                self.terrain[y][x] = 9 if randint(0, 9) == 9 else 0

t = Terrain(6, 6)
t.display()
print("----------------")
t.place_mines()
t.display()

J'aimerais obtenir quelque chose comme ça, où les 9 sont disposés aléatoirement à travers le Terrain, qu'il puisse y en avoir plusieurs par lignes/colones:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
----------------
[9, 0, 0, 9, 0, 0]
[0, 0, 0, 0, 9, 0]
[9, 0, 0, 9, 0, 0]
[9, 0, 0, 0, 0, 9]
[0, 9, 0, 0, 0, 0]
[0, 0, 9, 0, 0, 0]

Mais à la place j'obtiens toujours les 9 sur une même colonne, ou pas de 9du tout (ce qui est quand même assez improbable au vu du nombre de case):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
----------------
[9, 0, 0, 0, 0, 0]
[9, 0, 0, 0, 0, 0]
[9, 0, 0, 0, 0, 0]
[9, 0, 0, 0, 0, 0]
[9, 0, 0, 0, 0, 0]
[9, 0, 0, 0, 0, 0]

Ai-je mal compris un fonctionnement du module random ? De ce je pense comprendre, je ne suis pas censé obtenir le résultat que j'ai, donc il y a probablement une erreur dans mon raisonnement mais où (telle est la question ) ?

Merci d'avance

Je viens de découvrir un comportement de Python, merci ! Problème réglé du coup !

Le deuxième exemple n'est pas significatif :

1
2
3

>>> l = [0 for _ in range(10)]
>>> l[1] is l[5]
True

Si je ne m'abuse, ça dépend des implémentations.

Oui, certainement. Mais expliquer un piège en posant un autre piège plus vicieux (puisqu'il dépend justement de l'implémentation) n'est pas la meilleure idée possible. J'ai trouvé le premier exemple plus adapté.

Au contraire le dernier exemple est juste génial et exprime vraiment bien le passage par référence (que j'avais visiblement mal compris). Que ce soit des immuables ou des muables, le résultat est le même: tous les éléments de la liste vont pointer vers le même objet (ce qui n'est pas facile à voir pour les immuables).

À l'inverse, ton exemple dépend justement de l'implémentation car ce que tu mets à gauche ne sera pas une copie de la référence. Le problème c'est que ça ne se voit pas avec des immuables (il y a sûrement une histoire d'optimisation derrière), mais ça se voit direct avec une liste:

1
2

lst = [[1, 2] for _ in range(10)]
print(lst[0] is lst[5])

En fait c'est exactement ce que j'avais en tête : quel que soit plop (muable, immuable, constante entière ou whatever), [plop] * x sera toujours une liste de x références sur plop. D'où ces 2 exemples.

Que certaines implémentations produisent le même resultat avec des entiers et une autre syntaxe n'entre pas en considération, ici l'exemple sert simplement à illustrer comment fonctionne cet opérateur et le caractère systématique de ce phénomène.

Du coup je ne vois pas tellement en quoi mon exemple n'est pas valable…

Bien sûr, lorsque l'on a affaire à une liste d'immutables, il est moins immédiat de faire apparaître qu'il s'agit de multiples références sur le même objet. Ici nohar l'a bien montré, mais ça aurait justement pu avoir une autre raison, ce qu'il me parait important de souligner.

J'ai simplement dit que l'interprétation du test ma_liste[1] is ma_liste[5] peut prêter à confusion, et du coup l'exemple est nettement moins parlant. Je me suis peut-être mal exprimé: l'exemple en soi est peut-être "juste", c'est sa démonstration qui me gêne (bon, vu qu'il n'y a pas de démonstration sans ambiguïté possible, je pense qu'on peut dire que l'exemple pose problème).

D'ailleurs, en relisant, le premier exemple me gêne également, parce que la construction explicite d'une liste en comprehension donne exactement le même résultat :

1
2
3
4

>>> plop = [1,2,3]
>>> l = [plop for _ in range(10)]
>>> l[1] is l[5]
True

Du coup, le premier exemple est finalement encore pire que le second, parce que ce n'est pas implementation defined ici.

Ah, bah ça a été exactement mon sentiment, peut-être ceci explique cela.

En tout cas merci et bravo pour l'explication très détaillée de la question.

Vous aviez pas besoin d'allez aussi loin mais ça énormément plaisir d'apprendre des choses, merci à vous !