Explication détaillée de trois méthodes d'appel de la fonction recv pour recevoir complètement des données dans la programmation réseau Python

Récemment, j'utilise python pour la programmation réseau afin de développer un gadget de test tcpclient universel. Dans la programmation réseau utilisant des sockets, la manière de déterminer si un message envoyé par l'homologue a été reçu est une question à prendre en compte lors du développement de réseaux de sockets. Ici, une brève introduction aux trois méthodes couramment utilisées pour déterminer l'achèvement de la réception des données :

1. Méthode de réception de données de base :

Lors de l'utilisation de la réception de données de base méthode, lors de l'utilisation de la méthode de réception de données de base, lorsque la prise de service est déconnectée, une chaîne vide sera reçue. Par conséquent, selon cette fonctionnalité, une boucle peut être ajoutée au programme pour continuer à recevoir des données jusqu'à ce que l'extrémité d'envoi des données ferme la connexion socket. Scénarios applicables : Le lien entre le client et le serveur est un lien court (c'est-à-dire que la connexion sera fermée après une communication socket). Le code est le suivant :

import socket,struct,sys,time

Port=22220
#assume a socket disconnect (data returned is empty string) means  all data was #done being sent.
def recv_basic(the_socket):
    total_data=[]
    while True:
        data = the_socket.recv(20480)    
        if not data: break
        total_data.append(data)
    return ''.join(total_data)

2. Méthode d'identification de la queue

Obtenez les données complètes en recherchant la chaîne d'identification de la queue dans le protocole reçu message de données de données. Scénario applicable : les données de protocole reçues contiennent des identifiants de queue pertinents. Le code est le suivant :

End='something useable as an end marker'
def recv_end(the_socket):
    total_data=[];data=''
    while True:
            data=the_socket.recv(8192)
            if End in data:
                total_data.append(data[:data.find(End)])
                break
            total_data.append(data)
            if len(total_data)>1:
                #check if end_of_data was split
                last_pair=total_data[-2]+total_data[-1]
                if End in last_pair:
                    total_data[-2]=last_pair[:last_pair.find(End)]
                    total_data.pop()
                    break
    return ''.join(total_data)

3. Méthode de longueur de charge utile

C'est-à-dire déterminer la longueur du message effectif via la valeur de longueur de charge utile dans le protocole data. Scénarios applicables : protocole Les données contiennent un champ de protocole de charge utile. Cette méthode est également une méthode courante et universelle, mais elle nécessite en même temps de recevoir des données et de les analyser. Le code est le suivant :

def recv_size(the_socket):
    #data length is packed into 4 bytes
    total_len=0;total_data=[];size=sys.maxint
    size_data=sock_data='';recv_size=8192
    while total_len<size:
        sock_data=the_socket.recv(recv_size)
        if not total_data:
            if len(sock_data)>4:
                size_data+=sock_data
                size=struct.unpack(&#39;>i&#39;, size_data[:4])[0]
                recv_size=size
                if recv_size>524288:recv_size=524288
                total_data.append(size_data[4:])
            else:
                size_data+=sock_data
        else:
            total_data.append(sock_data)
        total_len=sum([len(i) for i in total_data ])
    return &#39;&#39;.join(total_data)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!