Python-Effekt für virtuelle Teeparty

Dieses Mal werde ich Ihnen die Wirkung der virtuellen Python-Teeparty vorstellen. Was sind die Vorsichtsmaßnahmen für die Wirkung der virtuellen Python-Teeparty?

Beim Erlernen und Verwenden fast aller Programmiersprachen mangelt es nie an Socket-Übungen, insbesondere wenn es darum geht, über die Kommunikation in lokalen Netzwerken zu schreiben. Daher ist dieses Projekt im Buch genau das Richtige, um die Socket-Programmierung zu üben.

Die Gesamtidee dieser Übung besteht darin, zunächst einen Chat-Server zu haben. Die Hauptfunktionen dieses Servers bestehen darin, Client-Socket-Verbindungen bereitzustellen, die Verbindungssitzung jedes Clients zu speichern und die von jeder Verbindung gesendeten Nachrichten zu verarbeiten , und analysieren Sie die vom Client gesendeten Daten. Das ist alles. Für den Client müssen Sie keinen Code schreiben, sondern einfach das Telnet-Tool des Systems verwenden.

Ich denke, mit der obigen Analyse gibt es nicht viel über den Rest dieses Programms zu sagen, außer natürlich den beiden Klassen, die Sockets kapseln.

Ich habe dies mithilfe der Socket-Klasse in Python versucht und ein einfaches Kommunikationsprogramm geschrieben. Aus irgendeinem Grund kam es jedoch immer zu Unfällen bei der Kommunikation. Dieser einfache Code lautet wie folgt:

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()

Der Grund für den Fehler in diesem Programm ist nicht detailliert, weil In Python werden zwei gekapselte Klassen bereitgestellt, um den Socket-Kommunikationsprozess abzuschließen: async_chat in Asynchat und Dispatcher in Asyncore und Asyncor selbst. Die erstere Klasse wird verwendet, um jede Sitzung zwischen dem Client und dem Server abzuwickeln, und die letztere Klasse wird hauptsächlich zur Bereitstellung von Socket-Verbindungsdiensten verwendet. Und jede Socket-Verbindung wird von ersterem (async_chat) zur Verarbeitung gehostet.

Schauen Sie sich den Code an:

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

Das gesamte Programm ist in die drei Teile unterteilt, die ich am Anfang erwähnt habe:

Stellt die Socket-Verbindung des Clients bereit: ChatServer-Klasse.

Speichern Sie die Verbindungssitzung jedes Clients und verarbeiten Sie die von jeder Verbindung gesendeten Nachrichten: Die Funktion dieser Klasse ist sehr einfach. Sie akzeptiert Daten und bestimmt, ob ein Terminator vorhanden ist Methode aufgerufen wird.

Analysieren Sie die vom Client gesendeten Daten: Es handelt sich um die verbleibenden raumbezogenen Klassen. Diese Klassen werden zur Verarbeitung der vom Client gesendeten Zeichenfolgen verwendet und werden alle von ihnen geerbt CommandHandler.

Letzter Screenshot:

Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln Artikel auf der chinesischen PHP-Website!

Empfohlene Lektüre:

Perfekte Lösung dafür, dass Python 2.7 Pip nicht verwenden kann

So lesen Sie TXT-Dateien stapelweise in DataFrame im Python-Format

Das obige ist der detaillierte Inhalt vonPython-Effekt für virtuelle Teeparty. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!