salut, je suis débutent en python, et je commence a m’intéresser aux réseaux. notamment à la communication Socket. je bosse sous Windows et python3.6. mon projet actuel pour me faire la main en python, est une messagerie instantané avec la librairie Socket.
je me suis donc attelé a la création d'un client et d'un serveur.
cependant j'ai 2 problème. quand j'envoi une message du client au serveur le le serveur ne reçois le message qu'au moment ou il en envoi une. alors que j'ai fais un thread pour la réception de message de manière a avoir une communication asynchrone.
mon 2ème problème est que quand j'envoi un message du serveur au client ce dernier ne reçois rien.

voila le code du client
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
 
import threading
import socket
import os
 
 
#------------------------------------------------------
class threadReception(threading.Thread):		#thread de reception pour chaque mySocket existante
 
	def __init__(self,aself, conn):
		threading.Thread.__init__(self)
		self.mySocket = conn			#csocket de communication (unique a chaque mySocket)
		self.aself = aself		#héritage du self
		self.isALive = True
 
 
	def run(self):
		while self.isALive:
			message = self.mySocket.recv(1024).decode('utf8') #on recoit les infos de cet communication
			if not message:
				pass
 
			else:
				print(message)
		mySocket.close()
 
 
class client():			#classe de base, pour mika
 
	def __init__(self, ip, port = 22000):		#initialisation de l'ip, port
		self.IP = ip
		self.PORT = port
		self.mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)	#création du socket
 
 
	def start(self):		#methode a lancer pour tout initialiser
		try:
			self.mySocket.connect((self.IP, self.PORT))		#connexion
			return True						# si réussite, renvoie true, sinon false
			threadReception()
		except Exception as e:
			print(e)
 
	def stop(self):						#lorsqu'on étein la table, on etein le serveur
		self.clientALive = False
		self.mySocket.close()
 
 
	def send(self, message):				#méthode pour envoyer un message à l'adresse choisie
		try:
			self.mySocket.send(message.encode('utf8'))		#envoi du message
		except Exception as e:
			print (e)
			print ('appareil faux/ pb de connexion')
 
 
while 1 :
	a = client('localhost',8000)
	a.start()
	msg = input('> ')
	a.send(msg)

et celui du serveur
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
 
import threading
import socket
import os
import time 
 
 
#------------------------------------------------------
class threadReception(threading.Thread):		#thread de reception pour chaque connexion existante
 
	def __init__(self, envoi, add, conn):
		threading.Thread.__init__(self)
		self.addresse = add		#adresse pour recuperer la connexion / supprimer
		self.connexion = conn			#csocket de communication (unique a chaque connexion)
		self.envoi = envoi		#héritage du self
		self.isALive = True
 
 
	def run(self):
		while self.isALive:
			message = self.connexion.recv(1024).decode('utf8') #on recoit les infos de cet communication
			if not message:
				break
 
			else:
				print(message)
		self.connexion.close()		#on ferme le socket
		del self.envoi.connectedList[self.addresse]		#on suprime la connexion du dictionnaire
 
 
 
 
 
class serveur(threading.Thread):			#classe de base, pour mika
 
	def __init__(self, ip, port = 22000):		#initialisation de l'ip, port
		threading.Thread.__init__(self)
		self.IP = ip
		self.PORT = port
		self.connectedList = {}			# {'adresse':connexion} creation du dictionnaire qui comporte l'adresse et le socket connexion d'un appareil
		self.mySocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)	#création du socket
		#self.mySocket.settimeout(0.2)		#timeout pour ne pas blocquer le while plus tard
		self.serverALive = True				#activation du while
 
 
	def run(self):		#methode a lancer pour tout initialiser
		print('serveur start')
 
		try:
			self.mySocket.bind((self.IP, self.PORT))		#bind du socket sur l'ip et le port
		except Exception as e:
			print(e)
			return False
 
		while self.serverALive:				#tant que le serveur est en vie, 
			try:
				self.mySocket.listen(10)
				connexion, adresse= self.mySocket.accept()		#connexion : socket de comunication, addresse liste [ip, port]
				self.connectedList[adresse[0]] = connexion		#enregistre dans le dico le socket de connexion avec l'adresse en clée
				threadReception(self, adresse[0], connexion).start()				#on lance le thread de reception pour chaque connexion
			except Exception as e:
				print(e)
 
 
 
	def stop(self):						#lorsqu'on étein la table, on etein le serveur
		self.serverALive = False
		self.mySocket.close()
		print('serveur deconecter')
 
 
	def getConnected(self):				#renvoie la liste des appareils connectés (clée du dico)
		lis = []
		for i in self.connectedList:
			lis.append(i)
		return lis
 
 
	def send(self, appareil, message):				#méthode pour envoyer un message à l'adresse choisie
		try:
			self.connectedList[appareil].send(message.encode('utf8'))		#envoi du message
		except Exception as e:
			print (e)
			print ('appareil faux/ pb de connexion')
 
 
 
a = serveur('localhost', 8000)
a.start()
while 1:
	try:
		listen = a.getConnected()
		listen = listen[0]
	except Exception as e:
		#print(e)
		pass
	else :
		msg = input('> ')
		a.send(listen,msg)
ps : je suis dyslexique désoler par avance pour les fautes.