Python通訊端,python套接
1、用戶端/伺服器架構
什麼是用戶端/伺服器架構?對於不同的人來說,它意味著不同的東西,這取決於你問誰以及描述的是軟體還是硬體系統。在這兩種情況中的任何一種下,前提都很簡單:伺服器就是一系列硬體或軟體,為一個或多個用戶端(服務的使用者)提供所需的“服務”。它存在唯一目的就是等待用戶端的請求,並響應它們(提供服務),然後等待更多請求。另一方面,用戶端因特定的請求而聯絡伺服器,並發送必要的資料,然後等待伺服器的回應,最後完成請求或給出故障的原因。伺服器無限地運行下去,並不斷地處理請求;而用戶端會對服務進行一次性請求,然後接收該服務,最後結束它們之間的事務。用戶端在一段時間後可能會再次發出其他請求,但這些都被當作不同的事務。
2、用戶端/伺服器編程2.1通訊端
通訊端的起源可以追溯到20 世紀70 年代,它是加利福尼亞大學的伯克利版本UNIX(稱為BSD UNIX)的一部分。因此,有時你可能會聽過將通訊端稱為伯克利通訊端或BSD 通訊端。通訊端最初是為同一主機上的應用程式所建立,使得主機上啟動並執行一個程式(又名一個進程)與另一個啟動並執行程式進行通訊。這就是所謂的處理序間通訊(Inter Process Communication,IPC)。有兩種類型的通訊端:基於檔案的和面向網路的。UNIX 通訊端是我們所講的通訊端的第一個家族,並且擁有一個“家族名字”AF_UNIX(又名AF_LOCAL,在POSIX1.g 標準中指定),它代表地址家族(address family):UNIX。包括Python 在內的大多數受歡迎的平台都使用術語地址家族及其縮寫AF;其他比較舊的系統可能會將地址家族表示成域(domain)或協議家族(protocol family),並使用其縮寫PF 而非AF。類似地,AF_LOCAL(在2000~2001 年標準化)將代替AF_UNIX。然而,考慮到回溯相容性,很多系統都同時使用二者,只是對同一個常數使用不同的別名。Python 本身仍然在使用AF_UNIX。因為兩個進程運行在同一台電腦上,所以這些通訊端都是基於檔案的,這意味著檔案
系統支援它們的底層基礎結構。這是能夠說得通的,因為檔案系統是一個運行在同一主機上的多個進程之間的共用常量。
第二種類型的通訊端是基於網路的,它也有自己的家族名字AF_INET,或者地址家族:網際網路。另一個地址家族AF_INET6 用於第6 版網際網路協議(IPv6)定址。此外,還有其他的地址家族,這些要麼是專業的、過時的、很少使用的,要麼是仍未實現的。在所有的地址家族之中,目前AF_INET 是使用得最廣泛的。
Python 2.5 中引入了對特殊類型的Linux 通訊端的支援。通訊端的AF_NETLINK 家族允許使用標準的BSD 通訊端介面進行使用者層級和核心層級代碼之間的IPC。針對Linux 的另一種特性(Python 2.6 中新增)就是支援透明的處理序間通訊(TIPC)協議。TIPC 允許電腦叢集之中的機器相互連信,而無須使用基於IP 的定址方式。Python 對TIPC 的支援以AF_TIPC 家族的方式呈現。
2.2通訊端地址:主機-連接埠對
有效連接埠號碼範圍為0~65535(儘管小於1024 的連接埠號碼預留給了系統)。
2.3連線導向的通訊端
TCP 通訊端,必須使用SOCK_STREAM 作為通訊端類型。
2.4不需連線的通訊端
實現這種連線類型的主要協議是使用者資料包通訊協定(更為人熟知的是其縮寫UDP)。為了建立UDP 通訊端,必須使用SOCK_DGRAM 作為通訊端類型。
3、python中的網路編程3.1socket 模組socket模組屬性
通訊端建立:
socket(socket_family, socket_type, protocol=0)tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)ud pSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
socket對象方法:
伺服器建立:
ss = socket() # 建立伺服器通訊端ss.bind() # 通訊端與地址綁定ss.listen() # 監聽串連inf_loop: # 伺服器無限迴圈cs = ss.accept() # 接受用戶端串連comm_loop: # 通訊迴圈cs.recv()/cs.send() # 對話(接收/發送)cs.close() # 關閉用戶端通訊端ss .close() # 關閉伺服器通訊端#(可選)
為伺服器實現一個智能的退出方案時,建議調用close()方法。
用戶端建立:
cs = socket() # 建立用戶端通訊端cs.connect() # 嘗試串連伺服器comm_loop: # 通訊迴圈cs.send()/cs.recv() # 對話(發送/接收)cs .close() # 關閉用戶端通訊端
I/O多工多工是指使用一個線程來檢查多個檔案描述符(Socket)的就緒狀態,比如調用select和poll函數,傳入多個檔案描述符,如果有一個檔案描述符就緒,則返回,否則阻塞直到逾時。得到就緒狀態後進行真正的操作可以在同一個線程裡執行,也可以啟動線程執行(比如使用線程池)。這樣在處理1000個串連時,只需要1個線程監控就緒狀態,對就緒的每個串連開一個線程處理就可以了,這樣需要的線程數大大減少,減少了記憶體開銷和環境切換的CPU開銷。
舉一個例子,類比一個tcp伺服器處理30個客戶socket。
假設你是一個老師,讓30個學生解答一道題目,然後檢查學生做的是否正確,你有下面幾個選擇:
1. 第一種選擇:
按順序逐個檢查,先檢查A,然後是B,之後是C、D。。。這中間如果有一個學生卡主,全班都會被耽誤。
這種模式就好比,你用迴圈挨個處理socket,根本不具有並發能力。
2. 第二種選擇:你
建立30個分身,每個分身檢查一個學生的答案是否正確。 這種類似於為每一個使用者建立一個進程或者線程處理串連。
3. 第三種選擇,你
站在講台上等,誰解答完誰舉手。這時C、D舉手,表示他們解答問題完畢,你下去依次檢查C、D的答案,然後繼續回到講台上等。此時E、A又舉手,然後去處理E和A。。。
這種就是IO複用模型,Linux下的select、poll和epoll就是幹這個的。將使用者socket對應的fd註冊進epoll,然後epoll幫你監聽哪些socket上有訊息到達,這樣就避免了大量的無用操作。此時的socket應該採用
非阻塞模式。
這樣,整個過程只在調用select、poll、epoll這些調用的時候才會阻塞,收發客戶訊息是不會阻塞的,整個進程或者線程就被充分利用起來,這就是
事件驅動,所謂的reactor模式。
方法:windows python: 提供: selectMac Python: 提供: selectLinux Python: 提供: select、poll、epoll select方法: select -在單線程網路服務中器程式中,管理多個通訊端串連。select的原型為(rlist,wlist,xlist[,timeout]),其中rlist是等待讀取的對象,wlist是等待寫入的對象,xlist是等待異常的對象,最後一個是可選對象,指定等待的時間,單位是s. select()方法的傳回值是準備好的對象的三元組,若在timeout的時間內,沒有對象準備好,那麼傳回值將是空的列表,它採用的是輪詢的方式來實現非同步通訊的。更詳細參照:http://www.cnblogs.com/wupeiqi/articles/5040823.html伺服器:
#!/usr/bin/python 'test TCP server' from socket import * from time import ctime import select import sys HOST = '' PORT = 21567 BUFSIZ = 1024 ADDR = (HOST, PORT) tcpSerSock = socket(AF_INET, SOCK_STREAM) tcpSerSock.bind(ADDR) tcpSerSock.listen(5) input = [tcpSerSock, sys.stdin] #input是一個列表,初始有歡迎通訊端以及標準輸入 while True: print 'waiting for connection...' tcpCliSock, addr = tcpSerSock.accept() print '...connected from:',addr input.append(tcpCliSock) #將服務通訊端加入到input列表中 while True: readyInput,readyOutput,readyException = select.select(input,[],[]) #從input中選擇,輪流處理client的請求串連(tcpSerSock),client發送來的訊息(tcpCliSock),及伺服器端的發送訊息(stdin) for indata in readyInput: if indata==tcpCliSock: #處理client發送來的訊息 data = tcpCliSock.recv(BUFSIZ) print data if data=='88': input.remove(tcpCliSock) break else: #處理伺服器端的發送訊息 data = raw_input('>') if data=='88': tcpCliSock.send('%s' %(data)) input.remove(tcpCliSock) break tcpCliSock.send('[%s] %s' %(ctime(), data)) if data=='88': break tcpCliSock.close() tcpSerSock.close() 用戶端:
#!/usr/bin/python 'test tcp client' from socket import * from time import ctime import select import sys HOST = 'localhost' PORT = 21567 BUFSIZ = 1024 ADDR = (HOST, PORT) tcpCliSock = socket(AF_INET, SOCK_STREAM) tcpCliSock.connect(ADDR) input = [tcpCliSock,sys.stdin] while True: readyInput,readyOutput,readyException = select.select(input,[],[]) for indata in readyInput: if indata==tcpCliSock: data = tcpCliSock.recv(BUFSIZ) print data if data=='88': break else: data = raw_input('>') if data=='88': tcpCliSock.send('%s' %(data)) break tcpCliSock.send('[%s] %s' %(ctime(), data)) if data=='88': break tcpCliSock.close()
3.2 socketserver 模組
SocketServer內部使用 IO多工 以及 “多線程” 和 “多進程” ,從而實現並發處理多個用戶端請求的Socket服務端。即:每個用戶端請求串連到伺服器時,Socket服務端都會在伺服器是建立一個“線程”或者“進程” 專門負責處理當前用戶端的所有請求。
該模組中的類
基本用法: 建立SocketServer TCP 伺服器
# 請求處理常式MyRequestHandler,作為SocketServer# 中StreamRequestHandler 的一個子類,並重寫了它的handle()方法,該方法在基類Request 中# 預設情況下沒有任何行為。# def handle(self):# pass# 當接收到一個來自用戶端的訊息時,它就會調用handle()方法。而StreamRequestHandler# 類將輸入和輸出通訊端看作類似檔案的對象,因此我們將使用readline()來擷取用戶端訊息,# 並利用write()將字串發送回用戶端。from socketserver import TCPServer as TCP,StreamRequestHandler as SRHfrom time import ctimeHOST=''PORT='21567'ADDR=(HOST,PORT)class MyRequestHandle(SRH): def handle(self): print('...connected from:{0}',self.client_address) self.wfile.write('[%s]%s'%(ctime(),self.rfile.readline()))tcpSever=TCP(ADDR,MyRequestHandle)print('waiting for connection')tcpSever.serve_forever() 建立TCP用戶端
from socket import *HOST='localhost'PORT='21567'BUFSIZ=1024ADDR=(HOST,PORT)while True: tcpClisocket=socket(ADDR,SOCK_STREAM) tcpClisocket.connect(ADDR) data=input('>') if not data: break # 因為這裡使用的處理常式類對待套 # 接字通訊就像檔案一樣,所以必鬚髮送行終止符(斷行符號和分行符號) # 而伺服器只是保留並重用這裡發送的終止符。當得到從伺服器返回的訊息時,用strip() # 函數對其進行處理並使用由print聲明自動提供的分行符號。 tcpClisocket.send('%s\r\n'%data) data=tcpClisocket.recv(BUFSIZ) if not data: break print(data.strip()) tcpClisocket.close() ThreadingTCPServer
ThreadingTCPServer實現的Soket伺服器內部會為每個client建立一個 “線程”,該線程用來和用戶端進行互動。
參照:http://www.cnblogs.com/wupeiqi/articles/5040823.html
- 建立一個繼承自 SocketServer.BaseRequestHandler 的類
- 類中必須定義一個名稱為 handle 的方法
- 啟動ThreadingTCPServer
# 啟動服務端程式# 執行 TCPServer.__init__ 方法,建立服務端Socket對象並綁定 IP 和 連接埠# 執行 BaseServer.__init__ 方法,將自訂的繼承自SocketServer.BaseRequestHandler 的類 MyRequestHandle賦值給 self.RequestHandlerClass# 執行 BaseServer.server_forever 方法,While 迴圈一直監聽是否有用戶端請求到達 ...# 當用戶端串連到達伺服器# 執行 ThreadingMixIn.process_request 方法,建立一個 “線程” 用來處理請求# 執行 ThreadingMixIn.process_request_thread 方法# 執行 BaseServer.finish_request 方法,執行 self.RequestHandlerClass() 即:執行 自訂 MyRequestHandler 的構造方法(自動調用基類BaseRequestHandler的構造方法,在該構造方法中又會調用 MyRequestHandler的handle方法)# 伺服器# #!/usr/bin/env python# # -*- coding:utf-8 -*-import SocketServerclass MyServer(SocketServer.BaseRequestHandler): def handle(self): # print self.request,self.client_address,self.server conn = self.request conn.sendall('歡迎致電 10086,請輸入1xxx,0轉人工服務.') Flag = True while Flag: data = conn.recv(1024) if data == 'exit': Flag = False elif data == '0': conn.sendall('通過可能會被錄音.balabala一大推') else: conn.sendall('請重新輸入.')if __name__ == '__main__': server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer) server.serve_forever()ForkingTcpSever
ForkingTCPServer和ThreadingTCPServer的使用和執行流程基本一致,只不過在內部分別為要求者建立 “線程” 和 “進程”。
3.3 Twisted模組
Twisted 是一個完整的事件驅動的網路架構,利用它既能使用也能開發完整的非同步網路應用程式和協議。它提供了大量的支援來建立完整的系統,包括網路通訊協定、線程、安全性和身分識別驗證、聊天/ IM、DBM 及RDBMS 資料庫整合、Web/網際網路、電子郵件、命令列參數、GUI 整合工具包等。與SocketServer 類似,Twisted 的大部分功能都存在於它的類中。
Twisted Reactor TCP伺服器
基於protocol 類建立TSServProtocol,重寫connectionMade()和dataReceived()方法,當一個用戶端串連到伺服器時就會執行connectionMade()方法,而當伺服器接收到用戶端通過網路發送的一些資料時就會調用dataReceived()方法。
reactor 會作為該方法的一個參數在資料中傳輸,這樣就能在無須自己提取它的情況下訪問它。在伺服器代碼的最後部分中,建立了一個協議工廠。它之所以被稱為工廠,是因為每次得到一個接入串連時,都能“製造”協議的一個執行個體。然後在reactor 中安裝一個TCP 監聽器,以此檢查服務要求。當它接收到一個請求時,就會建立一個TSServProtocol 執行個體來處理那個用戶端的事務。
from twisted.internet import protocol,reactorfrom time import ctimePORT=21567class TSServProtocal(protocol.Protocol): def connectionMade(self): clnt=self.clnt=self.transport.getPeer().host print('...conected from:',clnt) def dataReceived(self, data): self.transport.write('[%s]%s'%(ctime(),data))factory=protocol.Factory()factory.protocol=TSServProtocalprint('waiting for conneciton')reactor.listenTCP(PORT,factory)reactor.run() Twisted Reactor TCP用戶端
from twisted.internet import protocol, reactorHOST='localhost'PORT=21567class TSClntProtocal(protocol.Protocol): def sendData(self): data=input('>') if data: print('...sending%...'%data) else: self.transport.loseConnection() def connectionMade(self): self.sendData() def dataReceived(self, data): print(data)class TSClntFactory(protocol.Factory): protocol=TSClntProtocal clientConnectionLost=clientConnectionFailed=\ lambda self,connector,reason:reactor.stop()reactor.connectTCP(HOST,PORT,TSClntFactory())reactor.run()