Merci, je venais de m’apercevoir du bug et je ne comprenais pas comment je pouvais choisir la case 49 et pas la case 0.
#!/usr/bin/python3.5
# -*-coding:Utf-8 -*
from random import randrange
from math import ceil
def sortir(nb) :
"""1 : Le joueur a-t-il de l'argent ?
2 Le joueur veut-il continuer de jouer ?
"""
if nb == 0 :
print("""\n\n\n\nVous êtes à sec :
Le casino vous remercie pour votre participation\
à son chiffre d'affaire.""")
return True
else :
choix = input("""\n\n\n
Pour quitter le casino tapez la touche Q.
L'abus de jeu est néfaste. Faîtes-vous aidez !
Pour continuez appuyez sur ENTREE : """)
if choix is "Q" or choix is "q":
print("Merci d'avoir joué.")
return True
else :
return False
def la_bille():
"""Définit la case gagnante.
"""
nbr = (randrange(49))
print("La bille est sur la case", nbr, ".")
return nbr
def test_nombre_entier(texte, a, b):
""" Teste si le nombre est entier
teste si le nombre est dans l'intervale : a <= nombre <= b.
teste si la saisie est un nombre.
"""
print("Vous devez saisir un nombre entier entre", a, "et", b, ".")
nb = input(texte)
try:
nb = int(nb)
except ValueError:
print("Vous n'avez pas saisi un nombre entier.")
return False
if nb < a or nb > b:
print("Le nombre", nb, "n'est pas dans l'intervale.")
return False
else:
return nb
def resolution_du_pari(pari_sur_case, case, mise, argent):
""" Résolution du pari et :
- distribution des gains
- ou perte de la mise
"""
modulo_pari = pari_sur_case % 2
modulo_case = case % 2
if pari_sur_case is case:
print("""Wohoo ! Vous avez le bon numéro !
Vous gagnez""", mise*3, """€.""")
return argent + mise*3
elif modulo_pari == 0 and moduloCase == 0:
print("Pair, noir gagne !\nVous gagnez", ceil(mise/2), "€.")
return argent + ceil(mise/2)
elif modulo_pari != 0 and modulo_case != 0:
print("Impair, rouge gagne !\nVous gagnez", ceil(mise/2), "€.")
return argent + ceil(mise/2)
else:
print("Vous avez perdu votre mise de", mise, "€.")
return argent-mise
if __name__ == "__main__":
resolution_du_pari(13, 13, 10, 50)
Retire vraiment toutes les comparaisons is que tu utilises. Ce que j'ai dit pour les nombres est valable pour les chaînes de caractères, et globalement pour tous les types à moins de vraiment savoir ce que tu fais.
Il n'y a sinon qu'avec None qu'on utilise is plutôt que ==.
du coup, j'ai fais avec le couple de valeurs. Merci encore je n'aurai pas trouvé (si vite) seule.
#!/usr/bin/python3.5
# -*-coding:Utf-8 -*
""" Ce programme est un jeu de roulette de casino aux règles simplifiées. """
from fonctions_casino_z import *
quitter = False
argent_joueur = 50
print ("Bienvenue au Casino Z ! \nLe casino vous offre 50 €.")
while not quitter:
pari_sur_case = False
mise = False
while not pari_sur_case:
texte = "\n\n\n\n\nChoisissez votre case : "
pari_sur_case, case_choisie = test_nombre_entier(texte, 0, 49)
print("Vous avez parié sur la case", case_choisie, ".")
while not mise:
texte = "Choisissez votre mise : "
mise, mise_parie = test_nombre_entier(texte, 0, argent_joueur)
print("Vous avez parié", mise_parie, "€.")
case = la_bille()
argent_joueur = resolution_du_pari(
case_choisie, case,
mise_parie, argent_joueur)
print("Vous avez à présent", argent_joueur, "€.")
quitter = sortir(argent_joueur)
""" Chemin d'acces : cd /home/jaenne/Documents/Python3.5/casino_z """
#!/usr/bin/python3.5
# -*-coding:Utf-8 -*
from random import randrange
from math import ceil
def sortir(nb) :
"""1 : Le joueur a-t-il de l'argent ?
2 Le joueur veut-il continuer de jouer ?
"""
if nb == 0 :
print("""\n\n\n\nVous êtes à sec :
Le casino vous remercie pour votre participation\
à son chiffre d'affaire.""")
return True
else :
choix = input("""\n\n\n
Pour quitter le casino tapez la touche Q.
L'abus de jeu est néfaste. Faîtes-vous aidez !
Pour continuez appuyez sur ENTREE : """)
if choix == "Q" or choix == "q":
print("Merci d'avoir joué.")
return True
else :
return False
def la_bille():
"""Définit la case gagnante.
"""
nbr = (randrange(49))
print("La bille est sur la case", nbr, ".")
return nbr
def test_nombre_entier(texte, a, b):
""" Teste si le nombre est entier
teste si le nombre est dans l'intervale : a <= nombre <= b.
teste si la saisie est un nombre.
"""
print("Vous devez saisir un nombre entier entre", a, "et", b, ".")
nb = input(texte)
try:
nb = int(nb)
except ValueError:
print("Vous n'avez pas saisi un nombre entier.")
return False, 0
if nb < a or nb > b:
print("Le nombre", nb, "n'est pas dans l'intervale.")
return False, 0
else:
return True, nb
def resolution_du_pari(pari_sur_case, case, mise, argent):
""" Résolution du pari et :
- distribution des gains
- ou perte de la mise
"""
modulo_pari = pari_sur_case % 2
modulo_case = case % 2
if pari_sur_case == case:
print("""Wohoo ! Vous avez le bon numéro !
Vous gagnez""", mise*3, """€.""")
return argent + mise*3
elif modulo_pari == 0 and modulo_case == 0:
print("Pair, noir gagne !\nVous gagnez", ceil(mise/2), "€.")
return argent + ceil(mise/2)
elif modulo_pari != 0 and modulo_case != 0:
print("Impair, rouge gagne !\nVous gagnez", ceil(mise/2), "€.")
return argent + ceil(mise/2)
else:
print("Vous avez perdu votre mise de", mise, "€.")
return argent-mise
if __name__ == "__main__":
resolution_du_pari(13, 13, 10, 50)
Je débute ce cours et je rencontre des incohérences... J'aimerai comprendre d'où vient mon erreur.
Pour info, je travaille sous windows 10 avec python 3.8.0
j'écris mes codes soit dans notepade ++ soit dans Python IDLE (pour corriger plus vite)
dans le cours "apprenez à faire des boucles", l'exercice initial avec la boucle while est facile. Je joue avec les options, j'ajoute la fonction input pour vérifier que je me souviens bien. et là, le drame...
voici mon code :
nb = input("saisissez un chiffre: ") i=0
while i<10: print(i,"x",nb,"=",(i)*nb) i+=1
et voici le résultat 😅
saisissez un chiffre: 4 0 x 4 = 1 x 4 = 4 2 x 4 = 44 3 x 4 = 444 4 x 4 = 4444 5 x 4 = 44444 6 x 4 = 444444 7 x 4 = 4444444 8 x 4 = 44444444 9 x 4 = 444444444
Savez-vous d'où vient l'erreur ? Je me sens bête...
def pali(chaine):
for i in range (1,len(chaine)):
if chaine[i] == chaine[-i-1]:
return True
return False
print(pali('rotator'))
#bonjour, j'ai exécuté le programme avec in range (0,len(chaîne)) c’était le même résultat, pourquoi? et le plus logique pour moi c de mettre 1 au debut dans la boucle for nn ?
#-je ne comprends pas l'instruction chaine [-i -1]? normalement chaine [-i] c suffisant nn ? merci de me repondre
Tu aurais aussi le même résultat avec range(2). Ce n'est pas parce que le résultat est le même sur un exemple que les deux sont équivalents.
Il se trouve que dans ton cas ça reviendrait au même, parce qu'il est juste nécessaire de parcourir l'une ou l'autre moitié de la chaîne, ce qui est couvert par range(len(chaine)) et par range(1, len(chaine)).
Je pense que l'idée de commencer à 1 est une sorte d'optimisation pour ne pas traiter le cas des chaînes d'un seul caractère. Mais une meilleure optimisation serait range(len(chaine)//2) pour ne parcourir que la moitié de la chaîne (à l'exception du caractère central pour les chaînes de taille impaire, qui importe peu).
Aussi, ta fonction ne calcule pas le bon résultat, elle va renvoyer True pour la chaîne 'coucou' qui n'a rien d'un palindrome.
(et renverrait True pour 'damned' si tu faisais le changement que j'indique sur le range).
Relis ton code actuel, et regarde combien d'itérations maximum la boucle est capable d'exécuter ?
chaine[-i-1] c'est le ième caractère de la chaîne en partant de la fin. Parce que si i vaut 0 (premier caractère), le caractère qui lui est associé est le dernier (-1).
def pali(chaine):
for i in range (len(chaine)//2):
if chaine[i] != chaine[-i-1]:
return False
return True
print(pali('coucou'))
# WHILE BOUCLE
def pal(s):
i=0
while i<len(s):
if s[i]==s[len(s)-1-i]:
i+=1
else: return False
return True
print(pal('lol'))
def sentencesleft(word,x):
for i in range (len(word)):
if word[-i] == x:
return -i
else: return -1
print(sentences('lower','o'))
def inverse(s):
new =''
for i in range(0,len(s)):
new += s[-i-1]
print(new)
print(inverse('lower'))
# bonjour j'ai deux fonctions, la première renvoie #l'indice de la première occurrence d’un caractère dans #une chaîne en partant de la gauche
# la deuxième renvoie l'inverse du mot
# moi je voulais écrire une fonction a l'aide de deux #fonctions précédente renvoie l'indice de la première #occurrence d’un caractère dans une chaîne en partant de #la droite
# vous pouvez modifier les deux fonctions(c moi qui les #crée
Je viens de terminer le TP. Ca ne ressemble pas beaucoup à la correction du coup, j'aimerais beaucoup avoir des avis et critiques.
Merci d'avance.
#!/usr/bin/python3.8
# -*-coding:Utf-8 -*
"""
Pendu est un jeu dans lequel vous essaierez de deviner un mot de 8 lettres.
Le joueur a 8 essais.
Le joueur a une sauvegarde à son nom.
La sauvegarde ne prend en compte que le meilleur score.
Le score correspond au nombre d'essai(vies) restant.
Si le joueur ne comprend pas ce qu'est UNE LETTRE il peut changer de jeu
mais le programme continuera sans problèmes.
"""
import os
from fonctions_pendu import *
os.chdir("/home/jaenne/Documents/Python/pendu")
continuer = True
print ("Bienvenue dans le jeu du pendu.")
dessin(vies=0, lettres_trouvees=[], mot="mot")
nom_du_joueur = input("Quel est votre nom ? ")
print("Bonjour", nom_du_joueur)
tableau_des_scores = ouvrir_le_fichier_sauvegardes()
score_du_joueur = ouvrir_la_sauvegarde(nom_du_joueur)
while continuer:
mot, lettres_trouvees = generation_du_mot()
lettres_refusees = []
vies = 8
while lettres_trouvees != mot and vies >= 1:
lettre_proposee = input("Proposez une lettre : ")
lettres_trouvees, lettres_refusees, vies = verification_de_lettre(
lettre_proposee,
lettres_trouvees,
lettres_refusees,
vies,
mot
)
if lettres_trouvees != mot :
afficher_lettres_refusees(lettres_refusees)
dessin(vies, lettres_trouvees, mot)
print("Il vous reste :", vies, "vie(s).")
afficher_lettres_trouvees(lettres_trouvees)
if lettres_trouvees == mot:
print("Félicitations !")
dessin(vies, lettres_trouvees, mot)
else :
afficher_le_mot(mot)
print("Votre score est :", vies)
enregistrer_le_score(nom_du_joueur, vies)
continuer = sortir()
print("Merci d'avoir joué au Pendu, à bientôt !")
"""
cd /home/jaenne/Documents/Python/pendu
"""
#!/usr/bin/python3.8
# -*-coding:Utf-8 -*
"""
Toutes les fonctions utiles au jeu du Pendu sont ici.
Les données (mots) sont dans le fichier donnees_pendu.py
"""
import pickle
from random import randrange
from donnees_pendu import *
"""
Fonctions de menu -----------------------------------------------------------------------------
"""
def ouvrir_le_fichier_sauvegardes():
"""
Cette fonction vérifie que le fichier "sauvegardes" existe
si oui, elle renvoie le contenu dans la fonction main.
si non, elle créer le fichier "sauvegarde" avec un tableau des scores vide.
puis elle renvoie le contenu dans la fonction main.
"""
try:
with open("sauvegardes", "rb") as fichier:
mon_depickler = pickle.Unpickler(fichier)
tableau_des_scores = mon_depickler.load()
print("Fichier sauvegardes trouvé.")
return tableau_des_scores
except FileNotFoundError:
with open("sauvegardes", "wb") as fichier:
mon_pickler = pickle.Pickler(fichier)
tableau_des_scores = {}
tableau_des_scores = mon_pickler.dump(tableau_des_scores)
print("Fichier sauvegardes créé.")
return tableau_des_scores
except EOFError:
with open("sauvegardes", "wb") as fichier:
mon_pickler = pickle.Pickler(fichier)
tableau_des_scores = {}
tableau_des_scores = mon_pickler.dump(tableau_des_scores)
print("Fichier sauvegardes créé.")
return tableau_des_scores
def ouvrir_la_sauvegarde(nom_du_joueur):
"""
Cette fonction ouvre le fichier "sauvegardes"
puis vérifie que le joueur a une sauvegarde à son nom.
si oui, elle renvoie le score du joueur dans la fonction main.
si non, elle créer une sauvegarde au nom du joueur avec 0 point.
puis renvoie le score du joueur dans la fonction main.
"""
with open("sauvegardes", "rb") as fichier:
mon_depickler = pickle.Unpickler(fichier)
tableau_des_scores = mon_depickler.load()
for k, v in tableau_des_scores.items():
if k == nom_du_joueur:
print(
"J'ai trouvé votre sauvegarde.\
\nVotre meilleur score est {} point(s).".format(v)
)
score_du_joueur = v
return score_du_joueur
with open("sauvegardes", "wb") as fichier:
mon_pickler = pickle.Pickler(fichier)
score_du_joueur = 0
tableau_des_scores[nom_du_joueur] = score_du_joueur
tableau_des_scores = mon_pickler.dump(tableau_des_scores)
print("Vous n'avez pas encore de sauvegarde.")
return score_du_joueur
def enregistrer_le_score(nom_du_joueur, score_du_joueur):
"""
La fonction vérifie si le score du joueur est supérieur à son ancien meilleur
score.
Si oui, elle écrase l'ancien score et enregistre le nouveau meilleur score.
si non, elle ne touche pas au fichier de sauvegarde.
"""
with open("sauvegardes", "rb") as fichier:
mon_depickler = pickle.Unpickler(fichier)
tableau_des_scores = mon_depickler.load()
for k, v in tableau_des_scores.items():
if k == nom_du_joueur:
ancien_score = v
if ancien_score < score_du_joueur:
with open("sauvegardes", "wb") as fichier:
mon_pickler = pickle.Pickler(fichier)
tableau_des_scores[nom_du_joueur] = score_du_joueur
tableau_des_scores = mon_pickler.dump(tableau_des_scores)
print(
"Vous avez battu votre ancien score ! \nVous aviez",
ancien_score, "point(s) et maintenant vous avez",
score_du_joueur, "point(s).\nScore sauvegardé."
)
elif ancien_score == score_du_joueur:
print(
"Vous avez égallé votre ancien score ! \nVous avez",
score_du_joueur, "point(s)."
)
if score_du_joueur == 8:
print("C'est le score maximum !")
else :
print(
"Vous n'avez pas battu votre ancien score :",
ancien_score
)
def sortir():
"""
La fonction demande au joueur s'il veut un nouveau mot ou s'il préfère quitter
le jeu et retourne la réponse du joueur dans la fonction main.
"""
sortie = input("Pour continuer taper ENTREE, pour quitter taper Q : ")
if sortie == "q" or sortie == "Q":
return False
else :
return True
"""
Fonctions de gestion des exceptions générées par l'utilisateur----------------------------------
"""
"""
Je n'ai pas trouvé de cas ou le programme bug à cause d'une saisie du joueur.
si le joueur entre plusieurs lettres ou des chiffres quand input lui demande
1 lettre, le programme envoie une réponse négative et continue de tourner.
"""
"""
Fonctions du corps du jeu ----------------------------------------------------------------------
"""
def generation_du_mot():
"""
La fonction choisit un mot dans la liste du fichier "donnees_pendu.py"
Le mot_choisit est découpé en 8 lettres et envoyé dans la liste "mot".
On créer aussi la liste "lettres_trouvees" qui ne contient que des underscores.
Les deux listes sont renvoyées dans la fonction main.
"""
i = (randrange(623))
lettres_trouvees = ["_","_","_","_","_","_","_","_"]
print(
"\n\nJ'ai choisit un mot :\n\n",
lettres_trouvees[0],
lettres_trouvees[1],
lettres_trouvees[2],
lettres_trouvees[3],
lettres_trouvees[4],
lettres_trouvees[5],
lettres_trouvees[6],
lettres_trouvees[7],
"\n\n"
)
mot_choisit = (mots[i]).upper()
mot = [
mot_choisit[0], mot_choisit[1], mot_choisit[2], mot_choisit[3],
mot_choisit[4], mot_choisit[5], mot_choisit[6], mot_choisit[7]
]
return mot, lettres_trouvees
def verification_de_lettre(
lettre_proposee, lettres_trouvees,
lettres_refusees, vies, mot
):
"""
La fonction compare la lettre_proposee avec chacune des lettres contenues
dans la liste "mot".
Si la lettre_proposee est contenue dans le "mot" (une ou plusieurs fois),
la "lettre_proposee" remplace l'underscore de l'indice correspondant
dans la liste lettres_trouvees.
Si la lettre_proposee n'est pas dans le "mot",
le joueur perd une vie et la lettre est ajouté à la liste des lettres
refusées.
"""
lettre_proposee = lettre_proposee.upper()
point = 0
for i, lettre_du_mot in enumerate(mot):
if lettre_proposee == lettre_du_mot:
lettres_trouvees[i] = lettre_proposee
point +=1
if point == 0:
print(lettre_proposee, "ne fait pas partie des lettres du mot.\n\n")
lettres_refusees.append(lettre_proposee)
vies -= 1
return lettres_trouvees, lettres_refusees, vies
def afficher_lettres_trouvees(lettres_trouvees):
"""
Affiche l'avancement de la découverte du mot.
"""
print("\n",
lettres_trouvees[0],
lettres_trouvees[1],
lettres_trouvees[2],
lettres_trouvees[3],
lettres_trouvees[4],
lettres_trouvees[5],
lettres_trouvees[6],
lettres_trouvees[7],
"\n\n"
)
def afficher_lettres_refusees(lettres_refusees):
"""
Affiche les lettres déjà testées qui ne sont pas dans le mot.
"""
if lettres_refusees != []:
print("Vous avez déjà proposé ces lettres :")
for indice, lettre in enumerate(lettres_refusees):
print(lettres_refusees[indice])
def afficher_le_mot(mot):
"""
Affiche le mot qu'il fallait trouver.
"""
print(
"le mot était :",
mot[0],
mot[1],
mot[2],
mot[3],
mot[4],
mot[5],
mot[6],
mot[7],
)
def dessin(vies, lettres_trouvees, mot):
"""
La fonction affiche le dessin du pendu en fonction du nombre de vies du joueur.
ou s'il a trouvé le mot.
"""
if vies == 8 or lettres_trouvees == mot:
print(" \\ O / ")
print(" | ")
print(" / \\ ")
elif vies == 0:
print(" _____")
print(" | |")
print(" O |")
print(" /|\\ |")
print(" / \\ |")
print(" _____|\n")
elif vies == 1:
print(" _____")
print(" | |")
print(" |")
print(" |")
print(" |")
print(" _____|\n")
elif vies == 2:
print(" _____")
print(" |")
print(" |")
print(" |")
print(" |")
print(" _____|\n")
elif vies == 3:
print(" |")
print(" |")
print(" |")
print(" |")
print(" _____|\n")
elif vies == 4:
print(" |")
print(" |")
print(" |")
print(" _____|\n")
elif vies == 5:
print(" |")
print(" |")
print(" _____|\n")
elif vies == 6:
print(" |")
print(" _____|\n")
else:
print(" _____|\n")
"""
Test des fonctions -----------------------------------------------------------------------------
"""
if __name__ == "__main__":
enregistrer_le_score("Jaenne", 8)
Je planche sur un programme sur lequel l'insertion d'animations est nécessaire.
Cependant, je n'ai jamais utilisé le module animation de matplotlib donc j'ai quelques soucis.
Je souhaite faire défiler sur une même figure une succession de matrices (je modélise un déplacement, un peu à la manière de snake, donc l'animation simule le mouvement de mon pixel sur la matrice).
Pourriez-vous m'aider au niveau de la façon dont cela peut s'écrire s'il vous plaît?
Je suis sur les méthodes spéciales : __init__, __repr__, __str__, __getattr__ ne me posent pas de soucis.
Par contre je ne comprend pas : __setattr__ , __delattr__ et __setitem__
Voici un exemple du cours pour __setitem__ :
"""
Classes pour zdict.
"""
class Zdict:
"""
Classe enveloppe d'un dictionnaire.
"""
def __init__(self):
"""
Cette classe n'accepte aucun paramètres.
"""
self._dictionnaire = {}
def __getitem__(self, index):
"""
Méthode spéciale appelée quand on fait :
objet[index]
Redirige vers self._dictionnaire[index].
"""
return self._dictionnaire[index]
def __setitem__(self, index, valeur):
"""
Méthode spéciale appelée quand on fait :
objet[index] = valeur
Redirige vers self._dictionnaire[index] = valeur.
"""
self._dictionnaire[index] = valeur
Je n'ai pas sauté de pages du cours poutant mais je ne comprends pas le mot instancier et dans ce contexte, l'expression créer un alias.
Le problème vient de ma fonction main donc.
Je veux que l'objet dico prenne les attributs définits dans la classe Zdict. (c'est ça instancier ?)
Et tu dis que ça ne marchera pas car je n'ai fais que créer un alias. Si c'est comme dans le cours sur Linux, ça veut dire qu'en faisant
dico.methode
c'est comme si je faisais
Zdict.methode
C'est comme ça que je comprends ton message mais je suis surement à côté de la plaque...
Pourtant sur d'autres tests, ça fonctionnait :
class Personnage:
"""
Classe définissant un model de personnage.
self = Personnage("nom", "type")
type peut prendre la forme de :
- "pj" : personnage joueur,
- "pnj" : personnage non joueur.
"""
compteur_perso = 0 # compteur
compteur_pj = 0
compteur_pnj = 0
def __init__(self, nom, type):
"""
self = Personnage("nom", "type")
Définit un personnage (self) par ces caractèristiques :
- nom
- pv (point de vie. pj : 20 ; pnj : 30)
- force (capacité de degat. pj : 3 ; pnj : 5)
- soin (capacité de soin. pj : 4 ; pnj : 0)
Affiche soit :
- nom_pj est rentré dans la partie.
- nom_pnj a été généré.
Compte le nombre de personnages créés.
Compte le nombre de pj créés.
Compte le nombre de pnj créés.
"""
self._nom = nom
if type == "pj":
self._pv = 20
self._force = 3
self._soin = 4
self.armure = 0
print(self._nom, "est entré.e dans la partie.")
Personnage.compteur_pj += 1
elif type == "pnj":
self._pv = 30
self._force = 5
self._soin = 0
self.armure = 0
print(self._nom, "a été généré.")
Personnage.compteur_pnj += 1
Personnage.compteur_perso += 1
Je ne sais pas quel cours tu suis, mais instancier c'est créer une nouvelle instance d'une classe, et pour cela il faut l'appeler.
Et pour une classe A, on instancie un nouvel objet avec l'expression A().
Si tu écris obj = A, tu as juste obj et A qui sont deux références vers la même chose : la classe A (obj est donc un alias pour A).
Et donc dans ce cas, obj.method est équivalent à A.method, oui.
Mais si obj était une instance de A (obj = A()), les choses seraient différentes.
Dans tes derneirs codes, on voit bien que tu instancies la classe Personne, il faut simplement en faire de même pour Zdict.
Qu'est-ce qui ne fonctionne pas ?
Tu peux aussi faire from models import classe et utiliser ensuite classe.Zdict.
Mais de toute manière il faut éviter d'avoir trop d'objets différents à importer depuis un même module, ça signifie un mauvais découpage.
Je souhaite savoir si un/une étudiant.e a été admis.e ou pas. Il/Elle est déclaré.e admis.e si :
soit, il a au moins 9 points à chaque examen.
soit, la moyenne des trois examens est au moins égale à 10 points et la plus basse note est au moins égale 8 points.
S'il n'est pas admis alors il est refusé.
Mes fonctions huit() et neuf() bugent et je n'arrive pas à savoir pourquoi. Auriez vous des idées?
Merci!!!
import random
#Creation d'une liste vide...
examens = list()
print("**********\nCreation liste vide:\n",examens)
#Remplisage de la liste..
for item in range(3):
examens.append(random.randrange(1,21))
print("**********\nNotes examens:",examens)
#CASE1. Il a au moins 9 points à chaque examen...
def neuf (liste):
return all(liste)>=9
#Case2.1 la moyenne des trois examens est au moins égale à 10 points...
def moyenne(liste):
return sum(liste)/len(liste)
#Case2.2 la plus basse note est au moins égale 8 points...
def huit(liste):
return any(liste)<=8
#Fonction que valide si un étudiant a été admis...
def admis(huit,neuf,moyenne):
print("""**********\nArguments recus par admis():\n
//Fonction Huit:""", huit,"""\n
//Fonction Neuf:""", neuf,"""\n
//Fonction Moyenne:""", moyenne,"\n***********""")
print("**********\nOutput: -->\n")
if neuf == True:
print("Admis car il/elle a au moins 9 points à chaque examen.")
if moyenne >= 10 and huit == True:
print("""Admis car la moyenne des trois\n
examens est au moins égale à 10 points\n
et la plus basse note est au moins égale 8 points""")
else: print("Non Admis")
return ("Fin")
# Main....
print(admis(huit(examens),neuf(examens),moyenne(examens)))
En effet, tu n'as pas compris le fonctionnement des fonctions all et any.
all prend un itérable (une collection d'éléments), et renvoie true si tous les éléments s'évaluent à true (dans le cas des nombres, un nombre s'évalue à true s'il est différent de zéro).
Quant à any, elle renvoie true si au moins un des éléments de la collection s'évalue à true.
Donc quand tu fais all(liste), tu ne fais que tester si toutes les notes sont différentes de zéro. De même quand tu fais any(liste), tu vérifies juste que l'une des notes est différentes de zéro.
Il se trouve aussi que ces fonctions renvoient true ou false, qui sont respectivement la même chose que 1 et 0. Donc en faisant any(liste)<=8, tu obtiens toujours true (que any renvoie 0 ou 1, c'est inférieur à 8).
Écrire un programme Python qui lit une chaîne de caractères ch et qui affiche la liste des mots de ch ainsi que les indices de début de chacun des mots dans ch (chaque mot pouvant se répéter plusieurs fois). Par exemple, pour ch=" ab cda fg ab fg cda h cda " afficher :
"ab" 1, 11 "cda" 4, 19, 25 "fg" 8, 16 "h" 23
Bonjour, restant bloquer sur ce programme depuis de moultes heures, un peu d'aide serait la bienvenu
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique