python 全双工 socket聊天

自学python一段时间,一直想弄个有意思的东西,所以就拿socket做一个聊天室,可以一对多,一对一全双工聊天。后续可能完善代码在鼓弄一个带gui界面的,比较有逼格

服务端:

使用socketserver模块,多线程异步处理客户端消息,接受客户消息并转发 既服务端为一个中转站。

加入了 登陆 注册 多人聊天 一对一功能

客户端:

主线程连接服务端,两个子线程分别负责读写

server:

SocketServer
time ctime
threadingtraceback
Queue
db DB
lock=threading.Lock()
local_school = threading.local()

Handler():
    queue = []
    db = DB()
    user_name = {}

    (sock):
        .sock = sock
        .input = [.sock]
        ():
        data = .sock.recv().strip()
        data

    (data):
        .sock.sendall(data)

    ():
        .send()
        .sock.close()
        .queue.remove(.sock)
        .user_name[local_school.user]

    ():
        .sock.close()
        .queue.remove(.sock)
        .user_name[local_school.user]

    (userdata):
        sock .queue:
            sock.sendall(% (ctime()userdata))

    (user_sockuserdata):
        .user_name[user_sock].sendall(% (ctime()userdata))

    (userdata):
        time_data = ctime()
        sock [x x .queue x != .sock]:
            sock.sendall(% (time_datauserdata))

    ():
        funcdict = {
            : .login: .registered}
        :
            .sock.send()
            data = .recv()
            data == :
                .stop()
                data funcdict:
                funcdict[data]()
            :
                .handler()
        :
            .exit()

    ():
        .send()
        data = .recv()
        data == :
            .send()
            data = .recv()
            data == :
                .stop()
                data == :
                .handler()
            :
                .login()
        user_data = data.split()
        (user_data) == :
            user = user_data[]
            passwd = user_data[]
            user_data = .db.get_data() {}

            user user_data user_data[user] == passwd:
                local_school.user=user
                .send()
                .queue.append(.sock)
                .broadcast(% user)
                .user_name[user]=.sock  .send()
                data=.recv()
                data==:
                    .Ltian()
                data==:
                    .one_to_one()
                :
                    .send()
                    .handler()

            :
                .send()
                .login()

        :
            .send()
            .login()

    ():
        .send()
        data = .recv()
        data == :
            .send()
            data = .recv()
            data == :
                .stop()
                .send()
            :
                .handler()
        user_data = data.split()
        (user_data) == :
            user = user_data[]
            passwd = user_data[]

            db_data = .db.get_data() {}
            user db_data:
                .send()
                .registered()
            :
                db_data[user] = passwd
                local_school.user=user
                lock.acquire()
                :
                    .db.put_data(db_data)
                :
                    lock.release()
                .broadcast(% user)
                .queue.append(.sock)
                .user_name[user] = .sock
                .Ltian()
                .queue

        :
            .send()
            .registered()

    ():  .queue
        .send()
        :
            data = .recv()
            data==:
                % .queue
                .stop()% .queue
                .yiduiduo(local_school.userdata)  ():
        .send()
        user_data=.recv()[:]
        user_data==local_school.user:
            .one_to_one()
        user_data .db.get_data():

            .user_name.get(user_data) .user_name[user_data] .queue:
                .send()
                :
                    data=.recv()

                    data==:
                        .send()
                        data=.recv()
                        data==:
                            .one(user_datalocal_school.user)
                            .stop()
                            data==:
                            .Ltian()
                    data==.user_name.get(user_data):.one(user_datalocal_school.userdata)
            :
                .send()
                .one_to_one()
        :
            .send()
            .one_to_one()
MyServer(SocketServer.BaseRequestHandler):
    ():
        .client_address
        .mysock = Handler(.request)
        .mysock.queue
        .mysock.handler()

__name__ == :
    host = port = addr = (hostport)
    server = SocketServer.ThreadingTCPServer(addrMyServer)
    server.request_queue_size=server.serve_forever()

client:

socket *
threading
threads=[]
Client_Handler():
    (ipadr=port=):
        .sock = socket(AF_INETSOCK_STREAM)
        .sock.connect((ipadrport))
        .input=[.sock]
        .input
    (data):
        .sock.sendall(data)

    ():
        data = .sock.recv().strip()
        data
        data

    ():
        :
            :
                data=()
                data==:
                    .send()
                    .sock.close()
                    .send(data)
            :
                ():
        :
            :
                .recv()
            :
                a1=Client_Handler()
chat = threading.Thread(=a1.write) 
threads.append(chat)
chat = threading.Thread(=a1.read)  
threads.append(chat)
threads
i ((threads)):
    threads[i].start()
时间: 2024-11-07 00:47:43

python 全双工 socket聊天的相关文章

Python的socket聊天脚本。

没有前端,多开了一条线程用于接收信息. 服务器端: # -*- coding:utf-8 -*- import socket import threading class Sock_Server: def __init__(self): self.host = '192.168.1.11' # 获取主机名 self.port = 12345 # 端口 self.ser = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 设置模式 self.

python socket 聊天室

import socket s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #绑定端口 s.bind(("127.0.0.1", 8888)) while True: data = s.recvfrom(1024) print(str(data[0].decode("gbk"))) send_data = input("请输入聊天内容") if "exit" in se

Python 的 Socket 编程教程

这是用来快速学习 Python Socket 套接字编程的指南和教程.Python 的 Socket 编程跟 C 语言很像. Python 官方关于 Socket 的函数请看 http://docs.python.org/library/socket.html 基本上,Socket 是任何一种计算机网络通讯中最基础的内容.例如当你在浏览器地址栏中输入 www.oschina.net 时,你会打开一个套接字,然后连接到 www.oschina.net 并读取响应的页面然后然后显示出来.而其他一些聊

python 简单p2p聊天程序

目标是写一个python的p2p聊天的项目,这里先说一下python socket的基础课程 一.Python Socket 基础课程 Socket就是套接字,作为BSD UNIX的进程通信机制,取后一种意思.通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,可以用来实现不同虚拟机或不同计算机之间的通信.在Internet上的主机一 般运行了多个服务软件,同时提供几种服务.每种服务都打开一个Socket,并绑定到一个端口上,不同的端口对应于不同的服务.Socket正如其

Python实现文字聊天室

你是否想过用所学的Python开发一个图形界面的聊天室程序啊? 像这样的: 如果你想开发这样一个有点怀旧风格的聊天程序,那么可以接着看: 要开发这个聊天程序,你需要具备以下知识点: asyncore .asynchat模块使用 wxPython 图形开发 这个聊天程序的实验原理如下: 由于 Python 是一门带 GIL 的语言,所以在 Python 中使用多线程处理IO操作过多的任务并不是很好的选择.同时聊天服务器将同多个 socket 进行通信,所以我们可以基于 asyncore 模块实现聊

python tcp socket 多线程

不多说,直接上代码 client.py #!/usr/bin/python import socket,sys,string host="localhost" port=8000 def main(): sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM) sock.connect((host,port)) message = raw_input("please input whath you want to search

Python 3 socket编程

Python 3 socket编程 一 客户端/服务器架构 互联网中处处是C/S架构 1.C/S结构,即Client/Server(客户端/服务器)结构 2.在互联网中处处可见c/s架构 比如说浏览器,在线视频,各种社交软件. C/S架构与socket的关系: 我们学习socket就是为了c/s架构的开发 学习socket一定要先学习互联网协议: 1.如何基于socket编程,来开发一款自己的C/S架构软件 2..C/S架构的软件(软件属于应用层)是基于网络进行通信的 3.网络的核心即一堆协议,

Socket聊天程序——客户端

写在前面: 上周末抽点时间把自己写的一个简单Socket聊天程序的初始设计和服务端细化设计记录了一下,周二终于等来毕业前考的软考证书,然后接下来就是在加班的日子度过了,今天正好周五,打算把客户端的详细设计和Common模块记录一下,因为这个周末开始就要去忙其他东西了. 设计: 客户端设计主要分成两个部分,分别是socket通讯模块设计和UI相关设计. 客户端socket通讯设计: 这里的设计其实跟服务端的设计差不多,不同的是服务端是接收心跳包,而客户端是发送心跳包,由于客户端只与一个服务端进行通

Python 使用Socket实现FTP功能

FtpServer #!/usr/bin/env python import SocketServer class MyServer(SocketServer.BaseRequestHandler):   def setup(self):      pass   def handle(self):      path='/tmp'      while True:          print self.request,self.client_address,self.server