C'est juste que tu casses la boucle dès la 1ère itération, quelque soit le résultat (ligne 25 et 29).
Le else ne doit pas se trouver au niveau du if mais au niveau du for:
for agence_attributes in json.load(open("quotes.json")):
#...
if code_postal == agence_1.fields["postal_code"]:
print("Votre agence est située à:", agence_1.fields['name'])
break
else:
print("Désolé, il n'existe pas d'agence sur cette commune")
#plus besoin de break
Bonjour tout le monde, j'espère que vous allez bien.
Je me permet d'écrire ici pour demander un conseil au sujet du TP Labyrinthe en ligne. J'ai passé la journée dessus sans réussir à tout faire fonctionner à ma convenance. :/
Déjà, je souhaitais avoir une précision car je ne comprend pas bien. Quand il est dit : On ne doit plus jouer au jeu en console. À la place, le jeu doit être une application serveur. Application veut dire exécutable ? Ou bien que le jeu doit avoir une interface graphique ? Je suis confus sur ce point.
Mais ce n'est pas pour ça que je viens. C'est en particulier au sujet d'une difficulté que j'ai : quand je crée mon serveur, et que mes clients se connectent dessus, seul le premier qui se connecte reçoit mon message "Celui qui souhaite commencer appui sur C". Et d'ailleurs, seul le premier a une influence la dessus.
Voilà la partie du code où il semble il y a avoir un soucis. J'espère que ce n'est pas trop moche. :x
hote = ''
port = 12800
connexion_principale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion_principale.bind((hote, port))
connexion_principale.listen(5)
un_joueur_victorieux = False
labyrinthe_choisir = None
serveur_lance = True
clients_connectes = []
while serveur_lance:
connexions_demandees, wlist, xlist = select.select([connexion_principale],
[], [], 0.05)
for connexion in connexions_demandees:
connexion_avec_client, infos_connexion = connexion.accept()
clients_connectes.append(connexion_avec_client)
try:
clients_a_lire, wlist, xlist = select.select(clients_connectes,
[], [], 0.05)
except select.error:
pass
if labyrinthe_choisir == None:
for client in clients_connectes:
client.send(b"Celui qui souhaite commencer appui sur C")
message_joueur_commence_niveau = client.recv(1024)
message_joueur_commence_niveau = message_joueur_commence_niveau.decode()
if message_joueur_commence_niveau.lower() == "c":
labyrinthe_choisir = JoueurChoisiCarte(client)
else:
while un_joueur_victorieux != True:
for client in clients_connectes:
labyrinthe_choisir.LancerPartieJoueur(client)
un_joueur_victorieux = labyrinthe_choisir.VerifierVictoireRobotPosition(client)
if un_joueur_victorieux == True:
for client in clients_connectes:
client.close()
connexion_principale.close()
J'aimerai faire en sorte que le message s'affiche en même temps chez les deux joueurs et que c'est le premier qui appuie sur C qui choisisse le niveau (comme prévu finalement).
J'ai relu les dernier cours et je me suis dit que, peut être, il faut utiliser le threading ? Mais je ne vois vraiment pas en quoi faire. Je suis assez perdu.
Merci d'avance pour votre aide, Bonne journée / soirée
pour ma part, je suis en plein dedans (vive le laby ), ce que j'ai compris de l'exercice :
On ne doit plus jouer au jeu en console. À la place, le jeu doit être une application serveur. Il faut également créer les applications clients pour jouer à plusieurs au labyrinthe. Chaque joueur aura son propre robot. Au lieu de le placer à un endroit précis sur la carte, il apparaîtra aléatoirement ;
1- développer un programme serveur qui gérera les labyrinthes
2- développer un programme client pour les joueurs
Pour ton code ......
Je viens d'essayer, et il y a un blocage effectivement .... voir plusieurs ...
Alors je vais te donner des pistes de réflexions, voici un extrait de ton programme:
if labyrinthe_choisir == None:
for client in clients_connectes:
client.send(b"Celui qui souhaite commencer appui sur C")
message_joueur_commence_niveau = client.recv(1024)
message_joueur_commence_niveau = message_joueur_commence_niveau.decode()
cette partie de programme est lancée dès qu'une connexion est établie => Dès que le premier client reçoit le message, on sort de la boucle, mais on demande un message de sa part .
Si il réponds (il est sympa ) il débloque la commande et le message sera envoyé au second client connecté et ...... on attends à nouveau une réponse mais de qui ???
Réponse : de celui-ci (Pas super top ...)
Et si il envoi quelque chose, on envoi le message au fur et à mesure aux clients connectés
Pour résumer, ça ressemble à çà:
envoi client 1-> attente de réponse du client 1 -> envoi client 2-> attente de réponse du client 2 -> envoi client 3 -> etc...
les thread pourront te permettre de faire fonctionner de manière 'autonome' les demandes de connexions, les envois et les réceptions de messages.
Voilà espérant t'avoir un peu aidé (perso, j'ai galéré deux trois jours sur cette question, ça et les erreurs [10054] de windows lors de la déconnexion du client qui me faisait planté le serveur et c'est pas fini mais on va réussir)
Ouiiiii ! C'est bien ça le soucis, j'en ai bouffé toute la journée du code et c'est clair que le soucis vient de là x)
Je souffre à créer une manière efficace de gérer. Le système de thread me fait mal au crâne. Faut vraiment que j'apprenne et adapte ça à mon code qui est un peu boiteux. Par curiosité, sur quoi est ce tu bloques ?
J'espère réussir avant lundi en tout cas. Je croise les doigts.
Yo, avant lundi c'est chaud , ca fait quelques jours que je suis dessus,
mais je me dis tous les jours que je me coucherais un peu plus fort que la veille.
Pour les threads, j'ai résolu mon problème en créant une class Client(threading.Thread) par connexions de nouveau joueur. En effet, l'identité "client" pourra se retrouver dans le self et j'en surveille les messages et gère les envois
J'approche de la fin je pense. J'édite tout mon message pour montrer où le code en est :
# -*-coding:Utf-8 -*
import os
from labyrinthe import Labyrinthe, Joueur
import sys, threading
import socket
import select
liste_de_labyrinthes = []
labyrinthe_choisi = None
un_joueur_victorieux = False
liste_client = []
clients_connectes = []
lancer_jeu = False
client_nom_connexion = {}
def ImporterCartes(liste_de_labyrinthesVar):
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
def ServeurChoisiCarte():
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ImporterCartes(liste_de_labyrinthes)
labyrinthe_choisi = ServeurChoisiCarte()
class ThreadClient(threading.Thread):
'''dérivation de classe pour gérer la connexion avec un client'''
def __init__(self,conn):
threading.Thread.__init__(self)
self.connexion = conn
self.nom = ""
# Mémoriser la connexion dans le dictionnaire
liste_client.append(self.connexion)
print("Connexion du client", self.connexion.getpeername(),self.connexion)
def run(self):
self.nom = self.getName()
while True:
message = self.connexion.recv(1024)
message = message.decode()
if message.lower() == "c" and labyrinthe_choisi.lancer_partie == False:
labyrinthe_choisi.LancerPartieJoueur(self.connexion, client_nom_connexion)
else:
if labyrinthe_choisi.lancer_partie == True:
labyrinthe_choisi.LancerPartieJoueur(self.connexion, client_nom_connexion)
self.connexion.close()
del client_nom_connexion[nom]
# Initialisation du serveur
HOST = ''
PORT = 12800
connexion_principale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
connexion_principale.bind((HOST, PORT))
except socket.error:
print("La liaison du socket à l'adresse choisie a échoué.")
sys.exit()
print("Serveur prêt (port",PORT,") en attente de clients...")
connexion_principale.listen(5)
while True:
# Attente connexion nouveau client
try:
connexion, adresse = connexion_principale.accept()
except:
sys.exit()
# Créer un nouvel objet thread pour gérer la connexion
th = ThreadClient(connexion)
# The entire Python program exits when no alive non-daemon threads are left
th.setDaemon(1)
th.start()
# Création d'un dictionnaire pour connaître quel nom va avec quelle connexion
th_nom = th.getName()
client_nom_connexion[th_nom] = connexion
labyrinthe_choisi.CreerRobotPositionHasard(connexion)
message = "Vous êtes connecté au serveur.\nAttente des autres clients...\nSi vous souhaitez commencer, appuyer sur C"
connexion.send(message.encode())
L'affichage de la map n'est pas encore parfait, mais on s'approche de quelque de satisfaisant. :3 J'espère que ça va aider certain, bon courage
EDIT : Tout fonctionne ! Pour ceux qui se demande où je bloquais : je n'avais pas pris en considération que je demandais plusieurs fois au joueur de taper une commande d'affiler / et également, j'ai fais en sorte qu'à l'aide de booleen, chaque joueur soit appeler individuellement à taper une action. Si il y a des question n'hésitez pas.
Je suis en train de réaliser le 4ème chapitre du cours de Phyton "Les structures conditionnelles" et mon programme ne fonctionne pas et je ne comprends pas la raison. Merci de bien vouloir m'aider
# -*-coding:Latin-1 -*
import os
annee=input("Saisissez votre annee: ")
annee=int(annee)
if annee%4==0:
if annee%100==0:
if annee%400==0:
print("Annee bissextile")
else:
print("Annee normale")
else:
print("Annee normale")
else:
print("Annee normale")
os.system("pause")
Juste au cas où, j'ai recopié ton code, visual studio me signal qu'il semblerait qu'il y a un problème d'indentation au niveau du premier else : généralement 4 espace ou une tabulation pour indenter.
Je me posais des questions au sujets des tests unitaires pour les TP. Il faut écrire les test au sein des scripts concernés ou bien concevoir un script test exprès ? Désolé si ça semble vraiment idiot comme question. :S
Le problème dans ce code est l'incompréhension au niveau des variables.
temp_list_clefs n'est pas une copie de self._clefs, c'est exactement la même liste. Donc quand reverse est appelée sur temp_list_clefs, elle l'est aussi sur self._clefs. Donc les variables temporaires n'ont pas d'utilité.
Par ailleurs, même si une copie était utilisée, je ne vois pas à quoi elle servirait, puisqu'on peut justement déjà inverser une liste en place.
Merci beaucoup, juste une « dernière » question: je viens de commencer l'activité du labyrinthe.
Il y a quand même une sacrée marche à gravir dans le cours à ce niveau, non ?
Est-ce moi qui délire ?
@StarofGames
Si tu ne souhaites pas faire :
year = int(year)
if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
print("-> " + str(year) + " est une année bissextile !")
else:
print("-> " + str(year) + " est une année non-bissextile !")
essaye :
year = int(year)
if year % 400 == 0:
print("-> " + str(year) + " est une année bissextile !")
elif year % 4 == 0 and year % 100 != 0:
print("-> " + str(year) + " est une année bissextile !")
else:
print("-> " + str(year) + " est une année non-bissextile !")
@ letengu : Oui, c'est sûr que ça devient un peu plus compliqué à ce moment là. Il faut vraiment partitionner ton raisonnement pour ce labyrinthe et te poser plein de questions. La plus importante, c'est celle là : Comment je vais déplacer mon robot dans le labyrinthe (pour t'aiguiller un peu, c'est surtout se poser la question : est ce que si je déplace mon robot là, il y a un mur ou non ? Si oui, je ne la déplace pas, sinon je le déplace).
Désolé de revenir à charger sur mon soucis mais je ne comprend bêtement pas où écrire les tests unitaires. Est ce que je glisse mes tests juste en dessous de mes fonctions normales, ou alors je dois créer des fonctions test de même nature que mes fonctions dans une autre classe ? Je n'arrive vraiment pas à comprendre ça. Vraiment navré si ça semble bête - si c'est possible d'avoir un exemple, ce serai super.
@ letengu : dans l'activité, le découpage est particulier et c'est à toi de l'adopter à tes besoin.
De mémoire il contient : - robotc.py (qui sert à importer des fichiers textes contenants les cartes [pour ma part, j'y ai glissé aussi le code pour lancer l'application]) - carte.py (qui sert à traiter les données récupérés par l'importation des fichiers textes [en clair, il faut faire communiquer robotc et carte]) - labyrinthe.py (qui, pour ma part, contient le gros du code du jeu [déplacement, affichage, etc]).
Tu peux structurer vraiment comme tu le souhaites sinon. Tu n'es pas obligé de te laisser limiter par ce que propose l'exercice.
Pour avoir corrigés des copies d'autres personnes, certains crées des fichiers contenants des class comme : Joueur / SauvegarderEtCharger C'est à toi de voir ce que tu veux
Hésites pas à bidouiller, il y a plusieurs méthodes pour réaliser cette activité.
Je viens de réaliser l'exercice des années bissextiles (structures conditionnelles) mais d'une façon un peu voir vraiment différente de la correction.
Quelqu'un pourrait voir mon code et vérifier si il est valide ?
annee = input("Saisissez une année : ")
annee = int(annee)
if annee%4 != 0:
print("Ce n'est pas une année bissextile")
elif annee%4 == 0:
if annee%100 == 0:
if annee%400 == 0:
print("C'est une année bissextile")
else:
print("Ce n'est pas une année bissextile")
else:
print("C'est une année bissextile")
J'en suis a la gestion des erreur et bug du cours "perfectionnez-vous en python". Le problème est dans le programme suivant :
import argparse
import analysis.csv as c_an
import analysis.xml as x_an
def parse_arguments():
parser = argparse.ArgumentParser()
parser.add_argument("-e","--extension", help="""Type of file to analyse. Is it a CSV or an XML ?""")
parser.add_argument("-d", "--data_file", help=""" Analyse directly the data""")
return parser.parse_args()
def main():
args = parse_arguments()
datafile = args.datafile
if args.extension == 'xml':
x_an.launch_analysis(datafile)
elif args.extension == 'csv':
c_an.launch_analysis(datafile)
if __name__ == '__main__':
main()
A l’exécution proposé par le cours je reçois le message d'erreur suivant :
datafile = args.datafile
AttributeError: 'Namespace' object has no attribute 'datafile'
Et la j'avoue que j'ai chercher un peu mais les solutions proposer ont l'air d'être d'un tout autre niveau que celui du cours.
Une erreur simple ce serais glisser dans mon code ?
Sans plus tester que cela, je dirais que l'argument devrait s'appeler --datafile ou l'attribut data_file. Mais là, les noms ne correspondent pas, il y a un underscore d'un côté et pas de l'autre.
Bénédicte
entwanne — @entwanne — Un zeste de Python — La POO en Python — Notions de Python avancées — Les secrets d'un code pythonique
Bénédicte
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