Aide pour débutant

**snip001** · 08/04/2014, 11h47

je suis une bille en python ,bien que sa me semble très utiles ,j'ai encore bcp de mal a effectuer les taches qui me sont demander
ainsi pour un cours ,je dois réaliser plusieurs exercice ,peut être pourrait vous m'expliquer la bonne méthode car je cherche ,je cherche mais les erreur d'indentation et les résultat contraire a ceux souhaite sont vraiment démoralisant
comme support d'aide j'utilise principalement 3 source de cours
-http://www.cgmaths.fr/Atelier/Programmation/ProgPythonV2/ProgPython2.pdf
-http://calamar.univ-ag.fr/uag/ufrsen/coursenligne/vpage/new_site/cours/ISN/apprendre_python3.pdf
-http://www.dsimb.inserm.fr/~fuchs/python/cours_python.pdf
et bien sur ce site developpez.net

voila bon
Q1 : entrer des note et les cumuler ,j'ai réussie

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
cumul =0
import easygui
for i in range (10) :
    note = easygui.integerbox ('saisir une note ' +str (i) + 'i' )
    cumul=cumul+note
moyenne = cumul/10
print (moyenne)
 
if note >20 :
print (error)

Q2 : elle consister a écrire un programme qui test si un entier saisi par l'utilisateur est multiple de 7
je pense avoir trouver la méthode
il fallait ensuite faire en sorte que sa soit répétable (avec la fct continue et break pour finir)
je pense donc que sa doit donner sa :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
import easygui
a = easygui.integerbox ( 'saisir un entier : ')                                     # la personne entrera un entier
while a != 0:                                                                               #quand a différent de 0
for a in range(20):                                                                      #cette valeur sera compris dans un intervalle 0;20]
 if a % 7 == b :                                                                        #on divise la valeur rentrer par 7
 and if b % a == 0                                                                   #on divise le reste par la valeur insérer ,si c'est = a  0
 print ('la valeur est multiple de 7' )                                          #le programme affichera la valeur est multiple de 7
 else                                                                                   #sinon
 print ('la valeur n est pas multipe de 7' )                              #affiche la valeur n'est pas multiple de 7
continue                                               #après avoir afficher si multiple ,on recommence redemande une valeur
 
while a = 0:                                                                   #si valeur entrer est 0
    break                                                                        #le programme s’arrête

sa devrait marcher mais ...non

Q3: un programme qui demande à l’utilisateur de saisir un numéro de mois (entre 1 et 12 donc) et qui affiche le mois correspondant en toutes lettres.
la encore ,je sais comment faire une liste ,supprimer un élément d'une liste ou utiliser plusieurs liste pour obtenir une nouvelle liste (exemple liste mois + liste jour = liste moi avec nbre de jour)
mais faire insérer une valeur (un indice ) et obtenir la n-ieme valeur de la liste qui correspond a l'indice ,j'arrive pas
je sais que sa sera l'indice +1 ,car sinon il y aurais erreur du faite que janvier sera l'indice 0 et qu'on veut l'obtenir pour la saisie de 1 (bien sur les valeur rentrée ne seront que dans l'intervalle 1-12,donc le 0 ne peut etre saisie
j'arrive pas a formaliser... en + il faudrait en faire une version avec liste et une sans liste

Ainsi comme bcp j'ai eu droit au jeux final des allumette mais la vue mes difficulté a appréhender le début
je cherche encore ...
"le jeu se joue à deux joueurs. On considère un tas de n allumettes. À tour de rôle, chaque joueur va retirer du tas entre 1 et p allumettes (p est fixé au départ et est très inférieur à n évidemment, sinon le jeu perd tout son intéret). Le joueur qui retire la dernière allumette a gagné."

pour l'instant si vous pouviez m'indiquer mon erreur sur le multiple de 7 et quelques conseil pour l'extraction a partir de la liste ,je vous serais reconnaissant

a ce niveau ,je ne peux que progresser avec python ,la régression n'est pas une option ^^

**VinsS** · 08/04/2014, 11h50

Salut,

Il serait bien de mettre tes codes entre balises, surtout si tu dis que tu as des erreurs d'indentation.

**snip001** · 08/04/2014, 11h58

voila ,j'ai mis les balise ,c'est tout de suite plus clair ,merci

pour ceux qui aurait remarquer ,j'utilise pas tkinter ,on utilise easygui ,
j'ai d'ailleurs eu un peu de mal a l'installer sur mon ordinateur
j'avais donc du mal a tester les programmes chez moi ,je ne pouvais les tester qu'a mon université

**wiztricks** · 08/04/2014, 14h18

Salut,

Si vous débutez en Python, pas la peine d'essayer de programmer avec un GUI: input/raw_input pour saisir les données utilisateurs suffisent largement. Relisez le code que vous avez posté pour la question 2: l'indentation cloche et en Python c'est important.

Bon courage
- W

**Sve@r** · 08/04/2014, 18h13

Bonjour

Envoyé par snip001

Q2 : elle consister a écrire un programme qui test si un entier saisi par l'utilisateur est multiple de 7
je pense avoir trouvé la méthode
il fallait ensuite faire en sorte que ça soit répétable (avec la fct continue et break pour finir)
je pense donc que ça doit donner ça :

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
import easygui
a = easygui.integerbox ( 'saisir un entier : ')                                     # la personne entrera un entier
while a != 0:                                                                               #quand a différent de 0
for a in range(20):                                                                      #cette valeur sera comprise dans un intervalle 0;20]
 if a % 7 == b :                                                                        #on divise la valeur rentrée par 7
 and if b % a == 0                                                                   #on divise le reste par la valeur insérée ,si c'est = a  0
 print ('la valeur est multiple de 7' )                                          #le programme affichera la valeur est multiple de 7
 else                                                                                   #sinon
 print ('la valeur n est pas multipe de 7' )                              #affiche la valeur n'est pas multiple de 7
continue                                               #après avoir affiché si multiple ,on recommence redemande une valeur
 
while a = 0:                                                                   #si valeur entrée est 0
    break                                                                        #le programme s’arrête

ça devrait marcher mais ...non

Punaise, quelle orthographe. Les participes passés c'est du passé et bon les démonstratifs on s'en fout... C'est quand-même pas compliqué de se souvenir que "sa" est un possessif inquant "la sienne" (sa voiture, sa maison, sa femme) et que le démonstratif s'écrit "ça" (raccourci de "cela"). On l'apprend au primaire ça !!!
Bien écrire est une marque de respect ; et donc écrire comme un pied montre que t'en as rien à foutre de ceux qui te liront à "lagguer" sans cesse sur un texte à revenir au début de la phrase parce que le sens des mots va à l'encontre du sens général de celle-ci.
Sinon ton code je ne vois pas comment il "devrait" marcher. Déjà question syntaxe if expression : and if expression...

et ensuite question logique tu fais saisir "a" puis à la ligne du dessous tu l'écrases. Tu fais intervenir b qu'on ne connait ni d'Eve, ni d'Adam, et en plus ton test sur la divisibilité est aberrant . A tout hasard, quand a commence sa (ici c'est bien de "la sienne" que je parle) boucle à 0, quelle que soit la valeur de b je serais curieux de savoir ce que donnera le résultat de b % a (reste d'une division par 0 ???)
Tu pourrais par exemple nous donner la base mathématique que tu as utilisée pour établir ce test ???

Et en final tu mets une boucle pour faire un simple test. A ce niveau ce n'est même plus un problème Python mais carrément un problème de réflexion (à quoi sert une boucle, comment établir une alternative, comment organiser tous ces composants pour produire un algorithme solutionnant le problème, etc)...

Envoyé par snip001

Q3: un programme qui demande à l’utilisateur de saisir un numéro de mois (entre 1 et 12 donc) et qui affiche le mois correspondant en toutes lettres.
la encore ,je sais comment faire une liste ,supprimer un élément d'une liste ou utiliser plusieurs liste pour obtenir une nouvelle liste (exemple liste mois + liste jour = liste moi avec nbre de jour)
mais faire insérer une valeur (un indice ) et obtenir la n-ieme valeur de la liste qui correspond a l'indice ,j'arrive pas
je sais que sa sera l'indice +1 ,car sinon il y aurais erreur du fait que janvier sera l'indice 0 et qu'on veut l'obtenir pour la saisie de 1 (bien sur les valeur rentrée ne seront que dans l'intervalle 1-12,donc le 0 ne peut etre saisie

print mois[n-1]

Envoyé par snip001

a ce niveau ,je ne peux que progresser avec python ,la régression n'est pas une option ^^

Ouais, je confirme. A ce niveau, tu ne peux que progresser ; la régression est physiquement impossible !!!

**snip001** · 17/05/2014, 11h51

hum merci pour les critiques ,ça fait toujours plaisir ,au final j'ai jamais eu d'aide
pour ceux qui aurait les même questions ,je vais donner les correction ça aidera surement les débutants comme moi
je rajoute le calcul de moyenne et des solution a la création du jeux des allumettes puisque ces question sont souvent poser à ce que j'ai vue

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
# saisie du nombre de notes
nbnotes = easygui.integerbox('Nombre de notes : ',lowerbound=1)
if nbnotes == None:
    # L'utilisateur a appuyé sur Cancel
    easygui.msgbox("Opération annulée !")
    sys.exit(0)
 
# saisie des notes et cumul de celles-ci
cumul = 0.0
for i in range(nbnotes):
    saisie_ok = False
    note = easygui.integerbox('Note '+str(i+1)+': ',
                              lowerbound=0,
                              upperbound=20)
    if note == None:
        # L'utilisateur a appuyé sur Cancel
        easygui.msgbox("Opération annulée !")
        sys.exit(0)
    cumul += note
 
# calcul de la moyenne
moyenne = cumul / nbnotes 
 
affichage = [
    'Moyenne : '+ str(moyenne)
    ]
 
easygui.textbox(title='Résultat',text=affichage)

suivante :

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
 
# Test de la divisibilité par 7, tant que l'utilisateur le souhaite.
# Pour s'arrêter, il suffit d'appuyer sur le bouton Cancel
# (ou la touche "Echap"), puisque dans ce cas la fonction integerbox
# renvoie la valeur None
import easygui
import sys
 
nb = 0
while nb != None:
    nb = easygui.integerbox("Saisissez un entier:")
    if nb != None:
        if (nb % 7) == 0:
            easygui.msgbox('Le nombre '+str(nb)+' est divisible par 7')
        else:
            easygui.msgbox('Le nombre '+str(nb)+" n'est pas divisible par 7")

maintenant avec et sans liste ,recuperer une donnée :

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
Première version : utilisation du if.
# Affichage du mois en toutes lettres : version avec "if".
import easygui
import sys
 
# la saisie est validée par la fonction integerbox
# grâce aux paramtres lowerbound (borne inférieure)
# et upperbound (borne suppérieure)
nb = easygui.integerbox("Saisissez un numéro de mois",
                        lowerbound=1, upperbound=12)
if nb == None:
    # l'utilisateur a appuyé sur Cancel, on sort.
    sys.exit(1)
 
mois = ""
if nb == 1:
    mois = "Janvier"
elif nb == 2:
    mois = "Février"
elif nb == 3:
    mois = "Mars"
elif nb == 4:
    mois = "Avril"
elif nb == 5:
    mois = "Mai"
elif nb == 6:
    mois = "Juin"
elif nb == 7:
    mois = "Juillet"
elif nb == 8:
    mois = "Aout"
elif nb == 9:
    mois = "Septembre"
elif nb == 10:
    mois = "Octobre"
elif nb == 11:
    mois = "Novembre"
elif nb == 12:
    mois = "Décembre"
 
easygui.msgbox("Le mois numéro " + str(nb) + " est " + mois)
 
 
Seconde version : utilisation d'une liste.
# Affichage du mois en toutes lettres : version avec liste.
import easygui
 
# on initialise une liste contenant les noms de tous les mois
# de l'année.
mois = [
    "Janvier",
    "Février",
    "Mars",
    "Avril",
    "Mai",
    "Juin",
    "Juillet",
    "Aout",
    "Septembre",
    "Octobre",
    "Novembre",
    "Décembre"
    ]
 
# la saisie est validée par la fonction integerbox
# grâce aux paramtres lowerbound (borne inférieure)
# et upperbound (borne suppérieure)
nb = easygui.integerbox("Saisissez un numéro de mois",
                        lowerbound=1, upperbound=12)
if nb == None:
    # l'utilisateur a appuyé sur Cancel, on sort.
    sys.exit(1)
 
easygui.msgbox("Le mois numéro " + str(nb) + " est " + mois[nb-1])

allumettes 2 joueurs :

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
#####################################################################
##
## Jeu des allumettes.
##
#####################################################################
import random
import sys
import easygui
 
 
##
## Prise en charge du choix d'un joueur : demande au joueur combien
## d'allumettes il veut retirer, en validant sa saisie.
##
## nbal : nombre d'allumettes actuellement dans le tas 
##
def choix_joueur(nbal,p,nbj):
    # si le nombre d'allumettes restant dans le tas est
    # infériur à p, alors limiter le nombre max d'allumettes
    # retirable
    max_possible = p
    if nbal < p:
        max_possible = nbal
 
    choix = easygui.integerbox('il reste ' + str(nbal) + ' allumettes\n' +
                               'joueur ' + str(nbj) + " combien d'allumettes ?",
                               lowerbound=1, upperbound=max_possible)
    return choix
 
###########################################################################
#### Le Programme commence vraiment à s'exécuter ici ######################
 
# n allumettes au départ
# on ne peut pas retirer plus de p allumettes
n = 20
p = 4
 
stock = n
# 0: pas de vainqueur, 1: le joueur 1 a gagné, 2: le joueur 2 a gagné
vainqueur = 0
 
# tant qu'il n'y a pas de vainqueur on bloucle.
while vainqueur == 0:
    # joueur 1
    choix1 = choix_joueur(stock,p,1)
    stock = stock - choix1
    if stock == 0:
        vainqueur = 1
    else:
        # joueur 2
        choix2 = choix_joueur(stock,p,2)
        stock = stock - choix2
        if stock == 0:
            vainqueur = 2
    if vainqueur != 0:
        easygui.msgbox("Le joueur " + str(vainqueur) + " a gagné")

allumette 2 :

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
#####################################################################
##
## Jeu des allumettes.
##
#####################################################################
import random
import sys
import easygui
 
# n allumettes au départ
# on ne peut pas retirer plus de p allumettes
n = 20
p = 4
 
##
## Prise en charge du choix d'un joueur : demande au joueur combien
## d'allumettes il veut retirer, en validant sa saisie.
##
## nbal : nombre d'allumettes actuellement dans le tas 
##
def choix_joueur(nbal,p,nbj):
    # si le nombre d'allumettes restant dans le tas est
    # infériur à p, alors limiter le nombre max d'allumettes
    # retirable
    max_possible = p
    if nbal < p:
        max_possible = nbal
 
    choix = easygui.integerbox('il reste ' + str(nbal) + ' allumettes\n' +
                               'joueur ' + str(nbj) + " combien d'allumettes ?",
                               lowerbound=1, upperbound=max_possible)
    return choix
 
 
##
## Une partie : traite une partie complète.
##
def partie():
    stock = n
    # 0: pas de vainqueur, 1: le joueur 1 a gagné, 2: le joueur 2 a gagné
    vainqueur = 0
 
    # tant qu'il n'y a pas de vainqueur on bloucle.
    while vainqueur == 0:
        # Le joueur 1 joue
        choix1 = choix_joueur(stock,p,1)
        stock = stock - choix1
        if stock == 0:
            vainqueur = 1
        else:
            # Le joueur 2 joue
            choix2 = choix_joueur(stock,p,2)
            stock = stock - choix2
            if stock == 0:
                vainqueur = 2
        if vainqueur != 0:
            easygui.msgbox("Le joueur " + str(vainqueur) + " a gagné")
 
 
## programme principal ############################################
## L'exécution commence ici ! #####################################
 
encore = 1
while encore:
    partie()
    encore = easygui.boolbox("Voulez vous rejouer ?")

allumette joueurs vs ordi :

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
 
#####################################################################
##
## Jeu des allumettes.
## Version "un joueur contre l'ordinateur" 
##
#####################################################################
import random
import sys
import easygui
 
# initialisation du générateur pseudo-aléatoire.
random.seed()
 
# n allumettes au départ
# on ne peut pas retirer plus de p allumettes
n = 20
p = 4
 
##
## Prise en charge du choix d'un joueur : demande au joueur combien
## d'allumettes il veut retirer, en validant sa saisie.
##
## nbal : nombre d'allumettes actuellement dans le tas 
##
def choix_joueur(nbal,p):
    # si le nombre d'allumettes restant dans le tas est
    # infériur à p, alors limiter le nombre max d'allumettes
    # retirable
    max_possible = p
    if nbal < p:
        max_possible = nbal
 
    choix = easygui.integerbox('Il reste ' + str(nbal) + ' allumettes\n' +
                               "Joueur humain, combien d'allumettes ?",
                               lowerbound=1, upperbound=max_possible)
    if choix == None:
        # le joueur a cliqué sur "Annuler" ou a tapé sur la touche "Echap"
        easygui.msgbox("Abandon du joueur (c'est pas glorieux !)")
        sys.exit(0)
 
    return choix
 
##
## stratégie de choix de l'ordinateur
##
def choix_ordi(nbal,p):
    choix = nbal % (p+1)
    if choix == 0:
        if (nbal < p):
            choix = random.randint(1,nbal)
        else:
            choix = random.randint(1,p)
 
    easygui.msgbox("il reste " + str(nbal) + " alumettes\n"
                   "Je retire " + str(choix) + " allumettes.")
    return choix
 
##
## Une partie
## le jouer commence
##
def partie():
    stock = n
    # 0: pas de vainqueur, 1: le joueur 1 a gagné, 2: le joueur 2 a gagné
    vainqueur = 0
 
    # tant qu'il n'y a pas de vainqueur on bloucle.
    while vainqueur == 0:
        choix1 = choix_joueur(stock,p)
        stock = stock - choix1
        if stock == 0:
            vainqueur = 1
        else:
            choix2 = choix_ordi(stock,p)
            stock = stock - choix2
            if stock == 0:
                vainqueur = 2
        if vainqueur != 0:
            if vainqueur == 1:
                easygui.msgbox("Le joueur humain a gagné")
            else:
                easygui.msgbox("J'ai gagné !")
 
 
## programme principal ############################################
 
 
encore = 1
while encore:
    partie()
    encore = easygui.boolbox("Voulez vous rejouer ?")

**Sve@r** · 17/05/2014, 12h56

Envoyé par snip001

hum merci pour les critiques ,ça fait toujours plaisir ,au final j'ai jamais eu d'aide
pour ceux qui auraient les même questions ,je vais donner les correction ça aidera surement les débutants comme moi
je rajoute le calcul de moyenne et des solution a la création du jeux des allumettes puisque ces question sont souvent posées à ce que j'ai vue

Code :

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

easygui.msgbox("Le mois numéro " + str(nb) + " est " + mois[nb-1])

Bon, ok, on ne dira pas qui t'a soufflé cette géniale formule de nb-1 qui traduit le fait que si un tableau commence à 0 et qu'une énumération humaine commence à 1, pour faire correspondre les éléments de l'énumération à ceux du tableau suffit de soustraire 1 à l'indice humain. Et à part ça ose dire qu'on t'a pas aidé...

Ceci dit, tu as des outils pour formatter du texte...

Code :

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

easygui.msgbox("Le mois numéro %d est %s" % (nb, mois[nb-1]))

Envoyé par snip001

allumette joueurs vs ordi :

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
 
##
## stratégie de choix de l'ordinateur
##
def choix_ordi(nbal,p):
    choix = nbal % (p+1)
    if choix == 0:
        if (nbal < p):
            choix = random.randint(1,nbal)
        else:
            choix = random.randint(1,p)
 
    easygui.msgbox("il reste " + str(nbal) + " alumettes\n"
                   "Je retire " + str(choix) + " allumettes.")
    return choix

Un code déjà bien mieux écrit que le premier. Toutefois on remarque que l'ordi joue au hasard. Remarque ça dépend contre qui il joue...

Le jeu des allumettes se pratique avec un nombre d'allumettes précis, directement multiple de "p+1" (p étant dans ton code le nombre d'allumettes max à pouvoir être pris d'un coup).
Exemple: si p=4 (p+1=5), alors le nombre d'allumettes sera au choix 5; 10; 15; 20; 25; 30; 35 (soit toujours un multiple de 5).

Avec ce nombre, si le joueur commence, il suffit à l'ordi de toujours faire le complément à 5. Le joueur en choisit 1, l'ordi en choisit 4. Et etc. Au final, l'ordi finit toujours par récupérer la dernière pour gagner.
Si c'est l'ordi qui commence, là il commencera forcément au hasard. Mais ensuite si le joueur ne fait pas le bon choix, alors l'ordi peut se rattrapper en faisant lui-même le complément à 5 (ou à 10 selon) des deux coups précédents pour retomber sur une position gagnante pour lui correspondant au cas du joueur qui commence.
C'est un peu plus réfléchi que faire jouer l'ordi "au hasard". Ceci dit, dans les deux cas, le jeu ne sera pas très amusant (dans le premier un joueur moyennement câblé gagnera facilement, dans le second, dès que le truc aura été trouvé, l'amusement sera fini)

A noter qu'il existe le même jeu où celui qui prend la dernière a perdu. Dans ce cas, la technique reste la même mais le nombre d'allumettes au départ est calculé de la même façon sauf qu'au final on doit en rajouter 1. Et dans cette variante, le "truc" est un peu plus difficile à trouver quand on joue contre un programme.

Voilà. Si tu veux modifier ton code, déjà en lui permettant de prendre "p" aléatoirement (entre 6 et 9 par exemple) puis en calculant nbal par rapport à ce "p" puis en lui faisant "réfléchir" de façon plus mathématique ça donnera un programme un peu plus divertissant...

Aide pour débutant

Python

Discussions similaires

Partager

Partager