python模拟聊天

㈠ 如何用python编写一个聊天室

一、课程介绍

1.简介

本次项目课是实现简单聊天室程序的服务器端和客户端。

2.知识点

服务器端涉及到asyncore、asynchat和socket这几个模块，客户端用到了telnetlib、wx、time和thread这几个模块。

3.所需环境

本次课中编写客户端需要用到wxPython，它是一个GUI工具包，请先使用下面的命令安装：

$ sudo apt-get install python-wxtools

密码为shiyanlou

4.项目效果截图

登录窗口

二、项目实战（服务器端）

1.服务器类

首先需要一个聊天服务器，这里继承asyncore的dispatcher类来实现，代码如下

class ChatServer(dispatcher):
"""
聊天服务器
"""

def __init__(self, port):
dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(('', port))
self.listen(5)
self.users = {}
self.main_room = ChatRoom(self)

def handle_accept(self):
conn, addr = self.accept()
ChatSession(self, conn)

2.会话类

有了服务器类还需要能维护每个用户的连接会话，这里继承asynchat的async_chat类来实现，代码如下：

class ChatSession(async_chat):
"""
负责和单用户通信
"""

def __init__(self, server, sock):
async_chat.__init__(self, sock)
self.server = server
self.set_terminator(' ')
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))

3.命令解释器

现在就需要一个命令解释器能够解释用户的命令，例如登录、查询在线用户和发消息等，代码如下：

class CommandHandler:
"""
命令处理类
"""

def unknown(self, session, cmd):
'响应未知命令'
session.push('Unknown command: %s ' % 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)

4.房间

接下来就需要实现聊天室的房间了，这里我们定义了三种房间，分别是用户刚登录时的房间、聊天的房间和退出登录的房间，这三种房间都有一个公共的父类，代码如下：

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)
session.push('Connect Success')

def do_login(self, session, line):
'登录命令处理'
name = line.strip()
if not name:
session.push('UserName Empty')
elif name in self.server.users:
session.push('UserName Exist')
else:
session.name = name
session.enter(self.server.main_room)

class ChatRoom(Room):
"""
聊天用的房间
"""

def add(self, session):
'广播新用户进入'
session.push('Login Success')
self.broadcast(session.name + ' has entered the room. ')
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. ')

def do_say(self, session, line):
'客户端发送消息'
self.broadcast(session.name + ': ' + line + ' ')

def do_look(self, session, line):
'查看在线用户'
session.push('Online Users: ')
for other in self.sessions:
session.push(other.name + ' ')

class LogoutRoom(Room):
"""
用户退出时的房间
"""

def add(self, session):
'从服务器中移除'
try:
del self.server.users[session.name]
except KeyError:
pass

5.服务器端完整代码

#!/usr/bin/python
# encoding: utf-8

from asyncore import dispatcher
from asynchat import async_chat
import socket, asyncore

PORT = 6666 #端口

class EndSession(Exception):
"""
自定义会话结束时的异常
"""
pass

class CommandHandler:
"""
命令处理类
"""

def unknown(self, session, cmd):
'响应未知命令'
session.push('Unknown command: %s ' % 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)
session.push('Connect Success')

def do_login(self, session, line):
'登录命令处理'
name = line.strip()
if not name:
session.push('UserName Empty')
elif name in self.server.users:
session.push('UserName Exist')
else:
session.name = name
session.enter(self.server.main_room)

class ChatRoom(Room):
"""
聊天用的房间
"""

def add(self, session):
'广播新用户进入'
session.push('Login Success')
self.broadcast(session.name + ' has entered the room. ')
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. ')

def do_say(self, session, line):
'客户端发送消息'
self.broadcast(session.name + ': ' + line + ' ')

def do_look(self, session, line):
'查看在线用户'
session.push('Online Users: ')
for other in self.sessions:
session.push(other.name + ' ')

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(' ')
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):
dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(('', port))
self.listen(5)
self.users = {}
self.main_room = ChatRoom(self)

def handle_accept(self):
conn, addr = self.accept()
ChatSession(self, conn)

if __name__ == '__main__':
s = ChatServer(PORT)
try:
asyncore.loop()
except KeyboardInterrupt:
print

三、项目实战（客户端）

完成了服务器端后，就需要实现客户端了，这里客户端连接服务器使用了telnetlib模块。

1.登录窗口

这里的图形界面包选择了wxPython，前面有安装说明，登录窗口通过继承wx.Frame类来实现，代码如下：

class LoginFrame(wx.Frame):
"""
登录窗口

㈡ 如何用Python编写一个聊天室

python聊天室(python2.7版本)：

暂时先给出两种版本的,tcp+udp

都是分别运行server.py和client.py，就可以进行通讯了。

别外还有websocket版本，这个是有web界面的和基本web服务的，如果需要的话，我会把基本的代码贴一版上来。

TCP版本：

socket-tcp-server.py（服务端）:

#-*-encoding:utf-8-*-
#socket.getaddrinfo(host,port,family=0,socktype=0,proto=0,flags=0)
#根据给定的参数host/port，相应的转换成一个包含用于创建socket对象的五元组，
#参数host为域名，以字符串形式给出代表一个IPV4/IPV6地址或者None.
#参数port如果字符串形式就代表一个服务名，比如“http”"ftp""email"等，或者为数字，或者为None
#参数family为地主族，可以为AF_INET，AF_INET6，AF_UNIX.
#参数socktype可以为SOCK_STREAM(TCP)或者SOCK_DGRAM(UDP)
#参数proto通常为0可以直接忽略
#参数flags为AI_*的组合，比如AI_NUMERICHOST，它会影响函数的返回值
#附注：给参数host,port传递None时建立在C基础，通过传递NULL。
#该函数返回一个五元组(family,socktype,proto,canonname,sockaddr)，同时第五个参数sockaddr也是一个二元组(address,port)
#更多的方法及链接请访问
#Echoserverprogram
fromsocketimport*
importsys
importthreading
fromtimeimportctime
fromtimeimportlocaltime
importtraceback
importtime
importsubprocess
reload(sys)
sys.setdefaultencoding("utf8")


HOST='127.0.0.1'
PORT=8555#设置侦听端口
BUFSIZ=1024

classTcpServer():
def__init__(self):
self.ADDR=(HOST,PORT)
try:
self.sock=socket(AF_INET,SOCK_STREAM)
print'%disopen'%PORT

self.sock.bind(self.ADDR)
self.sock.listen(5)
#设置退出条件
self.STOP_CHAT=False

#所有监听的客户端
self.clients={}
self.thrs={}
self.stops=[]

exceptException,e:
print"%disdown"%PORT
returnFalse

defIsOpen(ip,port):

s=socket(AF_INET,SOCK_STREAM)
try:
s.connect((ip,int(port)))
#s.shutdown(2)
#利用shutdown()函数使socket双向数据传输变为单向数据传输。shutdown()需要一个单独的参数，
#该参数表示s了如何关闭socket。具体为：0表示禁止将来读；1表示禁止将来写；2表示禁止将来读和写。
print'%disopen'%port
returnTrue
except:
print'%disdown'%port
returnFalse

deflisten_client(self):
whilenotself.STOP_CHAT:
print(u'等待接入，侦听端口:%d'%(PORT))
self.tcpClientSock,self.addr=self.sock.accept()
print(u'接受连接，客户端地址：',self.addr)
address=self.addr
#将建立的clientsocket链接放到列表self.clients中
self.clients[address]=self.tcpClientSock
#分别将每个建立的链接放入进程中，接收且分发消息
self.thrs[address]=threading.Thread(target=self.readmsg,args=[address])
self.thrs[address].start()
time.sleep(0.5)defreadmsg(self,address):
#如果地址不存在，则返回False
ifaddressnotinself.clients:
returnFalse
#得到发送消息的clientsocket
client=self.clients[address]
whileTrue:
try:
#获取到消息内容data
data=client.recv(BUFSIZ)
except:
print(e)
self.close_client(address)
break
ifnotdata:
break
#python3使用bytes，所以要进行编码
#s='%s发送给我的信息是:[%s]%s'%(addr[0],ctime(),data.decode('utf8'))
#对日期进行一下格式化
ISOTIMEFORMAT='%Y-%m-%d%X'
stime=time.strftime(ISOTIMEFORMAT,localtime())
s=u'%s发送给我的信息是:%s'%(str(address),data.decode('utf8'))
#将获得的消息分发给链接中的clientsocket
forkinself.clients:
self.clients[k].send(s.encode('utf8'))
self.clients[k].sendall('sendall:'+s.encode('utf8'))
printstr(k)
print([stime],':',data.decode('utf8'))
#如果输入quit(忽略大小写),则程序退出
STOP_CHAT=(data.decode('utf8').upper()=="QUIT")
ifSTOP_CHAT:
print"quit"
self.close_client(address)
print"alreadyquit"
break

defclose_client(self,address):
try:
client=self.clients.pop(address)
self.stops.append(address)
client.close()
forkinself.clients:
self.clients[k].send(str(address)+u"已经离开了")
except:
pass
print(str(address)+u'已经退出')


if__name__=='__main__':
tserver=TcpServer()
tserver.listen_client()

——————————华丽的分割线——————————

socket-tcp-client.py（客户端）：

#-*-encoding:utf-8-*-
fromsocketimport*
importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding("utf8")


#测试，连接本机
HOST='127.0.0.1'
#设置侦听端口
PORT=8555
BUFSIZ=1024

classTcpClient:

ADDR=(HOST,PORT)
def__init__(self):
self.HOST=HOST
self.PORT=PORT
self.BUFSIZ=BUFSIZ
#创建socket连接
self.client=socket(AF_INET,SOCK_STREAM)
self.client.connect(self.ADDR)
#起一个线程，监听接收的信息
self.trecv=threading.Thread(target=self.recvmsg)
self.trecv.start()

defsendmsg(self):
#循环发送聊天消息，如果socket连接存在则一直循环，发送quit时关闭链接
whileself.client.connect_ex(self.ADDR):
data=raw_input('>:')
ifnotdata:
break
self.client.send(data.encode('utf8'))
print(u'发送信息到%s：%s'%(self.HOST,data))
ifdata.upper()=="QUIT":
self.client.close()
printu"已关闭"
break
defrecvmsg(self):
#接收消息，如果链接一直存在，则持续监听接收消息
try:
whileself.client.connect_ex(self.ADDR):
data=self.client.recv(self.BUFSIZ)
print(u'从%s收到信息：%s'%(self.HOST,data.decode('utf8')))
exceptException,e:
printstr(e)

if__name__=='__main__':
client=TcpClient()
client.sendmsg()

UDP版本：

socket-udp-server.py

#-*-coding:utf8-*-

importsys
importtime
importtraceback
importthreading
reload(sys)
sys.setdefaultencoding('utf-8')

importsocket
importtraceback

HOST="127.0.0.1"
PORT=9555
CHECK_PERIOD=20
CHECK_TIMEOUT=15

classUdpServer(object):
def__init__(self):
self.clients=[]
self.beats={}
self.ADDR=(HOST,PORT)
try:
self.sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.sock.bind(self.ADDR)#绑定同一个域名下的所有机器
self.beattrs=threading.Thread(target=self.checkheartbeat)
self.beattrs.start()
exceptException,e:
traceback.print_exc()
returnFalse

deflisten_client(self):
whileTrue:
time.sleep(0.5)
print"hohohohohoo"
try:
recvData,address=self.sock.recvfrom(2048)
ifnotrecvData:
self.close_client(address)
break
ifaddressinself.clients:
senddata=u"%s发送给我的信息是:%s"%(str(address),recvData.decode('utf8'))
ifrecvData.upper()=="QUIT":
self.close_client(address)
ifrecvData=="HEARTBEAT":
self.heartbeat(address)
continue
else:
self.clients.append(address)
senddata=u"%s发送给我的信息是:%s"%(str(address),u'进入了聊天室')
forcinself.clients:
try:
self.sock.sendto(senddata,c)
exceptException,e:
printstr(e)
self.close_client(c)
exceptException,e:
#traceback.print_exc()
printstr(e)
pass

defheartbeat(self,address):
self.beats[address]=time.time()

defcheckheartbeat(self):

whileTrue:
print"checkheartbeat"
printself.beats
try:
forcinself.clients:
printtime.time()
printself.beats[c]
ifself.beats[c]+CHECK_TIMEOUT<time.time():
printu"%s心跳超时，连接已经断开"%str(c)
self.close_client(c)
else:
printu"checkp%s,没有断开"%str(c)
exceptException,e:
traceback.print_exc()
printstr(e)
pass
time.sleep(CHECK_PERIOD)

defclose_client(self,address):
try:
ifaddressinself.clients:
self.clients.remove(address)
ifself.beats.has_key(address):
delself.beats[address]
printself.clients
forcinself.clients:
self.sock.sendto(u'%s已经离开了'%str(address),c)
print(str(address)+u'已经退出')
exceptException,e:
printstr(e)
raise

if__name__=="__main__":
udpServer=UdpServer()
udpServer.listen_client()

——————————华丽的分割线——————————
socket-udp-client.py:
#-*-coding:utf8-*-

importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding('utf-8')

importsocket

HOST="127.0.0.1"
PORT=9555
#BEAT_PORT=43278
BEAT_PERIOD=5


classUdpClient(object):
def__init__(self):
self.clientsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.HOST=HOST
self.ADDR=(HOST,PORT)
self.clientsock.sendto(u'请求建立链接',self.ADDR)
self.recvtrs=threading.Thread(target=self.recvmsg)
self.recvtrs.start()
self.hearttrs=threading.Thread(target=self.heartbeat)
self.hearttrs.start()

defsendmsg(self):
whileTrue:
data=raw_input(">:")
ifnotdata:
break
self.clientsock.sendto(data.encode('utf-8'),self.ADDR)
ifdata.upper()=='QUIT':
self.clientsock.close()
break

defheartbeat(self):
whileTrue:
self.clientsock.sendto('HEARTBEAT',self.ADDR)
time.sleep(BEAT_PERIOD)

defrecvmsg(self):
whileTrue:
recvData,addr=self.clientsock.recvfrom(1024)
ifnotrecvData:
break
print(u'从%s收到信息：%s'%(self.HOST,recvData.decode('utf8')))if__name__=="__main__":
udpClient=UdpClient()
udpClient.sendmsg()

㈢ 利用Python语言，设计一个网络聊天程序，实现网络通信或者文件传输

这个是很有意思，也简单的话题 。你可以使用twisted, 或者是socket, 实现。 如果想优美些可以用stackless，也可以用greenlet。

最简单的办法是使用内置的httpserver，通过多线程socketserver，和simplehttpserver实现简单的交互。

㈣ 怎么利用Python做一个即时通信软件呢，类似于QQ，能实现基本的聊天和文件传输功能

这个基本的聊天就是最基本的socket操作，python界面方面比较弱势，如果不用第三方库的话。

㈤ python可以做哪些有趣的事情

1. Python3 实现色情图片识别

2. Python3 图片隐写术

3. 200 行 Python 代码实现 2048

4. Python实现3D建模工具

5. 使用 Python 定制词云

6. Python3 智能裁切图片

7.微信变为聊天机器人

8. 使用 Python 解数学方程

9. 使用 Python 创建照片马赛克

10. Python 基于共现提取《釜山行》人物关系

11. Python 气象数据分析：《Python 数据分析实战》

12. NBA常规赛结果预测：利用Python进行比赛数据分析

13. Python 的循环语句和隐含波动率的计算

14. K-近邻算法实现手写数字识别系统

15. 数独游戏的 Python 实现与破解

16. 基于 Flask 与 MySQL 实现番剧推荐系

17. Python 实现英文新闻摘要自动提取

18. Python 解决哲学家就餐问题

19. Ebay 在线拍卖数据分析

20. 神经网络实现人脸识别任务

21. 使用 Python 解数学方程

22. Python3 实现火车票查询工具

23. Python 实现端口扫描器

24. Python3 实现可控制肉鸡的反向Shell

25. Python 实现 FTP 弱口令扫描器

26. 基于PyQt5 实现地图中定位相片拍摄位置

27. Python实现网站模拟登陆

28.Python实现简易局域网视频聊天工具

29. 基于 TCP 的 python 聊天程序

30. Python3基于Scapy实现DDos

31. 高德API + Python 解决租房问题

32. 基于 Flask 与 RethinkDB 实现TODO List

㈥ 关于python编程，写一个聊天室中间出现的问题

知道无大神，屌丝一大群

㈦ 花了2万多买的Python70个项目，现在分享给大家，练手进厂靠它了

前言：

不管学习哪门语言都希望能做出实际的东西来，这个实际的东西当然就是项目啦，不用多说大家都知道学编程语言一定要做项目才行。

这里整理了70个Python实战项目列表，都有完整且详细的教程，你可以从中选择自己想做的项目进行参考学习练手，你也可以从中寻找灵感去做自己的项目。

1、【Python 图片转字符画】

2、【200行Python代码实现2048】

3、【Python3 实现火车票查询工具】

4、【高德API+Python解决租房问题 】

5、【Python3 色情图片识别】

6、【Python 破解验证码】

7、【Python实现简单的Web服务器】

8、【pygame开发打飞机 游戏 】

9、【Django 搭建简易博客】

10、【Python基于共现提取《釜山行》人物关系】

11、【基于scrapy爬虫的天气数据采集(python)】

12、【Flask 开发轻博客】

13、【Python3 图片隐写术】

14、【Python 实现简易 Shell】

15、【使用 Python 解数学方程】

16、【PyQt 实现简易浏览器】

17、【神经网络实现手写字符识别系统 】

18、【Python 实现简单画板】

19、【Python实现3D建模工具】

20、【NBA常规赛结果预测——利用Python进行比赛数据分析】

21、【神经网络实现人脸识别任务】

22、【Python文本解析器】

23、【Python3 & OpenCV 视频转字符动画】

24、【Python3 实现淘女郎照片爬虫 】

25、【Python3实现简单的FTP认证服务器】

26、【基于 Flask 与 MySQL 实现番剧推荐系统】

27、【Python 实现端口扫描器】

28、【使用 Python 3 编写系列实用脚本】

29、【Python 实现康威生命 游戏 】

30、【川普撞脸希拉里(基于 OpenCV 的面部特征交换) 】

31、【Python 3 实现 Markdown 解析器】

32、【Python 气象数据分析 -- 《Python 数据分析实战》】

33、【Python实现键值数据库】

34、【k-近邻算法实现手写数字识别系统】

35、【ebay在线拍卖数据分析】

36、【Python 实现英文新闻摘要自动提取 】

37、【Python实现简易局域网视频聊天工具】

38、【基于 Flask 及爬虫实现微信 娱乐 机器人】

39、【Python实现Python解释器】

40、【Python3基于Scapy实现DDos】

41、【Python 实现密码强度检测器】

42、【使用 Python 实现深度神经网络】

43、【Python实现从excel读取数据并绘制成精美图像】

44、【人机对战初体验:Python基于Pygame实现四子棋 游戏 】

45、【Python3 实现可控制肉鸡的反向Shell】

46、【Python打造漏洞扫描器 】

47、【Python应用马尔可夫链算法实现随机文本生成】

48、【数独 游戏 的Python实现与破解】

49、【使用Python定制词云】

50、【Python开发简单计算器】

51、【Python 实现 FTP 弱口令扫描器】

52、【Python实现Huffman编码解压缩文件】

53、【Python实现Zip文件的暴力破解 】

54、【Python3 智能裁切图片】

55、【Python实现网站模拟登陆】

56、【给Python3爬虫做一个界面.妹子图网实战】

57、【Python 3 实现图片转彩色字符】

58、【自联想器的 Python 实现】

59、【Python 实现简单滤镜】

60、【Flask 实现简单聊天室】

61、【基于PyQt5 实现地图中定位相片拍摄位置】

62、【Python实现模板引擎】

63、【Python实现遗传算法求解n-queens问题】

64、【Python3 实现命令行动态进度条】

65、【Python 获取挂号信息并邮件通知】

66、【Python实现java web项目远端自动化更新部署】

67、【使用 Python3 编写 Github 自动周报生成器】

68、【使用 Python 生成分形图片】

69、【Python 实现 Redis 异步客户端】

70、【Python 实现中文错别字高亮系统】

最后：

以上项目列表希望可以给你在Python学习中带来帮助~

获取方式：转发 私信“1”