[python] Un vrai aléatoire

Programmation
#1

Bonjour!
Je rencontre un petit souci que voici : j’ai un classe Case, qui me crée un objet contenant un indice aléatoire.
J’ai ensuite une autre classe contenant une liste de Case. Voici comment je le crée :

longX et longY étants passés en argument. Bref, en somme, je fais une liste de Case.
Cependant, toutes les Case ont le même indice. Comment cela se fait-il?
Je donne l’indice via la fonction random.randint(1, 1000).
Alors où est-ce que je me plante?

edit : Evidemment que j’ai les même valeurs, je suis débile, puisque je la reproduit avec le *. Bon, reste à trouver une solution… :confused:

#2

Je ne connais pas bien python, mais le random ne te demande pas un entier au début ? Tu lui redonnerais pas cet entier à chaque fois par hasard ? Et toujours le même ?

#3

Non, en fait, random a plusieurs possibilités, comme sortir un nombre aléatoire parmis un intervalle. Finalement, j’ai opté pour random.random() tout seul, qui retourne un nombre compris entre 0 et 1 très compliqué. Comme je ne sais pas à l’avance de combien de case je vais avoir besoin, c’est le mieux que j’aie trouvé pour que cela fonctionne la plupart du temps.

Je m’en suis sorti en faisant appel à list.append(). C’est un peu plus compliqué et fait appel à une autre fonction en dehors de la classe, mais ça fonctionne bien :slightly_smiling: .
J’espère pouvoir, dans quelques mois, me dire que mon code pourrait être grandement optimisé, là, j’ai l’impression de bidouiller…

#4

Salut,

Lors de ta déclaration de la class l’as tu hérité de object ?

Comme class xxxx(object): ...

#5

Je ne peux pas t’en dire plus sans avoir vu plus de code. :slightly_smiling:

#6

C’est bon j’ai réussi comme je le disait plus tôt. Il fallait appeler le créateur de la classe Case pour avoir des indices différents.
Voilà le code tout entier, qui mérite améliorations :

[code]#!/usr/bin/env python

-- coding:Utf-8 --

Fichier: laby.py

Cree le 20 mars 2011 18:55:41

Derniere modification: 20 mars 2011 18:55:41

“”"

Auteur : thuban (thuban@singularity.fr)
licence : GNU General Public Licence

Description : Ceci est la classe Laby, qui contient aussi la
classe Case. Elle sert à générer des labyrinthe aléatoirement

“”"

try:
import sys
import random

except ImportError, err:
print “Couldn’t load module. %s” % (err)
sys.exit(2)

fonctions utiles ensuite

def genListCaseAleatoire(longueur):
""" retourne une liste de cases aléatoire de longueur longueur"""
ligne = []
for i in range(longueur):
ligne.append(Case())
return ligne

class Case:
""“Définit une case du labyrinthe par :
- ses 4 murs (Fermés : 0 ou Ouverts : 1)
Chaque mur correspond au mur Nord,Est,Sud,Ouest
- La valeur de la case, servant à faire le labyrinthe
”""
def init(self):
# Tous les murs sont fermés par défaut
self.N = 0
self.E = 0
self.S = 0
self.O = 0
#self.indice = random.randint(1, 1000)
self.indice = random.random()

def __repr__(self):
    return "Mur N:{0}, E:{1}, S:{2}, O:{3}, indice :{4}".format(self.N, self.E, self.S, \
                                 self.O, self.indice)

def ouvrir(self, orientation):
    """Méthode pour casser les murs
    On donne en argument l'orientation du mur à casser
    N,E,S ou O
    mod sert à inverser l'orientation si il est égal à -1
    """
    if orientation == "N":
        self.N = 1
    elif orientation == "E":
        self.E = 1
    elif orientation == "S":
        self.S = 1
    elif orientation == "O":
        self.O = 1

class Laby:
""“Le labyrinthe contenant les cases. Le construire va demander
du boulot!
”""

def __init__(self, sx,sy, ex,ey, depart, arrivee):
    """ notre labyrinthe va de sx, sy
    à ex, ey.
    La case de départ est un tuple depart
    La case d'arrivée est un tuple arrivee
    """
    self.longY = ey - sy                               # Dimensions du labyrinthe
    self.longX = ex - sx 
    #self._l = [[Case()]*self.longX]*self.longY         # un labyrinthe contenant le bon nombre de cases l[y][x]
    self._l = []         
    for i in range(self.longY):
        self._l.append(genListCaseAleatoire(self.longX))

def __repr__(self):
    return "Labyrinthe de largeur : {0} et de longueur : {1}".format(self.longX, self.longY)

def _get_pos(self, X, Y):
    """ Méthode pour accéder à une case du laby placée
     en X et Y du plateau
     Cela retourne donc un objet de type Case
    """
    return self._l[Y][X]

def _get_laby(self):
    return self._l

def fini(self):
    """Renvoie True si toutes les cases ont le même indice"""
    i = self._get_pos(0, 0).indice      # On regarde l'indice de la première case
    for casei in self._l:               # Toutes les cases de la casei colonne
        for casej in casei:             # Toutes les lignes de la casej colonne
            if casej.indice != i:       # On compare les indices
                return False
    return True

def parcour(self):
    """ renvoie une liste des cases"""
    listeCase = []
    for i in self._l:
        for j in i:
            listeCase.append(j)
    
    return listeCase


def construire(self):
    """On va construire notre labyrinthe.
    L'algorithme est le suivant : 
        On prend une case au hasard,
        on prend une direction au hasard
        On vérifie que la case suivante existe
        on regarde si les deux cases on le même indice (déja visitées)
        Si oui, on recommence
        Si non, on ouvre le mur entre ces cases
            et on met égaux l'indice des deux cases.
        On s'arrête lorsque toutes les cases ont le même indice"""


    while self.fini() != True:
        # Une case au hasard
        alX = random.randrange(0, self.longX)
        alY = random.randrange(0, self.longY)
        case = self._get_pos(alX, alY)

        # Direction au hasard
        possibilite = ["N","E","S","O"]
        while True:
            di = random.choice(possibilite)
            if di == "N":
                nalX, nalY = alX, alY + 1
            elif di == "S":
                nalX, nalY = alX, alY - 1
            elif di  == "E":
                nalX, nalY = alX + 1, alY 
            elif di == "O":
                nalX, nalY = alX - 1, alY 

            try:
                ncase = self._get_pos(nalX, nalY)
                possibilite = ["N","E","S","O"]
                break
            except : # la case suivante n'existe pas
                possibilite.remove(di)

       # on regarde si les deux cases adjacentes ont le même indice 
        if case.indice != ncase.indice :
           case.ouvrir(di)
           if di == "N":
               ncase.ouvrir("S")
           elif di == "S":
               ncase.ouvrir("N")
           elif di == "E":
               ncase.ouvrir("O")
           elif di == "O":
               ncase.ouvrir("E")
           for i in self.parcour():
               if i.indice == ncase.indice:
                   i.indice = case.indice

def main():

return 0

if name == ‘main’:
main()

vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

[/code]