Donc si j'ai bien compris, et que je résume ce qu'il se passe dans mon exemple :
- yield renvoie 6, l'exécution du générateur s'arrête à la ligne du yield, et on rentre dans la condition de la boucle for.
- Dans cette condition, l'exécution s'arrête à la méthode send() qui envoie True au générateur, valeur qui est capturée dans ma variable reverse depuis le MÊMEyield où s'est arrêté le générateur.
- PUIS l'exécution du générateur reprend, va jusqu'au prochain yield qui renvoi donc 5, mais cette valeur est renvoyée à la méthode send() et donc ne lance pas une nouvelle itération de la boucle for.
- PUIS l'exécution de ma boucle for reprend au niveau du send() et print(i) renvoie l'itération courante dans laquelle i vaut toujours 6. send() ayant fait avancer le générateur à 5, la prochaine itération de la boucle for affichera 4 au lieu de 5.
Vraiment désolé pour ce pavé Mais je voudrais être certain que mon raisonnement est le bon, car c'est assez déroutant quand on est pas habitué...
Écrire un programme qui demande à l’utilisateur combien de plis de papier sont nécessaires pour se rendre sur la Lune, et pose la question tant que l’utilisateur n’a pas saisi la bonne réponse.
Si la réponse saisie par l’utilisateur n’est pas correcte, le programme affiche le message "Mauvaiseréponse.", puis pose à nouveau la question. Si la réponse saisie par l’utilisateur est correcte, le programme affiche le message "Bravo!", et s’arrête.
Voici mon code j'ai besoin d'aide
int(input("Combien de plis sont-ils nécessaires pour se rendre sur la Lune ? : ")) DISTANCE = 3844.0e5 nombre_pliages = 0 epaisseur = 0.0001 while epaisseur == DISTANCE: epaisseur = 2 * epaisseur nombre_pliages = nombre_pliages + 1 print("Mauvaise réponse.") print("Bravo !")
Oui c'est bien ça. Si tu veux t'en assurer tu peux débuguer le générateur en ajoutant des breakpoints (ou des print) pour en suivre l'exécution.
Oui c'est bien ce que j'ai fais, mais même avec ça, je trouve ça difficile à appréhender la première fois Encore merci pour ton aide !
Lebenis, si tu veux pouvoir poser la question tant que l'utilisateur n'a pas répondu correctement, il faut utiliser un boucle et définir une variable qui changera de valeur une fois la bonne réponse donnée afin de sortir de la boucle.
Une solution :
DISTANCE = 3844.0e5
nombre_pliages = 0
epaisseur = 0.0001
# Tant que l'épaisseur est plus petite que la distance
while epaisseur < DISTANCE:
epaisseur = 2 * epaisseur
nombre_pliages = nombre_pliages + 1
bonne_reponse = False # On définie la variable permettant de sortir de la boucle
# Tant que cette variable vaut False
while bonne_reponse == False:
reponse_utilisateur = int(input("Combien de plis sont-ils nécessaires pour se rendre sur la Lune ? : "))
if reponse_utilisateur != nombre_pliages:
print("Mauvaise réponse.")
else:
print("Bravo !")
bonne_reponse = True # On définit la variable sur True pour sortir de la boucle
Oui c'est bien ça. Si tu veux t'en assurer tu peux débuguer le générateur en ajoutant des breakpoints (ou des print) pour en suivre l'exécution.
Oui c'est bien ce que j'ai fais, mais même avec ça, je trouve ça difficile à appréhender la première fois Encore merci pour ton aide !
Lebenis, si tu veux pouvoir poser la question tant que l'utilisateur n'a pas répondu correctement, il faut utiliser un boucle et définir une variable qui changera de valeur une fois la bonne réponse donnée afin de sortir de la boucle.
Une solution :
DISTANCE = 3844.0e5
nombre_pliages = 0
epaisseur = 0.0001
# Tant que l'épaisseur est plus petite que la distance
while epaisseur < DISTANCE:
epaisseur = 2 * epaisseur
nombre_pliages = nombre_pliages + 1
bonne_reponse = False # On définie la variable permettant de sortir de la boucle
# Tant que cette variable vaut False
while bonne_reponse == False:
reponse_utilisateur = int(input("Combien de plis sont-ils nécessaires pour se rendre sur la Lune ? : "))
if reponse_utilisateur != nombre_pliages:
print("Mauvaise réponse.")
else:
print("Bravo !")
bonne_reponse = True # On définit la variable sur True pour sortir de la boucle
- Edité par maciozik il y a environ 3 heures
Merci infiniment j'ai compris pourquoi mon code ne marchait pas. je suis débutant dans la programmation
Déjà en Python (CPython) tu n'auras pas de vrai parallélisme avec des threads, car un verrou global (GIL) empêche des threads différents d'exécuter du code simultanément.
Ils servent donc à la programmation concurrente, par exemple quand il est question d'attendre une réponse réseau.
Les threads sont une manière de concevoir un serveur de chat : un thread peut être dédié à chaque client pour attendre ses messages, et permettre au programme de gérer simultanément plusieurs clients.
Déjà en Python (CPython) tu n'auras pas de vrai parallélisme avec des threads, car un verrou global (GIL) empêche des threads différents d'exécuter du code simultanément.
Ils servent donc à la programmation concurrente, par exemple quand il est question d'attendre une réponse réseau. Les threads sont une manière de concevoir un serveur de chat : un thread peut être dédié à chaque client pour attendre ses messages, et permettre au programme de gérer simultanément plusieurs clients.
Merci vraiment ! je me donnais du mal pour rien , je prefere sauter cette etape et ne pas l'approfondir !
Est-ce que tu peux nous dire ce qu'il est censé faire et à quoi sert la liste L ?
Et même à quoi sert toute cette fonction si elle n'a aucun effet de bord et qu'elle renvoie simplement ce qu'elle prend en entrée.
C'est peut-être justement la liste L que tu veux renvoyer ?
Bonjour j’ai besoin d’aide. Alors je me doit de réaliser 6 programmes mais je n’ai absolument aucune idée de comment les faire. Les programmes à faire sont des convertisseur de binaire vers hexa , de hexa vers binaire, de binaire vers décimal, de décimal vers binaire, de décimal vers hexa et de hexa vers décimal. Bien sûr les fonction bin() hex() sont interdites. Voilà merci d’avance de vos réponses
J'ai commencé le cours sur python cette semaine (je n'ai aucune base) et je rencontre un problème sur le 1er TP, j'ai pas mal bossé dessus mais je ne comprends pas mon erreur.
annee = input ("""Saisissez une année : """)
annee = int (annee)
bissextile = False
if annee % 4 == 0:
bissextile = True
elif annee % 100 == 0:
bissextile = False
elif annee % 400 == 0:
bissextile = True
if bissextile:
print("""L'année saisie est bissextile.""")
else:
print("""L'année saisie n'est pas bissextile.""")
Dans ma 1ère version j'avais inscrit bissextile = True sur la 3ème ligne mais en lançant j'avais toujours la réponse "l'année saisie est bissextile", j'ai donc modifié en False sans vraiment comprendre.
Autre question, dans mon code l'année 2100 est bissextile et je ne parviens pas à apporter la modification nécessaire, désolé s'il s'agit de deux questions bêtes mais je souhaite comprendre avant de recopier la solution au problème.
J'ai commencé le cours sur python cette semaine (je n'ai aucune base) et je rencontre un problème sur le 1er TP, j'ai pas mal bossé dessus mais je ne comprends pas mon erreur.
annee = input ("""Saisissez une année : """)
annee = int (annee)
bissextile = False
if annee % 4 == 0:
bissextile = True
elif annee % 100 == 0:
bissextile = False
elif annee % 400 == 0:
bissextile = True
if bissextile:
print("""L'année saisie est bissextile.""")
else:
print("""L'année saisie n'est pas bissextile.""")
Dans ma 1ère version j'avais inscrit bissextile = True sur la 3ème ligne mais en lançant j'avais toujours la réponse "l'année saisie est bissextile", j'ai donc modifié en False sans vraiment comprendre.
Autre question, dans mon code l'année 2100 est bissextile et je ne parviens pas à apporter la modification nécessaire, désolé s'il s'agit de deux questions bêtes mais je souhaite comprendre avant de recopier la solution au problème.
Merci
- Edité par JulienBol il y a environ 3 heures
Il faut d'abord tester si l'année est un multiple de 400 puis un multiple de 100 et enfin un multiple de 4. (de cette façon tous les cas sont gérés)
ton problème devrait être réglé!
tu pourrais aussi simplifier / optimiser:
année = input("saisissez une année:")
année = int(année)
if année % 400 == 0 or (année % 4 == 0 and année % 100 != 0):
print("l\'année saisie est bissextile.")
else:
print("l\'année saisie n\'est pas bissextile.")
- Edité par Fantasio 2020 24 octobre 2020 à 12:15:45
if (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0:
# suite
else:
# suite
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard) La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
Bonjour, juste pour dire que je viens de commencer la formation, j'en suis au chapitre 3, j'avance doucement, j'ai jamais pipé quoique ce soit en relation avec la programmation. Je ne suis même pas du métier... C'est super simple pour le moment et même sympa de percuter aussi vite. On verra quand j'arrive au bout !
J'ai un programme python qui génère le jeu space invader sur pygame. Je dois créer un fonction qui compte les ennemis. J'ai tenté plusieurs chose mais cela n'aboutit pas. Est ce que quelqu'un pourrait m'aider a trouver une solution.
Merci d'avance
import pygame # necessaire pour charger les images et les sons
from random import randint # Pour générer un nombre aléatoire
class Joueur() :
'''
Classe qui défini le vaisseau de notre joueur
'''
def __init__(self) :
self.image = pygame.image.load('vaisseau.png') # Permet de mettre une image
self.velocite = 5 # Rapidité du mouvement
self.position = 350 # Position du vaisseau
self.direction = "0"
def deplacer(self):
'''
Permet de déplacer le vaisseau à droite et à gauche
'''
if (self.direction == "droite") and (self.position < 780):
self.position += self.velocite
elif (self.direction == "gauche") and (self.position > 0):
self.position -= self.velocite
def tirer(self):
'''
Permet de tirer les balles
'''
self.direction = "0"
def score(self):
'''
Permet d'afficher le score
'''
score_pen.speed(0)
score_pen.color("white")
score_pen.penup()
score_pen.setposition(-290,280)
scorestring = "Score : %" %score
score_pen.write(scorestring, False, align = 'left', font = ('Arial', 14, 'normal'))
class Balle():
'''
Classe qui défini les balles de notre joueur
'''
def __init__(self):
self.tireur = Joueur
self.depart = 0
self.hauteur = 0
self.image = pygame.image.load('balle.png')
self.etat = 'chargée' or 'tirée'
self.position = 350 # Position du vaisseau
def bouger(self, etat, tireur):
if etat == 'tiree' :
self.position += self.velocite
self.position -= self.velocite
# Une fois la balle tirée réinitialise pour retirer
if self.position > 275 :
etat = 'chargee'
def toucher(ennemis):
if ennemis == True:
return 'touché'
else:
return 'manqué'
class Ennemis():
'''
Classe qui défini l'ennemi de notre joueur
'''
def __init__(self, ennemis, depart : int, hauteur : int, image, vitesse : int):
self.ennemis = ennemis
self.depart = depart
self.hauteur = hauteur
self.image = pygame.image.load('invader1.png')
self.vitesse = vitesse
def avancer(self, ennemis):
'''
Permet de faire déscendre l'ennemi
'''
y = ennemis.ycor()
y -= ennemis.speed # fait déscendre l'ennemi
def NbEnnemis(self, ennemis):
'''
Permet de compter le nombre d'ennemi
'''
# Génére entre 1 et 5 ennemis
n =[0]*n
for i in range(n):
n[i] = randint(1,5)
return n
# Créer les ennemis
for i in range(n):
self.ennemis.append(ennemis)
# Compte le nombre d'ennemis
while n > 0:
nbre_ennemis += 1
def disparaitre(toucher, tireur, ennemis):
'''
Permet de faire disparaitre l'ennemi une fois qu'il a été touché
'''
if toucher(tireur, ennemis):
# Reset la balle
etat == 'chargee'
tireur.position(0,-400)
# Reset l'ennemi
ennemis.position(-200,250)
import pygame # importation de la librairie pygame
import space
import sys # pour fermer correctement l'application
# lancement des modules inclus dans pygame
pygame.init()
# création d'une fenêtre de 800 par 600
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption("Space Invaders")
# chargement de l'image de fond
fond = pygame.image.load('background.png')
# creation du joueur
player = space.Joueur()
# creation de la balle
tir = space.Balle()
tir.etat = "chargee"
# creation des ennemis
listeEnnemis = []
for indice in range(space.Ennemis.NbEnnemis):
vaisseau = space.Ennemi()
listeEnnemis.append(vaisseau)
### BOUCLE DE JEU ###
running = True # variable pour laisser la fenêtre ouverte
while running : # boucle infinie pour laisser la fenêtre ouverte
# dessin du fond
screen.blit(fond,(0,0))
### Gestion des événements ###
for event in pygame.event.get(): # parcours de tous les event pygame dans cette fenêtre
if event.type == pygame.QUIT : # si l'événement est le clic sur la fermeture de la fenêtre
running = False # running est sur False
sys.exit() # pour fermer correctement
# gestion du clavier
if event.type == pygame.KEYDOWN : # si une touche a été tapée KEYUP quand on relache la touche
if event.key == pygame.K_LEFT : # si la touche est la fleche gauche
player.sens = "gauche" # on déplace le vaisseau de 1 pixel sur la gauche
if event.key == pygame.K_RIGHT : # si la touche est la fleche droite
player.sens = "droite" # on déplace le vaisseau de 1 pixel sur la gauche
if event.key == pygame.K_SPACE : # espace pour tirer
player.tirer()
tir.etat = "tiree"
### Actualisation de la scene ###
# Gestions des collisions
for ennemi in listeEnnemis:
if tir.toucher(ennemi):
ennemi.disparaitre()
player.marquer()
print(f"Score = {player.score} points")
# placement des objets
# le joueur
player.deplacer()
screen.blit(tir.image,[tir.depart,tir.hauteur]) # appel de la fonction qui dessine le vaisseau du joueur
# la balle
tir.bouger()
screen.blit(player.image,[player.position,500]) # appel de la fonction qui dessine le vaisseau du joueur
# les ennemis
for ennemi in listeEnnemis:
ennemi.avancer()
screen.blit(ennemi.image,[ennemi.depart, ennemi.hauteur]) # appel de la fonction qui dessine le vaisseau du joueur
pygame.display.update() # pour ajouter tout changement à l'écran
pygame.quit()
- Edité par CharlineBch1 3 novembre 2020 à 20:58:29
Je suis le cours et passé l’étape PARTIE #2 et son quiz de fin, l'interface m'indique deja que je suis a "Progression = 100%" du cours et me donne l’accès a son certificat, alors que je dois être seulement a 50% :-)
liste_mois = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin", \
"Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"]
titre = liste_mois[m-1] + " " + str(a)
print(" " * ((20-len(titre))//2) + titre)
# Affichage nom des jours de la semaine
print("di lu ma me je ve sa")
# Affichage des jours
jour = 1 # Le jour à écrire (s'incrémente)
jour_semaine_1er = num_jour(jour, m, a) # Premier jour de la semaine
nbre_jours_mois = nbre_jours(m, a) # Nombre de jours du mois
# Boucle sur les lignes.
# Ne s'arrête pas tant que le jour final a été atteint
while jour <= nbre_jours_mois:
# La variable ligne stockera la ligne avant de l'imprimer
ligne = ""
if jour == 1 and jour_semaine < jour_semaine_1er:
ligne += " "
elif jour <= nbre_jours_mois:
if jour < 10:
ligne += " "
ligne += str(jour)
jour += 1
# Si on est entre deux jours, on ajoute un caractère d'espacement
if jour_semaine < 6 and jour <= nbre_jours_mois:
ligne += " "
print(ligne) # On affiche la ligne
l'exercice pour afficher le calendrier d'un mois
num_jour : une foction qui donne le numéro du jour dans la semaine (0,1,2,3,4,5,6)
nbre_jours : une fonction qui donne le nombre des jour dans un mois meme si l'année bissextile ou pas
ma question c'est que j'ai pas compris bien la solution (a partir de Affichage des jours) merci de m'expliquer /)
Bonjour, j'essaie de comprendre la correction du TP Dictionnaire ordonné. Tout me parait clair sauf un point important. Dans le constructeur, comment se construisent les attributs self._clefs et self._valeurs? Comment Python redistribue les clefs et valeurs de "base" et "données" dans les listes que l'on nomme nous-mêmes self._clefs et self._valeurs? Autrement formulé, je ne comprends pas comment les boucles "for" du constructeur y parviennent puisque self._clefs et self._valeurs n'y apparaissent pas.
En fait il se trouve que le constructeur ajoute les données depuis base et donnees en faisant des self[clef] = ..., ce qui a pour effet d'appeler la méthode __setitem__.
Et c'est cette méthode qui insère les valeurs correspondantes dans les listes self._cles et self._valeurs.
En fait il se trouve que le constructeur ajoute les données depuis base et donnees en faisant des self[clef] = ..., ce qui a pour effet d'appeler la méthode __setitem__. Et c'est cette méthode qui insère les valeurs correspondantes dans les listes self._cles et self._valeurs.
Salut, merci beaucoup pour la réponse.
Je comprends l'appel à __setitem__ mais ce qui me perturbe c'est que, comme nous décidons nous-même d'appeler les listes "self._cles" et "self._valeurs" comment python sait ranger "base[cle]" et "donnees[cle]" dans "self._valeurs" et non dans "self._cles"? Ce que je veux dire, c'est que les deux listes sont vides en début de constructeur et que ni "cles" ni "valeurs" sont des mots-clefs pour Python. Alors je ne comprends pas comment avec l'appel à __setitem__ on peut être certains que les clefs de "base" et "données" vont bien dans "self._cles" et que leurs valeurs vont bien dans "self._valeurs", et non l'inverse par exemple? En fait, les assignations auraient été plus garanties pour moi si dans les "boucles for" du constructeur, on avait des lignes comme : "self._valeurs.append(base [cle])" et "self._cles.append(cle)". Je ne vois pas comment Python réussit à assigner les bons objets aux bonnes listes, même avec __setitem__.
J'espère que j'ai réussi à expliquer ce qui me posait problème. Il doit y avoir un point important sur le constructeur que je n'ai pas compris. En tous les cas, merci beaucoup
Non je ne comprends pas le soucis, c'est écrit explicitement.
self[cle] = base[cle] (ligne 23 dans la correction) ça veut dire que dans l'objet self on va associer la valeur base[cle] à la clé cle.
Ça revient à appeler self.__setitem__(cle=cle, valeur=base[cle]).
Ensuite, la méthode __setitem__ insère simplement la clé dans self._cles et la valeur dans self._valeurs, il n'y a rien de magique.
Ensuite, la méthode __setitem__ insère simplement la clé dans self._cles et la valeur dans self._valeurs, il n'y a rien de magique.
De nouveau, merci pour la réponse. Mais, je suis désolé je n'y arrive pas. C'est justement ça qui me pose problème, qu'est-ce qui empêche "__setitem__" de ne pas insérer la clé "cle" dans self._valeurs et la valeur "base[cle]" dans self._cles? Ce n'est ni leur nom, ni leur ordre d'apparition dans le constructeur. Comment "__setitem__" trouve la bonne liste où insérer ces objets? Je vais y réfléchir mais là je bloque. En tout cas merci beaucoup malgré tout
Si c'est précisément leur ordre d'apparition qui faite cela.
Quand j'exécute obj[foo] = bar, c'est comme si j'appelais obj.__setitem__(foo, bar).
La clé (foo) et la valeur (bar) sont donc identifiables par leur position : la clé est toujours le premier argument et la valeur le deuxième.
Donc dans une méthode __setitem__(self, key, value) je sais bien que key est la clé et value la valeur.
Cette méthode n'a plus qu'à appliquer le traitement adéquat aux deux paramètres.
Portfolio : jonathan-macioszczyk.fr
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
Modeste Mobio
Portfolio : jonathan-macioszczyk.fr
Le Tout est souvent plus grand que la somme de ses parties.
Modeste Mobio
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
Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)
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