Bonjour,

j'ai écrit un code permettant de générer un arbre avec ses sommets et ses arêtes. Le problème est que je ne sais pas comment dessiner concrètement cet arbre. Quelqu'un connaît-il un package ou bien un programme qui permettrait d'entrer les sommets (entiers naturels) et les liaisons afin d'obtenir le graphique ?

Merci pour votre aide.

Tu as par exemple ce module, qui est une interface python pour graphviz.

Merci pour ta réponse. Malheureusement, je n'arrive pas à installer le module alors que je suis arrivé à installer Graphviz...

En fait, j'ai réussi à écrire ce programme qui génère des connexions entre nombres entiers (toujours mon histoire de labyrinthe où les connexions correspondent à des murs qui tombent).

#ALGORITHME DE GENERATION DU GRAPHE INITIAL

#Choix de la taille du labyrinthe
n = int(input("Saisir la taille de votre labyrinthe : "))

#Création de la liste de 16 éléments
liste_sommets = list(range(1, n**2+1))
print(liste_sommets)



#Définition de la fonction voisinage
def voisins(k):
#Définition des voisins des quatre coins
    if k==1:
        n1=k+1
        n2=k+n
        liste_voisins=[n1, n2]
    elif k==n:
        n1=k-1
        n2=k+n
        liste_voisins=[n1, n2]
    elif k==n**2-n+1:
        n1=k-n
        n2=k+1
        liste_voisins=[n1, n2]
    elif k==n**2:
        n1=k-n
        n2=k-1
        liste_voisins=[n1, n2]

#Définition des voisins du bord nord
    elif 1<k<n:
        n1=k-1
        n2=k+1
        n3=k+n
        liste_voisins=[n1, n2, n3]

#Définition des voinsins du bord sud
    elif n**2-n+1<k<n**2:
        n1=k-n
        n2=k-1
        n3=k+1
        liste_voisins=[n1, n2, n3]

#Définition des voinsins du bord ouest
    elif 1<k<n**2-n+1 and k%n==1:
        n1=k-n
        n2=k+1
        n3=k+n
        liste_voisins=[n1, n2, n3]

#Définition des voinsins du bord est
    elif n<k<n**2 and k%n==0:
        n1=k-n
        n2=k-1
        n3=k+n
        liste_voisins=[n1, n2, n3]

#Définition des voinsins intérieurs
    else:
        n1=k-n
        n2=k-1
        n3=k+1
        n4=k+n
        liste_voisins=[n1, n2, n3, n4]

    return liste_voisins
    #print("les voisins de", k, "sont :", liste_voisins)
    



#Boucle de fonctionnement
#k = 1
#while k < len(liste_sommets)+1:
    #voisins(k)
    #k += 1

et

import random
from graphe_initial import voisins

#L1 est la liste des voisins choisis
#L2 est la liste des voisins possibles à chaque tour de boucle
#L3 est la listes des voisins connectables à S (dernier rentrant dans la liste L1)
#S est le voisin choisi au hasard dans L2 et il vient dans L1
#T est l'élément choisi de la liste L3 venant se connecter à D

L1 = [1]

L2 = voisins(1)

while L2 != []:
    
    #On choisit au hasard un voisin à ajouter dans l'arbre
    S = random.choice(L2)
    
    #On supprime S de L2
    L2.remove(S)
    
    #On l'ajoute à L1
    L1.append(S)
    
    #On ajoute à L2 les voisins de S
    for i in range(len(voisins(S))):        
        if voisins(S)[i] not in L2:
            L2.append(voisins(S)[i])
            
            #On supprime de L2 les éléments appartenant déjà à L1
            for j in range(len(L2)):        
                if L2[j] in L1:
                    del L2[j]

    #On créé la liste des voisins connectables à S et on en choisit un au hasard                
    E3 = set.intersection(set (voisins(S)), set (L1))
    L3 = list(E3)
    T = random.choice(L3)
    
    
    #print("La liste L1 est :", L1)
    #print("La liste L2 est :", L2)
    #print("La liste L3 est :", L3)
    print(S, "est connecté à", T)
    print()
    print()

En fait, je voudrais générer un carré nxn contenant les connexions entre les entiers données par le programme.

Y a t-il un moyen simple d'y arriver ?

Merci !!