projet de didacticiel de base python cinq goûter virtuel

Cet article présente principalement en détail le tea party virtuel du projet de didacticiel de base Python 5. Il a une certaine valeur de référence. Les amis intéressés peuvent s'y référer

Apprendre et utiliser presque n'importe quel type de langage de programmation When. , les exercices sur les sockets ne manquent jamais, en particulier lorsqu'il s'agit d'écrire sur la communication sur les réseaux locaux. 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 expliquée en détail, car python fournit deux classes encapsulées pour compléter le processus de communication du socket : async_chat dans asyncchat et dispatcher dans asyncore Ainsi que 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 comme J'ai mentionné au début Chaque partie :

Fournit la connexion socket du client : classe ChatServer.

Stockez la session de connexion de chaque client et traitez 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. , la méthode found_terminator est appelée .

Analyser les données envoyées par le client : ce sont les classes restantes liées à la salle. 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 CommandHandler.

Capture d'écran finale :

Recommandations associées :

Projet de tutoriel de base Python trois-en- un XML

Projet de tutoriel de base Python 2 Bonnes images

Projet de tutoriel de base Python 4 Agrégation de nouvelles

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!