IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

variable persistante entre plusieurs programmes différentes


Sujet :

Python

  1. #21
    Expert éminent
    Avatar de tyrtamos
    Homme Profil pro
    Retraité
    Inscrit en
    Décembre 2007
    Messages
    4 461
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Var (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2007
    Messages : 4 461
    Points : 9 248
    Points
    9 248
    Billets dans le blog
    6
    Par défaut
    Bonjour,

    Pour le client, rien n'empêche de créer une fonction pour l'envoi de la requête au serveur et le retour de la réponse.

    Voilà comment on pourrait écrire le 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
    #!/usr/bin/python3
    # -*- coding: utf-8 -*-
     
    """
    client TCP
    """
     
    import socket
     
    ##############################################################################
    def envoirequete(requete, adresse, encodage, buffer):
     
        # établit une nouvelle connexion
        maSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            maSocket.connect(adresse)
        except:
            raise ValueError ("Echec de connexion")
     
        # envoie la requête au serveur
        envoi = maSocket.send(bytes(requete + '\n', encodage))
     
        # réceptionne la réponse du serveur
        reponse = str(maSocket.recv(buffer), encodage).rstrip()
     
        # arrête la connexion
        maSocket.shutdown(socket.SHUT_RDWR)
        maSocket.close()
     
        # retourne la réponse du serveur
        return reponse
     
    ##############################################################################
    if __name__ == '__main__':
     
        buffer=65536 #1024 => à adapter aux données à recevoir!
        adresse=('localhost', 20000)
        encodage = 'cp850' # encodage='cp850' pour la console Windows
     
        while True:
     
            # saisie la requete au clavier
            requete = input("?: ").strip()
     
            try:
                # envoie la requête au serveur
                reponse = envoirequete(requete, adresse, encodage, buffer)
                # affiche la réponse
                print(reponse)
            except ValueError as msgerreur:
                # affiche l'erreur "Echec de connexion"
                print(str(msgerreur))
    En s'inspirant de ça, on peut très bien automatiser une liste d'envois de requêtes, qui donnera une liste de réponses.
    Un expert est une personne qui a fait toutes les erreurs qui peuvent être faites, dans un domaine étroit... (Niels Bohr)
    Mes recettes python: http://www.jpvweb.com

  2. #22
    Membre du Club
    Inscrit en
    Septembre 2010
    Messages
    75
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 75
    Points : 42
    Points
    42
    Par défaut
    Bonjour,

    Un grand merci à toi j'y ai passé beaucoup de temps et finalement coté client j'ai simplifier le code sans boucle comme c'était appeler par une autre partie de programme ça n'était pas utile.
    "a priori" ça fonctionne.
    j'ai du lutter contre certaines erreurs mais ça fonctionne (pour l'instant)
    Coté serveur j'ai laissé la fermeture connexion mais je ne sais jamais si il faut fermer coté client et coté serveur la connexion ou que du coté client.
    voici donc mon code final.
    Si ça peut servir.

    Pour la partie 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
     
    import socket, sys, threading, socketbinance
     
    server_ip = "192.168.0.200"
    server_port = 8090
     
    #TODO paramétrer le timeout du serveur durant coupure
    status = socketbinance.Socket_order_status()
    status.start_socket()
     
     
    class ThreadClient(threading.Thread):
        # class pour géré le thread des connexions client
        def __init__(self, conn):
            threading.Thread.__init__(self)
            self.connexion= conn
     
        def run(self):
            #dialogue avec le client
            nom = self.getName() #chaque thread possède un nom
            #connexion au serveur binance pour récupérer les ordre
            while 1:
                msgclient = self.connexion.recv(4096).decode("cp850")
                if not msgclient or msgclient.upper() =="FIN":
                    break
                message = "%s > %s" % (nom, msgclient)
                print(message)
                filter = msgclient.split()
                print("conetnue de la variable",filter)
     
     
    #ma fonction principale renvoyant des infos aux clients
                if filter[0] =="getorderid":
                    # print("rentre dans la condition test orderid")
                    # print ("valeur retournée ===>",status.get_status_order_id(orderid=filter[1]))
                    # print(status.get_status_order_id(orderid=filter[1]))
                    self.connexion.send(str(status.get_status_order_id(orderid=filter[1])).encode("cp850")) 
     
            #Fermeture de la connexion:       
            self.connexion.close() # copure la connexion cote serveur
            del conn_client[nom]    #supprmier son entrée dans le dictionnaire
            print("Client %s déconnecté." % nom)
     
    # initialisation du serveur - Mise en place du socket:
    mysocket= socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    try:
        mysocket.bind((server_ip, server_port))
    except socket.error:
        print("La liaison du socket à l'adresse choisi a echoué")
        sys.exit()
    print("Serveur pret, en attente de requetes ...")
    mysocket.listen(3)
     
    # Attente et prise en charge des connexions demandées par les clients:
    # dictionnaire des conneions clients
    conn_client={}
    while 1:
        connexion, adresse= mysocket.accept()
        #créer un nouvel objet thread pour gérer la connexion:
        th = ThreadClient(connexion)
        th.start()
        #mémoriser la connexion dans le dictionnaire:
        it = th.getName() #identifiant du thread
        conn_client[it]=connexion
        print("client %s connecté, adressse IP %s, port %s" %\
              (it, adresse[0], adresse[1]))
     
        #dialogue  avec le client:#posé un souci et une erreur cette partie causé des erreurs
        # msg= "Vous êtes connecté. Envoyé vos messages."
        # connexion.send(msg.encode("cp850"))
    Ma partie cliente

    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
     
    import socket,sys,time,mail
     
     
    server_ip = "192.168.0.200"
    server_port = 8090
    requete=''
     
    def socclient(orderid):
        connexion = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        try:
            connexion.connect((server_ip,server_port))
        except socket.error:
            print("connexion du client échoué")
            mail.Send.mail(subject="client socket local binance",
                           text='erreur dans socket client binance' )
            sys.exit()
        print("connexion etablie avec le serveur")
     
        connexion.send(str(orderid).encode("cp850"))
        time.sleep(0.0015)#sinon pas de temps pour la réponse
     
        return (connexion.recv(4096).decode("cp850"))
     
        connexion.shutdown(socket.SHUT_RDWR)

    Je vous remercie à tous pour votre temps !

Discussions similaires

  1. [XL-2016] Variables partagées entre plusieurs fichiers
    Par Saperlipopette dans le forum Macros et VBA Excel
    Réponses: 3
    Dernier message: 08/11/2018, 16h58
  2. Variable globale entre plusieurs scripts
    Par Dan25 dans le forum VBScript
    Réponses: 2
    Dernier message: 01/03/2011, 18h15
  3. variable "globale" entre plusieurs fichiers
    Par kitue dans le forum Caml
    Réponses: 2
    Dernier message: 18/01/2010, 17h58
  4. Réponses: 12
    Dernier message: 14/08/2006, 13h55
  5. Partage de variables entre plusieurs pages
    Par bud_gw dans le forum Général JavaScript
    Réponses: 10
    Dernier message: 27/12/2005, 16h42

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo