如何做基於python的網路聊天室

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

② 聊天室是什麼 如何創建聊天室求大神幫忙指點下！！

一，在網路內搜索到的資料：

聊天室 （網路虛擬談話空間）

聊天室(chat room)是一個網上空間，為了保證談話的焦點，聊天室通常有一定的談話主題。任何一個聯入Internet、使用正確的聊天軟體，並且渴望談論的人都可以享受其樂趣。聊天室會話是自然會話在信息時代的延伸。合作原則解釋不了聊天室會話的諸多問題,沒有其適用性。聊天室有語音聊天室和視頻聊天室等分類。

網路聊天室通常直稱聊天室，是一種人們可以在線交談的網路論壇，在同一聊天室的人們通過廣播消息進行實時交談。
聊天室可以建立在即時通訊軟體（如MSN Messenger、QQ、Anychat）、P2P軟體、萬維網（如 Halapo,Meebo ) 等基礎上，萬維網方式更為普通和種類繁多，交談的手段不局限於文本，更包括語音、視頻。通常聊天室是按照房間或頻道為單位的，在同一房間或頻道的網人可以實時地廣播和閱讀公開消息。一般情況下，與其它網路論壇、即時通訊不同的是，聊天室不保存聊天記錄。
聊天室基本原理是，拋開CGI和WWW伺服器，根據HTML規范，接收到瀏覽器的請求以後，模仿WWW伺服器的響應，將聊天內容發回瀏覽器。在瀏覽器看來就像瀏覽一個巨大的頁面一樣始終處於頁面聯接狀態， 這就是一個專門的聊天伺服器，一個簡化了的WWW伺服器。
聊天者只需在想要進入的聊天室注冊自己的用戶名、密碼後，登錄進入某一個聊天室（大多數網站都有很多的聊天室）。在聊天室里，一般都會列出正在聊天人的名單，並且對新人進入進行提示。聊天者在一個對話框里留言，寫下的話會立刻被其他人看到，並收到回應。用戶也可以在聊天室內看別人對話，而自己不說話，這種行為一般被稱作「潛水」。
由於聊天室里的話語都是立即可見的，所以需要一個管理員來維持秩序。管理員會制定一些基本的規章制度讓大家來遵守。比如，當聊天者剛進入聊天室的時候，應該向大家介紹自己；當你向某人說話時，應該明確指明說話對象；舉報一些惡意說廢話者，他們反復說同樣的話，使對方經常滾屏。聊天室的話題涉及方方面面，如，經典電影、愛爾蘭歷史、警察暴行、精神食糧。有的網站，如Yahoo，提供分專題的聊天室。有的網站，如MSN，可以指導用戶創建自己的話題聊天室。

二，在其他網站搜索到的資料：

即網路聊天室，通常直呼聊天室,是一種多人可以同時在線交談的的網路論壇，在同一聊天室的人們通過廣播消息、文字、語音、視頻等進行實時交談。

聊天室可以建立在即時通訊軟體（如MSN Messenger、QQ）、P2P軟體、萬維網等基礎上，萬維網方式更為普通和種類繁多，交談的手段不局限於文本，更包括語音、視頻。通常聊天室是按照房間或頻道為單位的，由一個或者多個管理員管理，在同一房間或頻道的網人可以實時地廣播和閱讀公開消息。一般情況下，與其它網路論壇、即時通訊不同的是，聊天室不保存聊天記錄。

③ 怎麼建立一個網路聊天室

自己建設個吧只要有自己的空間 和域名找到源程序 就行了這個是仿照 QQ群的 網頁源碼http://down.cnzz.cn/ShowPic/48735.aspx

④ 如何用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 socket編程相關，一步一步來。比如先做一個無界面一問一答的雙人聊天室，然後做實時問答版的，在做多人實時聊天室版，再加上界面不就ok了，之後人多了系統扛不住了，在考慮如何提高系統性能。飯是一口一口吃，路是一步一步走。

⑥ python怎麼連接websocket

不知道是不是要server和client。

給一個例子，基於py27的聊天室，有server，同時client是用python模擬的，如果你想用js寫，可以自己寫一個

使用前先：

pip install websocket-client

然後運行server、client就可以了

websocket_server.py（服務端）

#-*-encoding:utf-8-*-

importsys
sys.path.append("..")
fromsocketimport*
importjson,time,threading

reload(sys)
sys.setdefaultencoding("utf8")

config={
'HOST':'127.0.0.1',
'PORT':10010,
'LISTEN_CLIENT':50,
'KEY':'',
'SIZE':2048,
'TIME_OUT':10000,
'HEART_TIME':5,
'MAGIC_STRING':'258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
'HANDSHAKE_STRING':"HTTP/1.1101SwitchingProtocols
"
"Upgrade:websocket
"
"Connection:Upgrade
"
"Sec-WebSocket-Accept:{1}
"
"WebSocket-Location:ws://{2}/chat
"
"WebSocket-Protocol:chat

"
}


classServer():
"""
服務端基類
"""
def__init__(self):
self.sock=socket(AF_INET,SOCK_STREAM)
self.sock.bind((config['HOST'],config['PORT']))#監聽埠
self.sock.listen(config['LISTEN_CLIENT'])#監聽客戶端數量

#所有監聽的客戶端
self.clients={}
self.thrs={}
self.users={}
self.stops=[]
self.onlineusers=[]

#監聽客戶端連接
deflisten_client(self):
while1:
#循環監聽
tcpClientSock,addr=self.sock.accept()
address=addr[0]+':'+str(addr[1])#ip:port
#握手
topInfo=tcpClientSock.recv(1024)
headers={}
ifnottopInfo:
self.onlineusers.remove(self.users[address])
tcpClientSock.close()
continue

header,data=topInfo.split('

',1)

try:
getInfo=header.split('
')[0].split('')[1].split('/')[1:]
ifgetInfo[0]=='name':
self.users[address]=str(getInfo[1])
self.onlineusers.append(self.users[address])
else:
self.users[address]=u'匿名用戶'

except:
self.users[address]=u'匿名用戶'

print"thisisself.users[address]:"
printself.users[address]

forlineinheader.split('
')[1:]:
key,val=line.split(':',1)
headers[key]=val

if'Sec-WebSocket-Key'notinheaders:
self.onlineusers.remove(self.users[address])
tcpClientSock.close()
continue


importhashlib,base64
sec_key=headers['Sec-WebSocket-Key']
res_key=base64.b64encode(hashlib.sha1(sec_key+config['MAGIC_STRING']).digest())
str_handshake=config['HANDSHAKE_STRING'].replace('{1}',res_key).replace('{2}',config['HOST']+':'+str(config['PORT']))

tcpClientSock.send(str_handshake)

#握手成功分配線程進行監聽
print(address+u'進來了')

self.clients[address]=tcpClientSock
self.thrs[address]=threading.Thread(target=self.readMsg,args=[address])
self.thrs[address].start()
time.sleep(0.5)

defreadMsg(self,address):
ifaddressnotinself.clients:
returnFalse
client=self.clients[address]

importselect
time_out=0
while1:
ifaddressinself.stops:
self.close_client(address)
print(address+u'已經離開了系統！')
break

#檢測超時
iftime_out>=config['TIME_OUT']:
self.close_client(address)
break

time_out+=5

infds,outfds,errfds=select.select([client,],[],[],5)
iflen(infds)==0:
continue

time_out=0
try:
info=client.recv(1024)
except:
self.close_client(address)
break

ifnotinfo:
continue

ifinfo=='quit':
self.close_client(address)
break
code_len=ord(info[1])&127
ifcode_len==126:
masks=info[4:8]
data=info[8:]
elifcode_len==127:
masks=info[10:14]
data=info[14:]
else:
masks=info[2:6]
data=info[6:]
i=0
raw_str=""
fordindata:
#print(masks,masks[i%4])
raw_str+=chr(ord(d)^ord(masks[i%4]))
i+=1

print"thisisraw_stryesthisisraw_str"
printrepr(raw_str)

#獲取到輸入的數據向所有的客戶端發送
#開啟線程記錄

ifraw_str:
t1=threading.Thread(target=self.send_data,args=[raw_str,address])
t1.start()

time.sleep(0.5)defonlineuser(self):
fromurllibimportunquote
username=[]
foriinself.onlineusers:
i=unquote(i).encode('utf8')
username.append(str(i))
returnusername


defsend_data(self,data,address):
importstruct
fromurllibimportunquote
try:
username=unquote(self.users[address])
except:
username=u'匿名用戶'

'''封裝數據'''
reply={}
ifdata:
data=data.split("}")[0]+"}"
data=json.loads(data);
'''如果有人加入的話，消息封裝如下：'''
ifdata["type"]=="JOIN":
reply["type"]="JOIN"
reply["data"]=data["username"]
reply["user_from"]=data["username"]
reply["user"]=self.onlineuser()
'''如果有人發消息，判斷是發送給全部還是個人'''

elifdata["type"]=="POST":
reply["type"]="POST"
ifdata["sendto"]=="ALL":
reply["data"]="["+data['username']+"]:"+data["content"]
else:
reply["data"]=u"["+data['username']+"]悄悄對["+data["sendto"]+"]說:"+data["content"]
reply["user_from"]=data["username"]
reply["user"]=self.onlineuser()
reply["sendto"]=data["sendto"]

'''如果是退出的消息，封裝如下'''
elifdata["type"]=="QUIT":
self.close_client(address)
reply["type"]="QUIT"
reply["user_from"]=data["username"]
reply["user"]=self.onlineuser()

reply=json.mps(reply)
else:
returnFalse

token="x81"
length=len(reply)
iflength<126:
token+=struct.pack("B",length)
eliflength<=0xFFFF:
token+=struct.pack("!BH",126,length)
else:
token+=struct.pack("!BQ",127,length)

#struct為Python中處理二進制數的模塊，二進制流為C，或網路流的形式。
alldata='%s%s'%(token,reply)
try:
#判斷消息如果是私聊的，找出sendto和sendfrom進行單發
ifdata["type"]=="POST":
ifdata["sendto"]!="ALL":

forkey,valinself.users.iteritems():
printkey,unquote(val)
val=unquote(val)
ifval==data["sendto"]orval==data["username"]:
printkey
self.clients[key].send(alldata)
else:
forkey,valinself.clients.iteritems():
client=val
try:
client.send(alldata)
except:
self.close_client(key)
else:
forkey,valinself.clients.iteritems():
client=val
try:
client.send(alldata)
except:
self.close_client(key)
except:
pass


defclose_client(self,address):
try:
client=self.clients.pop(address)
self.stops.append(address)
self.onlineusers.remove(self.users[address])
client.close()
delself.users[address]
except:
pass

print(address+u'已經退出')if__name__=='__main__':
s=Server()
s.listen_client()websocket_client.py(客戶端)
#-*-encoding:utf-8-*-

importsys
sys.path.append("..")
fromsocketimport*
importjson,time,threading
fromwebsocketimportcreate_connection
reload(sys)
sys.setdefaultencoding("utf8")

#config={
#'HOST':'127.0.0.1',
#'PORT':10010
#}
#pipinstallwebsocket-client

classClient():
def__init__(self):
#調用create_connection方法，建立一個websocket鏈接
self.ws=create_connection("ws://127.0.0.1:10010/name/johanna")
#建一個線程，監聽伺服器發送給客戶端的數據
self.trecv=threading.Thread(target=self.recv)
self.trecv.start()
#建立鏈接後，給聊天室大家群發一個加入消息
msg={
"type":"JOIN",
"username":"johanna",
"content":"HelloEvery,anewguycomein"
}
msg=json.mps(msg)
self.ws.send(msg)

#發送方法，聊天輸入語句時調用，此處默認為群聊ALL
defsend(self,content):
msg={
"type":"POST",
"username":"johanna",
"sendto":"ALL",
"content":content

}
msg=json.mps(msg)
self.ws.send(msg)

#接收服務端發送給客戶的數據，只要ws處於連接狀態，則一直接收數據
defrecv(self):
try:
whileself.ws.connected:
result=self.ws.recv()
print"receivedmsg:"+str(result)
exceptException,e:
pass


#關閉時，發送QUIT方法，並告訴大家，我要走了
defclose(self):
msg={
"type":"QUIT",
"username":"johanna",
"content":"byebye,everyone"
}
msg=json.mps(msg)
self.ws.send(msg)


if__name__=='__main__':

c=Client()
#當輸入聊天語句非exit時，則持續聊天狀態，如果exit，則關閉鏈接
whileTrue:
content=raw_input("pleaseinput(inputexittoexit):")
ifcontent=="exit":
c.close()
break
else:
c.send(content)
time.sleep(1)

⑦ python區域網聊天室怎麼編寫表情代碼，用什麼方式打開，需要什麼插件嗎

要VB我給你代碼，Python不會

⑧ 如何用Python編寫一個聊天室

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

fromasyncoreimportdispatcher
fromasynchatimportasync_chat
importsocket,asyncore

PORT=6666#埠

classEndSession(Exception):
"""
自定義會話結束時的異常
"""
pass

classCommandHandler:
"""
命令處理類
"""

defunknown(self,session,cmd):
'響應未知命令'
session.push('Unknowncommand:%sn'%cmd)

defhandle(self,session,line):
'命令處理'
ifnotline.strip():
return
parts=line.split('',1)
cmd=parts[0]
try:
line=parts[1].strip()
exceptIndexError:
line=''
meth=getattr(self,'do_'+cmd,None)
try:
meth(session,line)
exceptTypeError:
self.unknown(session,cmd)

classRoom(CommandHandler):
"""
包含多個用戶的環境，負責基本的命令處理和廣播
"""

def__init__(self,server):
self.server=server
self.sessions=[]

defadd(self,session):
'一個用戶進入房間'
self.sessions.append(session)

defremove(self,session):
'一個用戶離開房間'
self.sessions.remove(session)

defbroadcast(self,line):
'向所有的用戶發送指定消息'
forsessioninself.sessions:
session.push(line)

defdo_logout(self,session,line):
'退出房間'
raiseEndSession

classLoginRoom(Room):
"""
剛登錄的用戶的房間
"""

defadd(self,session):
'用戶連接成功的回應'
Room.add(self,session)
session.push('ConnectSuccess')

defdo_login(self,session,line):
'登錄命令處理'
name=line.strip()
ifnotname:
session.push('UserNameEmpty')
elifnameinself.server.users:
session.push('UserNameExist')
else:
session.name=name
session.enter(self.server.main_room)

classChatRoom(Room):
"""
聊天用的房間
"""

defadd(self,session):
'廣播新用戶進入'
session.push('LoginSuccess')
self.broadcast(session.name+'hasenteredtheroom.n')
self.server.users[session.name]=session
Room.add(self,session)

defremove(self,session):
'廣播用戶離開'
Room.remove(self,session)
self.broadcast(session.name+'haslefttheroom.n')

defdo_say(self,session,line):
'客戶端發送消息'
self.broadcast(session.name+':'+line+'n')

defdo_look(self,session,line):
'查看在線用戶'
session.push('OnlineUsers:n')
forotherinself.sessions:
session.push(other.name+'n')

classLogoutRoom(Room):
"""
用戶退出時的房間
"""

defadd(self,session):
'從伺服器中移除'
try:
delself.server.users[session.name]
exceptKeyError:
pass

classChatSession(async_chat):
"""
負責和單用戶通信
"""

def__init__(self,server,sock):
async_chat.__init__(self,sock)
self.server=server
self.set_terminator('n')
self.data=[]
self.name=None
self.enter(LoginRoom(server))

defenter(self,room):
'從當前房間移除自身，然後添加到指定房間'
try:
cur=self.room
exceptAttributeError:
pass
else:
cur.remove(self)
self.room=room
room.add(self)

defcollect_incoming_data(self,data):
'接受客戶端的數據'
self.data.append(data)

deffound_terminator(self):
'當客戶端的一條數據結束時的處理'
line=''.join(self.data)
self.data=[]
try:
self.room.handle(self,line)
exceptEndSession:
self.handle_close()

defhandle_close(self):
async_chat.handle_close(self)
self.enter(LogoutRoom(self.server))

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

defhandle_accept(self):
conn,addr=self.accept()
ChatSession(self,conn)

if__name__=='__main__':
s=ChatServer(PORT)
try:
asyncore.loop()
exceptKeyboardInterrupt:
print

⑨ 用python製作聊天室伺服器源代碼寫好了不知如何讓運行

Python是一種即譯式的，互動的，...或新建一個界面讓數據在互不兼容的系統中流動。...Zope是一個開放源代碼的Web應用伺服器，採用Python語言開發，使用它您可

⑩ 我想要做一個網路聊天室，不知道怎麼開始做

1.首先你要進一步明確你要做什麼？
網路聊天室，是網頁聊天？電腦軟體聊天？移動app聊天？
2.然後你要明白你可以做到什麼？
你會編程嗎？java，php，C++，C#，你會？那就可以開始設計程序的思路了。你不會？你就可以網上找源碼學習自己部署源碼項目了。
3.進一步你要知道你怎麼可以做好。
服務端環境怎麼搭建，伺服器用什麼系統，源碼是不是有bug和漏洞，搭建好了客戶端怎麼連接，運行起來了怎麼保證穩定性。
4.什麼？你有錢？而且很多。
差不多幾十萬可以直接讓別人幫你搞定，還有餘錢招人運維。豬八戒或者直接線下聯系軟體公司就好。
5.什麼？你沒錢？
那麼老老實實參考上述三條，讓你或者你的團隊自學搞定。不會編程也得會部署已經有的源碼，不會伺服器就趕緊了解就學，網上的聊天程序一大堆，安裝說明文檔，和各種知識也很多，基本上看教程照著來就行，如果你這都搞不定？
【那就沒辦法了】