IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

[Python 3.X] Appel aléatoire de modules


Sujet :

Python

  1. #1
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut [Python 3.X] Appel aléatoire de modules
    Bonjour,
    Si certains l'ont déjà lu dans une autre discussion, je suis en train de faire une espèce de jeu coopératif pour mes enfants avec un raspberry.
    J'ai plusieurs mini jeux (boutons, LEDs, son, etc) et pour chaque mini jeu j'ai créé un module à part entière. J'aurais donc un programme principal qui devra me lancer les différents modules.
    Afin d'éviter la monotonie, je me demandais s'il était possible d'appeler ces differents modules de façon aléatoire, le dernier devant toujours etre le même. J'ai 10 modules.
    Merci d'avance.

  2. #2
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Salut,

    Citation Envoyé par esope60 Voir le message
    Afin d'éviter la monotonie, je me demandais s'il était possible d'appeler ces differents modules de façon aléatoire, le dernier devant toujours etre le même. J'ai 10 modules.
    Oui c'est possible... Quel problème cela vous pose?

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  3. #3
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut
    Pour le moment je n'ai pas encore commencé à faire le programme principal, je me contente de faire mes 10 modules (j'en suis à la moitié).
    Je ne sais pas encore comment je vais appeler mes modules depuis mon programme principal (jamais fait), mais avant de le faire je souhaitais savoir si c'était possible de le faire aléatoirement.
    Déjà si on peut c'est pas mal, maintenant faut je trouve comment.
    Merci

  4. #4
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Pour choisir aléatoirement entre une liste de N objets, on peut toujours utiliser random.choice.
    Et comme avec Python tout est objet, les modules aussi (et la difficulté est ailleurs).

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  5. #5
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Pour choisir aléatoirement entre une liste de N objets, on peut toujours utiliser random.choice.
    Et comme avec Python tout est objet, les modules aussi (et la difficulté est ailleurs).

    - W
    Merci,
    Du coup si je veux être sûr que chaque module soit exécuté, et une seule fois il faudrait que je fasse un truc dans ce style :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    liste_modules = [module1.py, module2.py, module3.py, ... , module10.py]
    mini_jeux = random.sample(liste_modules, 10)
    puis éventuellement utiliser subprocess.call("start python" mini_jeux[0])

    sauf que je ne peux pas mettre des name.py dans la liste, et je ne sais pas si c'est propre de lancer les modules comme ça.
    Après c'est peut petre pas un bon choix de ma part d'avoir décomposé les mini-jeux en différents modules, je ne sais pas je manque de méthodologie.

  6. #6
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Citation Envoyé par esope60 Voir le message
    Après c'est peut petre pas un bon choix de ma part d'avoir décomposé les mini-jeux en différents modules, je ne sais pas je manque de méthodologie.
    Un "module" est une chose Python décrite ici.
    La chose lancée par subprocess.call s'appelle un programme externe et si ce programme s'appelle "python",
    [module1.py, module2.py, ... , module10.py] seront des scripts, i.e. des fichiers et donc des chaînes de caractères: [ "module1.py", "module2.py", "module3.py", ... , "module10.py" ].
    Désolé mais toute technique a son vocabulaire. On peut l'ignorer et vivre sans mais pas facile de se faire comprendre lorsqu'on essaie d'échanger des idées dans un forum de discussion ou de chercher la solution à un problème sur Internet (avec quels mots le décrire?).
    note: ouvrez une recette de cuisine une "brunoise de carotte" n'a rien à voir avec une julienne. De même que dans les métiers du bois, ciseaux, bédanes ou gouges se ressemblent mais ont des usages très différents.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  7. #7
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut
    Merci pour tes lumières,
    Je vais donc plutôt faire en sorte qu'il n'y ait que des fonctions dans les modules et les exécuter après avoir importer les différents modules.

    Cependant meme si je suis loin d'etre un expert, j'essaie de m'exprimer au mieux mais en effet je ne connais pas tout et manque de connaissance.
    C'est marrant que tu parles de métier du bois, étant assez actif sur un forum qui traite du bois, on aide tout le monde. Certains ont des ateliers pros, d'autres n'ont que le minimum, des fois même pas. Certains viennent avec leur question pour monter une étagère sans connaissance, d'autres plus avertis ont pour projet des meubles avec des assemblages très techniques. Ce n'est pas grave si quelqu'un se trompd et appelle une scie radiale scie plongeante, on lui explique (comme tu l'as fais pour moi). La personne qui a un besoin à l'instant t et ne deviendra jamais un pro du bois n'a pas nécessairement besoin de savoir si le taux d'hygrométrie de son bois respecte telle spécification, etc.
    Ce que je veux dire c'est que je ne deviendrais jamais un pro du Python, je n'ai pas le temps pour ça, et que j'essaie juste de me dépatouiller pour faire fonctionner un projet, même si c'est pas très bien codé, pas bien optimisé, n'étant pas puriste dans le domaine ça ne me dérange pas.
    Mais je comprends que tu sois un peu lassé des gens qui te questionnent sans trop chercher sur le forum.

    En tout cas merci de ton aide, tu as répondu à mes interrogations 😉

  8. #8
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut
    Bonjour à tous,
    je ne parviens toujours pas à faire ce que je veux.
    En fait importer les modules de façon aléatoire ne me sert à rien (ou alors il faudrait que je les décharges au fur et à mesure que je les importe avec "del" mais je ne sais pas si c'est propre. Ce sont les fonctions que j'ai besoin d'exécuter aléatoirement.
    J'aimerais faire quelque chose comme ça:

    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
    23
    #!/usr/bin/python
    # -*- coding: latin-1 -*-
    import random
     
     
    def fonc1():
        print("fonction 1")
     
    def fonc2():
        print("fonction 2")
     
    def fonc3():
        print("fonction 3")
     
    liste_fonc = [fonc1, fonc2, fonc3]
    #mélanger l'ordre des fonctions
    alea = random.sample(liste_fonc,3)
    print(alea)
     
    #Exécuter les fonction dans le nouvel ordre
    alea[0]
    alea[1]
    alea[2]
    Si je mets les nom de fonction directement comme ça, le print (alea) me retourne
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    [<function fonc2 at 0x000000000365FE18>, <function fonc3 at 0x000000000365FEA0>, <function fonc1 at 0x0000000003670E18>]
    Probablement normal, mais les appels alea[0], etc ne font rien.

    Et si je les nomme avec des guillemets ce ne sont plus des fonctions mais juste du string.

    Donc j'imagine qu'on doit pouvoir faire la meme chose mais peut-être pas avec des liste.
    Merci d'avance

  9. #9
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Salut,

    Citation Envoyé par esope60 Voir le message
    Probablement normal, mais les appels alea[0], etc ne font rien.

    Et si je les nomme avec des guillemets ce ne sont plus des fonctions mais juste du string.
    alea[0] est un objet de type fonction et pour appeler une fonction, il faut des parenthèses i.e. écrire alea[0]().
    note: fonc1 retournerait aussi <function fonc1 at 0x...> et pour l'appeler vous faites bien func1()La seule différence est que "func1" est une variable globale associée à un objet fonction, i.e. le chemin par lequel on arrive à l'objet qu'on veut "appeler".

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  10. #10
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Salut,



    alea[0] est un objet de type fonction et pour appeler une fonction, il faut des parenthèses i.e. écrire alea[0]().
    note: fonc1 retournerait aussi <function fonc1 at 0x...> et pour l'appeler vous faites bien func1()La seule différence est que "func1" est une variable globale associée à un objet fonction, i.e. le chemin par lequel on arrive à l'objet qu'on veut "appeler".

    - W
    Super, ça marche avec les parenthèse, j'ai tous les éléments maintenant.
    merci beaucoup.

    J'ai une question organisationnelle. J'ai 3 possibilités:

    1) un programme principal qui fait des subprocess.call des différents scripts.py (1 script = 1 mini-jeu, 11 scripts en tout))
    2) un programme principal qui exécute les fonctions importées d'un module, puis déchargés avant de réimporter les fonctions du module suivant.
    3) un programme principal qui importe en une fois toutes les fonctions du module (dans ce cas plus qu'un seul fichier regroupant toutes les fonctions), et les exécute dans un ordre donné.

    Sachant que pour quasiment tous les modules (mini-jeu) j'ai besoin d'un petit thread différent qui tourne en boucle (toujours un seul thread à la fois, qui s'arrête a la fin du mini-jeu).

    Je ne sais pas si c'est clair, j'ai essayé de nommer au mieux les éléments. je cherche la solution la plus propre.

    Je peux vous montrer un exemple type pour un module (désolé si c'est codé avec les pieds). Dans ce jeu, j'ai 6 boutons poussoirs de couleur différente.
    Une séquence de couleur est généré aléatoirement au début du jeu, puis, le téléphone sonne (vrai combiné connecté en JACK). Après appui sur un bouton pour décrocher, la sequence de couleurs est énoncée verbalement. ceci est dans mon thread qui tourne en boucle.
    Dans le code principale qui a lancé mon thread, j'attends les appuis sur les boutons. Si le premier est bon, passer au suivant, si on se trompe au 4ème, on recommence tout. quand la succession d'appui correspond à la séquence, le thread s'arrête, et le jeu avec.
    Pour moi c'est toute la partie sous "if __name__ == "__main__":" que je devrais mettre dans une fonction si je n'utilise pas la méthode des call module.py

    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
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    #!/usr/bin/python
    # -*- coding: latin-1 -*-
     
    #import des modules nécessaires
    import RPi.GPIO as GPIO
    import time
    import random
    import pygame
    from threading import Thread
     
    #ignorer les avertissements liés aux GPIOs
    GPIO.setwarnings(False)
    #nommage GPIO en BCM
    GPIO.setmode(GPIO.BCM)
     
    #importer les méthodes de la procédure du module pour les SR
    from shiftpi.shiftpi import HIGH, LOW, ALL, digitalWrite, shiftRegisters, delay, pinsSetup
    #indiquer que l'on travaille avec 8 shift registers
    shiftRegisters(8)
    #mettre toutes les sorties du SR à zéro
    digitalWrite(ALL, LOW)
    #6 lignes à retirer quand les LED RGB seront placées par des cathode communes.
    digitalWrite(51, HIGH)
    digitalWrite(52, HIGH)
    digitalWrite(53, HIGH)
    digitalWrite(54, HIGH)
    digitalWrite(55, HIGH)
    digitalWrite(56, HIGH)
     
     
    ##############
    ##############
     
    #importer le module pour la gestion du mcp13017 (ajout GPIOs en entré/sortie)
    import Adafruit_GPIO.MCP230xx as MCP
    #définir la variable 'mcp' avec les paramètres et adresse en 000
    mcp1 = MCP.MCP23017(address = 0x21, busnum = 1)
    #définir les 10 entrées pour les 10 boutons à l'état haut avec résistance de pull up
    #Interrupteur 0
    mcp1.pullup(0, 1)
    mcp1.pullup(1, 1)
    mcp1.pullup(2, 1)
    mcp1.pullup(3, 1)
    mcp1.pullup(4, 1)
    mcp1.pullup(5, 1)
    mcp1.pullup(6, 1)
    mcp1.setup(0, GPIO.IN)
    mcp1.setup(1, GPIO.IN)
    mcp1.setup(2, GPIO.IN)
    mcp1.setup(3, GPIO.IN)
    mcp1.setup(4, GPIO.IN)
    mcp1.setup(5, GPIO.IN)
    mcp1.setup(6, GPIO.IN)
     
    correspondance = {}
    correspondance["rouge"] = 0
    correspondance["jaune"] = 1
    correspondance["bleu"] = 2
    correspondance["vert"] = 3
    correspondance["blanc"] = 4
    correspondance["noir"] = 5
     
     
    liste_couleurs = ["rouge","jaune","bleu","vert","blanc","noir"]
    melange_couleurs = random.sample(liste_couleurs,6)
     
     
     
    ######
     
    run = True
     
    def sequence():
        global run
        while run:
            print("jouer les sons")
            #Jouer les son dans l'ordre défini et en boucle
            for j in range(0, 5):
                pygame.mixer.music.load(melange_couleurs[j] + ".mp3")
                pygame.mixer.music.play()
                while pygame.mixer.music.get_busy() == True:
                    continue
            time.sleep(2)
     
    if __name__ == "__main__":
        sonne = True
        #tant que le téléphone n'est pas décroché, faire sonner.
        while sonne :
            pygame.mixer.init()
            pygame.mixer.music.load("sonne.mp3")
            pygame.mixer.music.play()
            if mcp1.input(6) == False :
                sonne = False
            time.sleep (0.02)
     
        #Penser à ajouter les transistors pour stopper le son des L et R
        #Lancer le thread indiquant la sequence vocale.
        Thread(target=sequence).start()
     
        try:
            i = 0
            while i < 6:
                print(melange_couleurs)
                #Si le bouton appuyé est de la bone couleur, passer au suivant
                if mcp1.input(correspondance[melange_couleurs[i]]) == False :
                    i += 1
                    time.sleep(0.5)
                #Sinon tout recommencer
                elif mcp1.input(0) == False or mcp1.input(1) == False or mcp1.input(2) == False or mcp1.input(3) == False or mcp1.input(4) == False or mcp1.input(5) == False:
                    i = 0
                    time.sleep(0.5)
                time.sleep(0.02)
     
                print("gagné")
                run = False
     
     
        #Prise en compte d'une sortie de script par appui sur Ctrl+C
        except KeyboardInterrupt:
            print("Programme interrompu par Ctrl+C !")
     
        #Reinitialisation des ports GPIO, quelque soit la facon dont se termine le script
        finally:
            GPIO.cleanup()

  11. #11
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 283
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 283
    Points : 36 770
    Points
    36 770
    Par défaut
    Salut,

    Citation Envoyé par esope60 Voir le message
    J'ai une question organisationnelle. J'ai 3 possibilités:

    1) un programme principal qui fait des subprocess.call des différents scripts.py (1 script = 1 mini-jeu, 11 scripts en tout))
    2) un programme principal qui exécute les fonctions importées d'un module, puis déchargés avant de réimporter les fonctions du module suivant.
    3) un programme principal qui importe en une fois toutes les fonctions du module (dans ce cas plus qu'un seul fichier regroupant toutes les fonctions), et les exécute dans un ordre donné.
    La différence entre 2 et 3 est qu'au lieu d'avoir N modules et une fonction bien définie (dont le nom peut être identique dans les différents modules) à appeler, vous avez 1 modules et N fonctions.
    Une autre différence, c'est ajouter un jeu avec la possibilité de le tester "à part" avant de le charger dans le programme principal.

    La grande différence entre des subprocess et des threads, c'est la remise en état du bazard pour passer au jeu suivant (mais comme les registres du GPIO sont "globaux" çà risque de ne pas changer grand chose).

    Il n'y a pas de bon choix, ou plutôt poser vous la question de savoir quel découpage vous semble le plus confortable pour diagnostiquer/corriger un problème.
    note: il n'est pas interdit non plus de "mixer" les genres i.e. avoir un peu de subprocess, un peu d'import dédié, un peu d'import partagé.

    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  12. #12
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    Août 2015
    Messages
    43
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Eure (Haute Normandie)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2015
    Messages : 43
    Points : 30
    Points
    30
    Par défaut
    Citation Envoyé par wiztricks Voir le message
    Une autre différence, c'est ajouter un jeu avec la possibilité de le tester "à part" avant de le charger dans le programme principal.
    - W
    C'est vrai que l'option 3 est à abandonner tout de suite en effet, pouvoir tester un module seul est primordial.

    Citation Envoyé par wiztricks Voir le message
    la remise en état du bazard pour passer au jeu suivant (mais comme les registres du GPIO sont "globaux"
    Tout à fait, que ce soit les entrées, sorties, carte son, afficheur 7 segments, etc. tout est reparamétrable au début de chaque script donc pas gênant.


    ==> Étant donné que je n'ai pas besoin de retour sur mon programme principal (bien sûr si je gère correctement les erreurs sur les différents scripts), je partirais donc sur un programme principal qui lance mes scripts aléatoirement avec dans chacun des scripts ses imports propres, un thread défini dans une fonction, et le programme qui s'exécute derrière.

    Voici à quoi pourrait ressembler mon programme principal:

    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
    23
    24
    25
    26
    27
    28
    #!/usr/bin/python
    # -*- coding: latin-1 -*-
    from subprocess import call
    import random
    import pygame
     
    #vérifier que le câble entre les deux pupitres sont bien connectés. Sinon jouer un son d'instruction.
    ##pygame.mixer.init()
    ##    pygame.mixer.music.load("branchement.mp3")
    ##    pygame.mixer.music.play()
    ##    while pygame.mixer.music.get_busy() == True:
    ##        continue
     
    jouer = True
    while jouer :
        liste_scripts = ["module1", "module2","module3","module5", "module6","module7", "module8","module9", "module11"]
        #mélanger l'ordre des scripts
        alea = random.sample(liste_scripts,9)
        print(alea)
     
        #lancer les scripts dans l'odre défini par alea
        for i in range (0, len(alea)):
            call("python " + alea[i] + ".py")
        #puis toujours lancer les modules 4 et 10 en dernier
        call("python module4.py")
        call("python module10.py")
        print("gagné")
        #Trouver une combinaison d'interrupteurs pour refaire une partie ou arrêter et éteindre le raspberry
    Merci de ton aide, elle a été précieuse.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Joomla!] Appel d'un module dans un composant
    Par metwa dans le forum EDI, CMS, Outils, Scripts et API
    Réponses: 1
    Dernier message: 29/12/2009, 09h57
  2. Appel d'un module a partir d'une macro 'module'
    Par lilp1 dans le forum Macros et VBA Excel
    Réponses: 3
    Dernier message: 15/05/2009, 10h19
  3. [1.x] symfony 1.2 [propel] appel d'un module dans un autre module
    Par sonja dans le forum Symfony
    Réponses: 1
    Dernier message: 26/03/2009, 00h02
  4. appel d'un module
    Par PC81 dans le forum VBA Access
    Réponses: 11
    Dernier message: 29/04/2008, 09h33
  5. appel d'un module externe avec argument en entree
    Par oursblanc dans le forum Modules
    Réponses: 6
    Dernier message: 20/10/2005, 23h16

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo