effet de thé virtuel python

Cette fois, je vais vous présenter l'effet du goûter virtuel python. Quelles sont les précautions pour l'effet du goûter virtuel python. Ce qui suit est un cas pratique, jetons un coup d'œil.

Lors de l'apprentissage et de l'utilisation de presque tous les langages de programmation, la pratique sur les sockets ne manque jamais, en particulier lorsqu'on écrit sur la communication LAN. Ce projet du livre est donc idéal pour pratiquer la programmation socket.

L'idée générale de cet exercice est d'avoir dans un premier temps un serveur de chat. Les principales fonctions de ce serveur sont de fournir des connexions socket client, stocker la session de connexion de chaque client, traiter les messages envoyés par chaque connexion. et analysez les données envoyées par le client. C'est tout. Quant au client, vous n'avez pas besoin d'écrire de code, utilisez simplement l'outil telnet du système.

Je pense qu'avec l'analyse ci-dessus, il n'y a pas grand chose à dire sur le reste de ce programme, sauf bien sûr, à l'exception des deux classes qui encapsulent les sockets.

J'ai essayé cela en utilisant la classe socket en python et j'ai écrit un programme de communication simple. Cependant, pour une raison quelconque, des accidents se produisaient toujours pendant la communication. Ce code simple est le suivant :

server.py

import socket
mysocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
mysocket.bind(('',8888))
mysocket.listen(5)
while True:
    connection,addr = mysocket.accept()
    revStr = connection.recv(1024)
    connection.send('Server:' + revStr)
    connection.close()

clinet.py

import socket
import time
clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
clientsocket.connect(('',8888))
while True:
    time.sleep(2)
    clientsocket.send('hello the5fire')
    print clientsocket.recv(1024)
clientsocket.close()

La raison pour laquelle ce programme a mal tourné n'est pas détaillée, car dans python Deux classes encapsulées sont fournies pour compléter le processus de communication du socket : async_chat dans asynchat et dispatcher dans asyncore et asyncore lui-même. La première classe est utilisée pour gérer chaque session entre le client et le serveur, et la seconde classe est principalement utilisée pour fournir des services de connexion socket. Et chaque connexion socket est hébergée par la première (async_chat) pour le traitement.

Regardez le code :

from asyncore import dispatcher
from asynchat import async_chat
import socket, asyncore
PORT = 5005
NAME = 'TestChat'
class EndSession(Exception):pass
class CommandHandler:
    def unknown(self, session, cmd):
        session.push('Unknown command: %s\r\n' % cmd)
    def handle(self, session, line):
        if not line.strip(): return
        parts = line.split(' ',1)
        cmd = parts[0]
        try: line = parts[1].strip()
        except IndexError: line = ''
        meth = getattr(self, 'do_'+cmd, None)
        try:
            meth(session, line)
        except TypeError:
            self.unknown(session,cmd)
class Room(CommandHandler):
    def init(self, server):
        self.server = server
        self.sessions = []
    def add(self, session):
        self.sessions.append(session)
    def remove(self, session):
        self.sessions.remove(session)
    def broadcast(self, line):
        for session in self.sessions:
            session.push(line)
    def do_logout(self, session, line):
        raise EndSession
class LoginRoom(Room):
    def add(self,session):
        Room.add(self,session)
        self.broadcast('Welcome to %s\r\n' % self.server.name)
    def unknown(self, session, cmd):
        session.push('Please log in \nUse "login"\r\n')
    def do_login(self, session, line):
        name = line.strip()
        if not name:
            session.push('Please enter a name\r\n')
        elif name in self.server.users:
            session.push('The name "%s" is taken.\r\n' % name)
            sessoin.push('Please try again.\r\n')
        else:
            session.name = name
            session.enter(self.server.main_room)
class ChatRoom(Room):
    def add(self, session):
        self.broadcast(session.name + ' has entered the room.\r\n')
        self.server.users[session.name] = session
        Room.add(self, session)
    def remove(self, session):
        Room.remove(self, session)
        self.broadcast(session.name + ' has left the room.\r\n')
    def do_say(self, session, line):
        self.broadcast(session.name + ': ' + line + '\r\n')
    def do_look(self, session, line):
        session.push('The following are in this room:\r\n')
        for other in self.sessions:
            session.push(other.name + '\r\n')
    def do_who(self, session, line):
        session.push('The following are logged in:\r\n')
        for name in self.server.users:
            session.push(name + '\r\n')
class LogoutRoom(Room):
    def add(self, session):
        try: del self.server.users[session.name]
        except KeyError: pass
class ChatSession(async_chat):
    def init(self, server, sock):
        async_chat.init(self,sock)
        self.server = server
        self.set_terminator('\r\n')
        self.data = []
        self.name = None
        self.enter(LoginRoom(server))
    def enter(self, room):
        try: 
            cur = self.room
        except AttributeError: 
            pass
        else: cur.remove(self)
        self.room = room
        room.add(self)
    def collect_incoming_data(self, data):
        self.data.append(data)
    def found_terminator(self):
        line = ''.join(self.data)
        self.data = []
        try: self.room.handle(self, line)
        except EndSession:
            self.handle_close()
    def handle_close(self):
        async_chat.handle_close(self)
        self.enter(LogoutRoom(self.server))
class ChatServer(dispatcher):
    def init(self, port, name):
        dispatcher.init(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.bind(('',port))
        self.listen(5)
        self.name = name
        self.users = {}
        self.main_room = ChatRoom(self)
    def handle_accept(self):
        conn, addr = self.accept()
        ChatSession(self,conn)
if name == 'main':
    s = ChatServer(PORT, NAME)
    try: asyncore.loop()
    except KeyboardInterrupt: print

L'ensemble du programme est divisé en trois parties que j'ai mentionnées au début :

Fournit la connexion socket du client : classe ChatServer.

Stocker la session de connexion de chaque client et traiter les messages envoyés par chaque connexion : Classe ChatSession La fonction de cette classe est très simple Elle accepte les données et détermine s'il y a un terminateur. Si c'est le cas, le found_terminator. la méthode est appelée.

Analyser les données envoyées par le client : ce sont les classes restantes liées à la pièce. Ces classes sont utilisées pour traiter les chaînes et les commandes envoyées par le client, et elles sont toutes héritées de. Gestionnaire de commandes.

Capture d'écran finale :

Je pense que vous maîtrisez la méthode après avoir lu le cas dans cet article. Pour des informations plus intéressantes, veuillez prêter attention aux autres informations connexes. articles sur le site php chinois !

Lecture recommandée :

Solution parfaite pour que python2.7 ne puisse pas utiliser pip

Comment lire par lots des fichiers txt dans DataFrame au format python

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!