如何用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)

#更多的方法及链接请访问

# Echo server program我爱编程网

from socket import *

import sys

import threading

from time import ctime

from time import localtime

import traceback

import time

import subprocess

reload(sys)

sys.setdefaultencoding("utf8")

HOST='127.0.0.1'

PORT=8555  #设置侦听端口

BUFSIZ=1024

class TcpServer():

def __init__(self):

self.ADDR=(HOST, PORT)

try:

self.sock=socket(AF_INET, SOCK_STREAM)

print '%d is open' % PORT

self.sock.bind(self.ADDR)

self.sock.listen(5)

#设置退出条件

self.STOP_CHAT=False

# 所有监听的客户端

self.clients = {}

self.thrs = {}

self.stops = []

except Exception,e:

print "%d is down" % PORT

return False

def IsOpen(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 '%d is open' % port

return True

except:

print '%d is down' % port

return False

def listen_client(self):

while not self.STOP_CHAT:

print(u'等待接入，侦听端口:%d' % (PORT))

self.tcpClientSock, self.addr=self.sock.accept()

print(u'接受连接，客户端地址：',self.addr)

address = self.addr

#将建立的client socket链接放到列表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)

def readmsg(self,address):

#如果地址不存在，则返回False

if address not in self.clients:

return False

#得到发送消息的client socket

client = self.clients[address]

while True:

try:

#获取到消息内容data

data=client.recv(BUFSIZ)

except:

print(e)

self.close_client(address)

break

if not data:

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

#将获得的消息分发给链接中的client socket

for k in self.clients:

self.clients[k].send(s.encode('utf8'))

self.clients[k].sendall('sendall:'+s.encode('utf8'))

print str(k)

print([stime], ':', data.decode('utf8'))

#如果输入quit(忽略大小写),则程序退出

STOP_CHAT=(data.decode('utf8').upper()=="QUIT")

if STOP_CHAT:

print "quit"

self.close_client(address)

print "already quit"

break

def close_client(self,address):

try:

client = self.clients.pop(address)

self.stops.append(address)

client.close()

for k in self.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 -*-

from socket import *

import sys

import threading

import time

reload(sys)

sys.setdefaultencoding("utf8")

#测试，连接本机

HOST='127.0.0.1'

#设置侦听端口

PORT=8555

BUFSIZ=1024

class TcpClient:

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

def sendmsg(self):

#循环发送聊天消息，如果socket连接存在则一直循环，发送quit时关闭链接

while self.client.connect_ex(self.ADDR):

data=raw_input('>:')

if not data:

break

self.client.send(data.encode('utf8'))

print(u'发送信息到%s：%s' %(self.HOST,data))

if data.upper()=="QUIT":

self.client.close()

print u"已关闭"

break

def recvmsg(self):

#接收消息，如果链接一直存在，则持续监听接收消息

try:

while self.client.connect_ex(self.ADDR):

data=self.client.recv(self.BUFSIZ)

print(u'从%s收到信息：%s' %(self.HOST,data.decode('utf8')))

except Exception,e:

print str(e)

if __name__ == '__main__':

client=TcpClient()

client.sendmsg()

UDP版本：

socket-udp-server.py

# -*- coding:utf8 -*-

import sys

import time

import traceback

import threading

reload(sys)

sys.setdefaultencoding('utf-8')

import socket

import traceback

HOST = "127.0.0.1"

PORT = 9555

CHECK_PERIOD = 20

CHECK_TIMEOUT = 15

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

except Exception,e:

traceback.print_exc()

return False

def listen_client(self):

while True:

time.sleep(0.5)

print "hohohohohoo"

try:

recvData,address = self.sock.recvfrom(2048)

if not recvData:

self.close_client(address)

break

if address in self.clients:

senddata = u"%s发送给我的信息是:%s" %(str(address),recvData.decode('utf8'))

if recvData.upper() == "QUIT":

self.close_client(address)

if recvData == "HEARTBEAT":

self.heartbeat(address)

continue

else:

self.clients.append(address)

senddata = u"%s发送给我的信息是:%s" %(str(address),u'进入了聊天室')

for c in self.clients:

try:

self.sock.sendto(senddata,c)

except Exception,e:

print str(e)

self.close_client(c)

except Exception,e:

# traceback.print_exc()

print str(e)

pass

def heartbeat(self,address):

self.beats[address] = time.time()

def checkheartbeat(self):

while True:

print "checkheartbeat"

print self.beats

try:

for c in self.clients:

print time.time()

print self.beats[c]

if self.beats[c] + CHECK_TIMEOUT 

print u"%s心跳超时，连接已经断开" %str(c)

self.close_client(c)

else:

print u"checkp%s,没有断开" %str(c)

except Exception,e:

traceback.print_exc()

print str(e)

pass

time.sleep(CHECK_PERIOD)

def close_client(self,address):

try:

if address in self.clients:

self.clients.remove(address)

if self.beats.has_key(address):

del self.beats[address]

print self.clients

for c in self.clients:

self.sock.sendto(u'%s已经离开了' % str(address),c)

print(str(address)+u'已经退出')

except Exception,e:

print str(e)

raise

if __name__ == "__main__":

udpServer = UdpServer()

udpServer.listen_client()

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

socket-udp-client.py:

# -*- coding:utf8 -*-

import sys

import threading

import time

reload(sys)

sys.setdefaultencoding('utf-8')

import socket

HOST = "127.0.0.1"

PORT = 9555

#BEAT_PORT = 43278

BEAT_PERIOD = 5

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

def sendmsg(self):

while True:

data = raw_input(">:")

if not data:

break

self.clientsock.sendto(data.encode('utf-8'),self.ADDR)

if data.upper() == 'QUIT':

self.clientsock.close()

break

def heartbeat(self):

while True:

self.clientsock.sendto('HEARTBEAT',self.ADDR)

time.sleep(BEAT_PERIOD)

def recvmsg(self):

while True:

recvData,addr = self.clientsock.recvfrom(1024)

if not recvData:

break

print(u'从%s收到信息：%s' %(self.HOST,recvData.decode('utf8')))

if __name__ == "__main__":

udpClient = UdpClient()

udpClient.sendmsg()

朋友圈很多人都想学python，有一个很重要的原因是它非常适合入门。对于

人工智能算法

的开发，python有其他编程语言所没有的独特优势，

代码量少

，开发者只需把精力集中在算法研究上面。

本文介绍一个用python开发的，自动与美女尬聊的小软件。以下都是满满的干货，是我工作之余时写的，经过不断优化，现在分享给大家。那现在就让我们抓紧时间开始吧!

准备：

编程工具IDE：pycharm

python版本： 3.6.0

首先新建一个py文件，命名为：ai_chat.py

PS： 以下五步的代码直接复制到单个py文件里面就可以直接运行。为了让读者方便写代码，我把代码都贴出来了，但是排版存在问题，我又把在pycharm的代码排版给截图出来。

第一步： 引入关键包

简单介绍一下上面几个包的作用：

pickle 包

是用来对数据序列化存文件、反序列化读取文件，是人类不可读的，但是计算机去读取时速度超快。(就是用记事本打开是乱码)。 而

json包

是一种文本序列化，是人类可读的，方便你对其进行修改(记事本打开，可以看到里面所有内容，而且都认识。)

gensim 包

是自然语言处理的其中一个python包，简单容易使用，是入门NLP算法必用的一个python包。

jieba包

是用来分词，对于算法大咖来说效果一般般，但是它的速度非常快，适合入门使用。

以上这些包，不是关键，学习的时候，可以先跳过。等理解整个程序流程后，可以一个一个包有针对性地去看文档。

第二步：静态配置

这里path指的是对话语料(训练数据)存放的位置，model_path是模型存储的路径。

这里是个人编程的习惯，我习惯把一些配置，例如：文件路径、模型存放路径、模型参数统一放在一个类中。当然，实际项目开发的时候，是用config 文件存放，不会直接写在代码里，这里为了演示方便，就写在一起，也方便运行。

第三步： 编写一个类，实现导数据、模型训练、对话预测一体化

首次运行的时候，会从静态配置中读取训练数据的路径，读取数据，进行训练，并把训练好的模型存储到指定的模型路径。后续运行，是直接导入模型，就不用再次训练了。

对于model类，我们一个一个来介绍。

initialize()

函数和

__init__()

函数 是对象初始化和实例化，其中包括基本参数的赋值、模型的导入、模型的训练、模型的保存、最后返回用户一个对象。

__train_model()

函数，对问题进行分词，使用

gesim

实现词袋模型，统计每个特征的

tf-idf

, 建立稀疏矩阵，进而建立索引。

__save_model()

函数 和

__load_model()

函数 是成对出现的，很多项目都会有这两个函数，用于保存模型和导入模型。不同的是，本项目用的是文件存储的方式，实际上线用的是数据库

get_answer()

函数使用训练好的模型，对问题进行分析，最终把预测的回答内容反馈给用户。

第四步：写三个工具类型的函数，作为读写文件。

其中，获取对话材料，可以自主修改对话内容，作为机器的训练的数据。我这里只是给了几个简单的对话语料，实际上线的项目，需要大量的语料来训练，这样对话内容才饱满。

这三个工具函数，相对比较简单一些。其中

get_data()

函数，里面的数据是我自己编的，大家可以根据自己的习惯，添加自己的对话数据，这样最终训练的模型，对话方式会更贴近自己的说话方式。

第五步： 调用模型，进行对话预测

主函数main()， 就是你整个程序运行的起点，它控制着所有步骤。

运行结果：

程序后台运行结果：

如果有疑问想获取源码(

其实代码都在上面

)，可以后台私信我，回复：python智能对话。 我把源码发你。最后，感谢大家的阅读，祝大家工作生活愉快!

1、首先在Window 上在安装 Python时，已经已经安装了默认的交互式编程客户端，提示窗口：在 python 提示符中输入以下文本信息，然后按 Enter 键查看运行效果。

2、然后，通过脚本参数调用解释器开始执行脚本，直到脚本执行完毕。当脚本执行完成后，解释器不再有效。所有 Python 文件将以 .py 为扩展名。将以下的源代码拷贝至 test.py 文件中。

3、然后，假定您的Python解释器在/usr/bin目录中，使用以下命令执行脚本。

4、然后，在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字头。Python 中的标识符是区分大小写的。

5、最后，是行和缩进，学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。