python网络编程-socket编程
一、服務(wù)端和客戶端
BS架構(gòu) （騰訊通軟件：server+client）
CS架構(gòu) （web網(wǎng)站）
?
C/S架構(gòu)與socket的關(guān)系：
我們學(xué)習(xí)socket就是為了完成C/S架構(gòu)的開發(fā)
?
二、OSI七層模型
互聯(lián)網(wǎng)協(xié)議按照功能不同分為osi七層或tcp/ip五層或tcp/ip四層
?
每層運行常見物理設(shè)備
?
詳細(xì)參考：
http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label4
?
學(xué)習(xí)socket一定要先學(xué)習(xí)互聯(lián)網(wǎng)協(xié)議：
1.首先：本節(jié)課程的目標(biāo)就是教會你如何基于socket編程，來開發(fā)一款自己的C/S架構(gòu)軟件
2.其次：C/S架構(gòu)的軟件（軟件屬于應(yīng)用層）是基于網(wǎng)絡(luò)進(jìn)行通信的
3.然后：網(wǎng)絡(luò)的核心即一堆協(xié)議，協(xié)議即標(biāo)準(zhǔn)，你想開發(fā)一款基于網(wǎng)絡(luò)通信的軟件，就必須遵循這些標(biāo)準(zhǔn)。
4.最后：就讓我們從這些標(biāo)準(zhǔn)開始研究，開啟我們的socket編程之旅
TCP/IP協(xié)議族包括運輸層、網(wǎng)絡(luò)層、鏈路層。
?
三、socket層，不懂看圖就明白了。
Socket是介于應(yīng)用層和傳輸層之間。
四、socket是什么
Socket是應(yīng)用層與TCP/IP協(xié)議族通信的中間軟件抽象層，它是一組接口。在設(shè)計模式中，Socket其實就是一個門面模式，它把復(fù)雜的TCP/IP協(xié)議族隱藏在Socket接口后面，對用戶來說，一組簡單的接口就是全部，讓Socket去組織數(shù)據(jù)，以符合指定的協(xié)議。
所以，我們無需深入理解tcp/udp協(xié)議，socket已經(jīng)為我們封裝好了，我們只需要遵循socket的規(guī)定去編程，寫出的程序自然就是遵循tcp/udp標(biāo)準(zhǔn)的。
?掃盲篇：
1 將socket說成ip+port，ip是用來標(biāo)識互聯(lián)網(wǎng)中的一臺主機(jī)的位置，而port是用來標(biāo)識這臺機(jī)器上的一個應(yīng)用程序，ip地址是配置到網(wǎng)卡上的，而port是應(yīng)用程序開啟的，ip與port的綁定就標(biāo)識了互聯(lián)網(wǎng)中獨一無二的一個應(yīng)用程序 2 3 而程序的pid是同一臺機(jī)器上不同進(jìn)程或者線程的標(biāo)識（Google Chrome會有多個PID）?
五、套接字發(fā)展史及分類
套接字起源于 20 世紀(jì) 70 年代加利福尼亞大學(xué)伯克利分校版本的 Unix,即人們所說的 BSD Unix。 因此,有時人們也把套接字稱為“伯克利套接字”或“BSD 套接字”。一開始,套接字被設(shè)計用在同 一臺主機(jī)上多個應(yīng)用程序之間的通訊。這也被稱進(jìn)程間通訊,或 IPC。套接字有兩種（或者稱為有兩個種族）,分別是基于文件型的和基于網(wǎng)絡(luò)型的。?
?
1、基于文件類型的套接字家族
套接字家族的名字：AF_UNIX
unix一切皆文件，基于文件的套接字調(diào)用的就是底層的文件系統(tǒng)來取數(shù)據(jù)，兩個套接字進(jìn)程運行在同一機(jī)器，可以通過訪問同一個文件系統(tǒng)間接完成通信
?
2、基于網(wǎng)絡(luò)類型的套接字家族
套接字家族的名字：AF_INET
(還有AF_INET6被用于ipv6，還有一些其他的地址家族，不過，他們要么是只用于某個平臺，要么就是已經(jīng)被廢棄，或者是很少被使用，或者是根本沒有實現(xiàn)，所有地址家族中，AF_INET是使用最廣泛的一個，python支持很多種地址家族，但是由于我們只關(guān)心網(wǎng)絡(luò)編程，所以大部分時候我么只使用AF_INET)
?
六、套接字工作流程
? ? ? 生活中的場景，你要打電話給一個朋友，先撥號，朋友聽到電話鈴聲后提起電話，這時你和你的朋友就建立起了連接，就可以講話了。等交流結(jié)束，掛斷電話結(jié)束此次交談。????
生活中的場景就解釋了這工作原理，也許TCP/IP協(xié)議族就是誕生于生活中，這也不一定。
?
先從服務(wù)器端說起。服務(wù)器端先初始化Socket，然后與端口綁定(bind)，對端口進(jìn)行監(jiān)聽(listen)，調(diào)用accept阻塞，等待客戶端連接。在這時如果有個客戶端初始化一個Socket，然后連接服務(wù)器(connect)，如果連接成功，這時客戶端與服務(wù)器端的連接就建立了。客戶端發(fā)送數(shù)據(jù)請求，服務(wù)器端接收請求并處理請求，然后把回應(yīng)數(shù)據(jù)發(fā)送給客戶端，客戶端讀取數(shù)據(jù)，最后關(guān)閉連接，一次交互結(jié)束。
?
1、socket模塊發(fā)送和接收消息
示例：模擬發(fā)送消息和接收消息的過程
tcp服務(wù)端（server）
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socketphone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #買手機(jī) phone.bind(('127.0.0.1',8000)) #綁定手機(jī)卡 #改成服務(wù)端網(wǎng)卡IP地址和端口 phone.listen(5) #開機(jī) 5的作用是最大掛起連接數(shù) #backlog連接池（也叫半鏈接） print('------------->') conn,addr=phone.accept() #等電話 msg=conn.recv(1024) #收消息 print('客戶端發(fā)來的消息是：',msg) conn.send(msg.upper()) #發(fā)消息 conn.close() phone.close() View Code?
執(zhí)行結(jié)果：
------------->tcp客戶端(client)
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socketphone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)phone.connect(('127.0.0.1',8000)) #拔通電話 #改成服務(wù)端網(wǎng)卡IP地址和端口 phone.send('hello'.encode('utf-8')) #發(fā)消息 data=phone.recv(1024) print('收到服務(wù)端的發(fā)來的消息: ',data)phone.close() View Code?
?
執(zhí)行結(jié)果：
收到服務(wù)端的發(fā)來的消息: b'HELLO'2、tcp三次握手和四次揮手
主動斷開連接 ：FIN_WAIT_1
被動斷開連接： FIN_WAIT_2
馬上斷開連接： TIME_WAIT
?
socket中TCP的三次握手建立連接詳解
流程如下：
- 客戶端向服務(wù)器發(fā)送一個SYN J
- 服務(wù)器向客戶端響應(yīng)一個SYN K，并對SYN J進(jìn)行確認(rèn)ACK J+1
- 客戶端再向服務(wù)器發(fā)一個確認(rèn)ACK K+1
只有就完了三次握手，但是這個三次握手發(fā)生在socket的那幾個函數(shù)中呢？請看下圖：
? ? ? ? ? ? ? ? ? ? 圖1、socket中發(fā)送的TCP三次握手
從圖中可以看出，當(dāng)客戶端調(diào)用connect時，觸發(fā)了連接請求，向服務(wù)器發(fā)送了SYN J包，這時connect進(jìn)入阻塞狀態(tài)；服務(wù)器監(jiān)聽到連接請求，即收到SYN J包，調(diào)用accept函數(shù)接收請求向客戶端發(fā)送SYN K ，ACK J+1，這時accept進(jìn)入阻塞狀態(tài)；客戶端收到服務(wù)器的SYN K ，ACK J+1之后，這時connect返回，并對SYN K進(jìn)行確認(rèn)；服務(wù)器收到ACK K+1時，accept返回，至此三次握手完畢，連接建立。
總結(jié)：客戶端的connect在三次握手的第二個次返回，而服務(wù)器端的accept在三次握手的第三次返回。
?
socket中TCP的四次握手釋放連接詳解
上面介紹了socket中TCP的三次握手建立過程，及其涉及的socket函數(shù)。現(xiàn)在我們介紹socket中的四次握手釋放連接的過程，請看下圖：
? ? ? ? ? ? ? ? ?圖2、socket中發(fā)送的TCP四次握手
圖示過程如下：
- 某個應(yīng)用進(jìn)程首先調(diào)用close主動關(guān)閉連接，這時TCP發(fā)送一個FIN M；
- 另一端接收到FIN M之后，執(zhí)行被動關(guān)閉，對這個FIN進(jìn)行確認(rèn)。它的接收也作為文件結(jié)束符傳遞給應(yīng)用進(jìn)程，因為FIN的接收意味著應(yīng)用進(jìn)程在相應(yīng)的連接上再也接收不到額外數(shù)據(jù)；
- 一段時間之后，接收到文件結(jié)束符的應(yīng)用進(jìn)程調(diào)用close關(guān)閉它的socket。這導(dǎo)致它的TCP也發(fā)送一個FIN N；
- 接收到這個FIN的源發(fā)送端TCP對它進(jìn)行確認(rèn)。
這樣每個方向上都有一個FIN和ACK。
?
總結(jié)：
四次揮手?jǐn)嚅_連接原則：
記住一條原則：誰先發(fā)起客戶端請求，誰先斷開連接
但是在大并發(fā)情況下，大部分都是服務(wù)端先斷開連接，不會保留連接。因為每一分鐘都有很多人在訪問網(wǎng)站。
?
3、socket()模塊函數(shù)用法
import socket socket.socket(socket_family,socket_type,protocal=0) socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默認(rèn)值為 0。獲取tcp/ip套接字 tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)獲取udp/ip套接字 udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)由于 socket 模塊中有太多的屬性。我們在這里破例使用了'from module import *'語句。使用 'from socket import *',我們就把 socket 模塊里的所有屬性都帶到我們的命名空間里了,這樣能 大幅減短我們的代碼。 例如tcpSock = socket(AF_INET, SOCK_STREAM) View Code?
服務(wù)端套接字函數(shù)
s.bind() ? ? 綁定(主機(jī),端口號)到套接字
s.listen() ? ?開始TCP監(jiān)聽
s.accept() 被動接受TCP客戶的連接,(阻塞式)等待連接的到來
客戶端套接字函數(shù)
s.connect() ? ? ? ? ? ? ? ? ? ? ? 主動初始化TCP服務(wù)器連接
s.connect_ex() connect() ?函數(shù)的擴(kuò)展版本,出錯時返回出錯碼,而不是拋出異常
公共用途的套接字函數(shù)
s.recv() ? ? ? ? 接收TCP數(shù)據(jù)
s.send() ? ? ? ?發(fā)送TCP數(shù)據(jù)(send在待發(fā)送數(shù)據(jù)量大于己端緩存區(qū)剩余空間時,數(shù)據(jù)丟失,不會發(fā)完)
s.sendall() ? ? 發(fā)送完整的TCP數(shù)據(jù)(本質(zhì)就是循環(huán)調(diào)用send,sendall在待發(fā)送數(shù)據(jù)量大于己端緩存區(qū)剩余空間時,數(shù)據(jù)不丟失,循環(huán)調(diào)用send直到發(fā)完)
s.recvfrom() ?接收UDP數(shù)據(jù)
s.sendto() ? ? 發(fā)送UDP數(shù)據(jù)
s.getpeername() ? 連接到當(dāng)前套接字的遠(yuǎn)端的地址
s.getsockname() ? 當(dāng)前套接字的地址
s.getsockopt() ? ? ?返回指定套接字的參數(shù)
s.setsockopt() ? ? ? 設(shè)置指定套接字的參數(shù)
s.close() ? ? ? ? ? ? ? 關(guān)閉套接字
面向鎖的套接字方法
s.setblocking() ? 設(shè)置套接字的阻塞與非阻塞模式
s.settimeout() ? ?設(shè)置阻塞套接字操作的超時時間
s.gettimeout() ? ?得到阻塞套接字操作的超時時間
面向文件的套接字的函數(shù)
s.fileno() ? ? ? ?套接字的文件描述符
s.makefile() ? 創(chuàng)建一個與該套接字相關(guān)的文件
?
七、基于TCP的套接字
tcp語法格式：
tcp服務(wù)端
ss = socket() #創(chuàng)建服務(wù)器套接字 ss.bind() #把地址綁定到套接字 ss.listen() #監(jiān)聽鏈接 inf_loop: #服務(wù)器無限循環(huán)cs = ss.accept() #接受客戶端鏈接comm_loop: #通訊循環(huán)cs.recv()/cs.send() #對話(接收與發(fā)送)cs.close() #關(guān)閉客戶端套接字 ss.close() #關(guān)閉服務(wù)器套接字(可選) View Code?
tcp客戶端
cs = socket() #創(chuàng)建客戶套接字 cs.connect() #嘗試連接服務(wù)器 comm_loop: #通訊循環(huán)cs.send()/cs.recv() #對話(發(fā)送/接收) cs.close() #關(guān)閉客戶套接字 View Code?
?
1、基于tcp實現(xiàn)：客戶端發(fā)送空格，服務(wù)端也會接收
示例：
tcp_server端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *ip_port = ('127.0.0.1', 8080) back_log = 5 buffer_size = 1024tcp_server = socket(AF_INET, SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)print('服務(wù)端開始運行了') conn, addr = tcp_server.accept() #服務(wù)器阻塞 print('雙向鏈接是', conn) print('客戶端地址', addr)while True:data = conn.recv(buffer_size) #收緩存為空，則阻塞print('客戶端發(fā)來的消息是', data.decode('utf-8'))conn.send(data.upper()) conn.close()tcp_server.close() View Code?
tcp_client端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *ip_port = ('127.0.0.1', 8080) back_log = 5 buffer_size = 1024tcp_client = socket(AF_INET, SOCK_STREAM) tcp_client.connect(ip_port)while True:msg = input('>>:') #發(fā)送空格到自己的發(fā)送緩存中# msg=input('>>:').strip() #去掉空格tcp_client.send(msg.encode('utf-8'))print('客戶端已經(jīng)發(fā)送消息')data = tcp_client.recv(buffer_size) #收緩存為空則阻塞print('收到服務(wù)端發(fā)來的消息是', data.decode('utf-8'))tcp_client.close() View Code?
執(zhí)行結(jié)果：
?View Code?
實驗過程中遇到的問題：
在重啟服務(wù)端時可能會遇到如下報錯：
這個是由于你的服務(wù)端仍然存在四次揮手的time_wait狀態(tài)在占用地址（如果不懂，請深入研究1.tcp三次握手，四次揮手 2.syn洪水攻擊 3.服務(wù)器高并發(fā)情況下會有大量的time_wait狀態(tài)的優(yōu)化方法）。
解決方法：
法一：在程序中處理
1 #加入一條socket配置，重用ip和端口 2 3 phone=socket(AF_INET,SOCK_STREAM) 4 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加 5 phone.bind(('127.0.0.1',8080))?
法二：在linux系統(tǒng)中，通過調(diào)整系統(tǒng)內(nèi)核參數(shù)的方式來解決
發(fā)現(xiàn)系統(tǒng)存在大量TIME_WAIT狀態(tài)的連接，通過調(diào)整linux內(nèi)核參數(shù)解決，系統(tǒng)優(yōu)化的一個優(yōu)化點）vi /etc/sysctl.conf編輯文件，加入以下內(nèi)容： net.ipv4.tcp_syncookies = 1 net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_tw_recycle = 1 net.ipv4.tcp_fin_timeout = 30然后執(zhí)行 /sbin/sysctl -p 讓參數(shù)生效。net.ipv4.tcp_syncookies = 1 表示開啟SYN Cookies。當(dāng)出現(xiàn)SYN等待隊列溢出時，啟用cookies來處理，可防范少量SYN攻擊，默認(rèn)為0，表示關(guān)閉；net.ipv4.tcp_tw_reuse = 1 表示開啟重用。允許將TIME-WAIT sockets重新用于新的TCP連接，默認(rèn)為0，表示關(guān)閉；net.ipv4.tcp_tw_recycle = 1 表示開啟TCP連接中TIME-WAIT sockets的快速回收，默認(rèn)為0，表示關(guān)閉。net.ipv4.tcp_fin_timeout = 30 修改系統(tǒng)默認(rèn)的 TIMEOUT 時間 View Code?
八、基于UDP的套接字
udp語法格式：
udp服務(wù)端
1 ss = socket() #創(chuàng)建一個服務(wù)器的套接字 2 ss.bind() #綁定服務(wù)器套接字 3 inf_loop: #服務(wù)器無限循環(huán) 4 cs = ss.recvfrom()/ss.sendto() # 對話(接收與發(fā)送) 5 ss.close()udp客戶端
1 cs = socket() # 創(chuàng)建客戶套接字 2 comm_loop: # 通訊循環(huán) 3 cs.sendto()/cs.recvfrom() # 對話(發(fā)送/接收) 4 cs.close() # 關(guān)閉客戶套接字?
1、基于upd實現(xiàn)方法
示例：
udp_server端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8080) buffer_size = 1024udp_server = socket(AF_INET,SOCK_DGRAM) #數(shù)據(jù)報套接字 udp_server.bind(ip_port)while True:data,addr=udp_server.recvfrom(buffer_size)print(data)udp_server.sendto(data.upper(),addr) #upper() 小寫變大寫 View Code?
udp_client端：
from socket import * ip_port=('127.0.0.1',8080) #服務(wù)端IP+端口 buffer_size = 1024udp_client=socket(AF_INET,SOCK_DGRAM) #udp數(shù)據(jù)報套接字while True:msg=input('>>:').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)#數(shù)據(jù)，ip地址+端口data,addr=udp_client.recvfrom(buffer_size)print(data.decode('utf-8')) View Code?
執(zhí)行結(jié)果：
先運行udp_server，再運行udp_client。
服務(wù)端返回結(jié)果：
1 b'sfdsfds' #bytes類型 2 b'fdsfds' 3 b'fsdfds' 4 b'sdfdsf'在客戶端輸入：
1 >>:sfdsfds #在客戶端輸入 2 SFDSFDS #服務(wù)端返回的結(jié)果，把客戶端輸入的字符變大寫 3 4 >>:fdsfds 5 FDSFDS 6 7 >>:fsdfds 8 FSDFDS?
2、實現(xiàn)ntp時間服務(wù)器
示例：
tup_server端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nulige#實現(xiàn)ntp時間服務(wù)器 import time from socket import * ip_port=('127.0.0.1',8080) buffer_size = 1024udp_server = socket(AF_INET,SOCK_DGRAM) #數(shù)據(jù)報套接字 udp_server.bind(ip_port)while True:data,addr=udp_server.recvfrom(buffer_size)print(data)if not data:fmt='%Y-%m-%d %X' #如果用戶沒有輸入時間，就返回默認(rèn)格式else:fmt=data.decode('utf-8')back_time=time.strftime(fmt)udp_server.sendto(back_time.encode('utf-8'),addr) View Code?
udp_client端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8080) #服務(wù)端IP+端口 buffer_size = 1024udp_client=socket(AF_INET,SOCK_DGRAM) #數(shù)據(jù)報套接字while True:msg=input('>>:').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)data,addr=udp_client.recvfrom(buffer_size)print('ntp服務(wù)器的標(biāo)準(zhǔn)時間是',data.decode('utf-8')) View Code?
執(zhí)行結(jié)果：
運行udp_server,再運行udp_client,然后在udp_client里輸入：
1 >>:%Y #在客戶端輸入%Y 2 ntp服務(wù)器的標(biāo)準(zhǔn)時間是 2017 #就會返回服務(wù)端的時間 3 >>:%m-%d-%Y 4 ntp服務(wù)器的標(biāo)準(zhǔn)時間是 01-03-2017 5 >>:?
3、基于tcp實現(xiàn)遠(yuǎn)程執(zhí)行命令
備注：因系統(tǒng)差異，請盡量把程序放在linux服務(wù)器上面運行，windows上面可能會報錯。
socket_server_tcp服務(wù)端 (在linux上面運行）
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import subprocessip_port = ('192.168.1.135', 8000) back_log = 5 buffer_size = 1024tcp_server = socket(AF_INET, SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)while True:conn,addr=tcp_server.accept()print('新的客戶端鏈接',addr)while True:#收try:cmd=conn.recv(buffer_size)#if not cmd:break MAC筆記本處理方法print('收到客戶端的命令',cmd)#執(zhí)行命令，得到命令的運行結(jié)果cmd_resres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err=res.stderr.read()if err:cmd_res=errelse:cmd_res=res.stdout.read()#發(fā) conn.send(cmd_res)except Exception as e:print(e)break conn.close() View Code?
socket_client_tcp客戶端（windows系統(tǒng)上面運行）
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *# ip_port = ('127.0.0.1', 8082) ip_port = ('192.168.1.135', 8000) back_log = 5 buffer_size = 1024tcp_client = socket(AF_INET, SOCK_STREAM) tcp_client.connect(ip_port)while True:cmd=input('>>:').strip()if not cmd:continueif cmd == 'quit':breaktcp_client.send(cmd.encode('utf-8'))cmd_res=tcp_client.recv(buffer_size)# print('命令的執(zhí)行結(jié)果是 ',cmd_res.decode('gbk'))print('命令的執(zhí)行結(jié)果是 ',cmd_res.decode('utf-8')) tcp_client.close() View Code?
執(zhí)行結(jié)果：
在客戶端執(zhí)行命令：
>>:df -h命令的執(zhí)行結(jié)果是 Filesystem Size Used Avail Use% Mounted on/dev/sda3 9.6G 1.8G 7.3G 20% /tmpfs 931M 0 931M 0% /dev/shm/dev/sda1 190M 32M 149M 18% /boot/dev/sr0 4.4G 4.4G 0 100% /opt>>:dir命令的執(zhí)行結(jié)果是 s3.py server_ssh.py socket_server.py server.py socket_clinet_udp.py socket_server_udp.py服務(wù)端返回結(jié)果： [root@python3 scripts]# python socket_server.py 新的客戶端鏈接 ('192.168.1.115', 53569) 收到客戶端的命令 b'df -h' 收到客戶端的命令 b'dir' View Code?
4、基于udp實現(xiàn)遠(yuǎn)程執(zhí)行命令
socket_server_udp服務(wù)端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import subprocessip_port = ('192.168.1.135', 8000) back_log = 5 buffer_size = 1024udp_server = socket(AF_INET, SOCK_DGRAM) udp_server.bind(ip_port)while True:cmd,addr=udp_server.recvfrom(buffer_size)print(cmd)#執(zhí)行命令，得到命令的運行結(jié)果cmd_resres = subprocess.Popen(cmd.decode('utf-8'), shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err = res.stderr.read()if err:cmd_res = errelse:cmd_res = res.stdout.read()if not cmd_res: # 判斷為空的情況cmd_res = '執(zhí)行成功'.encode('gbk') #linux改成utf-8print(cmd_res)#發(fā)udp_server.sendto(cmd_res,addr) View Code?
socket_clinet_udp客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import *ip_port = ('192.168.1.135', 8000) # ip_port = ('192.168.12.63', 8000) back_log = 5 buffer_size = 10240udp_client = socket(AF_INET, SOCK_DGRAM)while True:cmd=input('>>:').strip()if not cmd:continueif cmd == 'quit':breakudp_client.sendto(cmd.encode('utf-8'),ip_port)cmd_res,addr=udp_client.recvfrom(buffer_size)print('命令的執(zhí)行結(jié)果是 ',cmd_res.decode('gbk')) #如果在linux上面運行，把gbk改成utf-8 udp_client.close() View Code?
執(zhí)行結(jié)果：
?View Code?
九、recv與recvfrom的區(qū)別
1、收發(fā)原理詳解：
發(fā)消息：都是將數(shù)據(jù)發(fā)送到己端的發(fā)送緩沖中
收消息：都是從己端的緩沖區(qū)中收
?
2、發(fā)消息二者類似，收消息確實有區(qū)別的？
tcp協(xié)議：send發(fā)消息，recv收消息
（1）如果收消息緩沖區(qū)里的數(shù)據(jù)為空，那么recv就會阻塞
（2）tcp基于鏈接通信，如果一端斷開了鏈接，那另外一端的鏈接也跟著完蛋recv將不會阻塞，收到的是空
?
udp協(xié)議：sendto發(fā)消息，recvfrom收消息
（1）如果如果收消息緩沖區(qū)里的數(shù)據(jù)為“空”，recvfrom不會阻塞
（2）recvfrom收的數(shù)據(jù)小于sendinto發(fā)送的數(shù)據(jù)時，數(shù)據(jù)丟失
（3）只有sendinto發(fā)送數(shù)據(jù)沒有recvfrom收數(shù)據(jù)，數(shù)據(jù)丟失
?
注意：
1.你單獨運行上面的udp的客戶端，你發(fā)現(xiàn)并不會報錯，相反tcp卻會報錯，因為udp協(xié)議只負(fù)責(zé)把包發(fā)出去，對方收不收，我根本不管，而tcp是基于鏈接的，必須有一個服務(wù)端先運行著，客戶端去跟服務(wù)端建立鏈接然后依托于鏈接才能傳遞消息，任何一方試圖把鏈接摧毀都會導(dǎo)致對方程序的崩潰。
2.上面的udp程序，你注釋任何一條客戶端的sendinto，服務(wù)端都會卡住，為什么？因為服務(wù)端有幾個recvfrom就要對應(yīng)幾個sendinto，哪怕是sendinto(b'')那也要有。
?
3.總結(jié)：
1.udp的sendinto不用管是否有一個正在運行的服務(wù)端，可以己端一個勁的發(fā)消息
2.udp的recvfrom是阻塞的，一個recvfrom(x)必須對一個一個sendinto(y),收完了x個字節(jié)的數(shù)據(jù)就算完成,若是y>x數(shù)據(jù)就丟失，這意味著udp根本不會粘包，但是會丟數(shù)據(jù)，不可靠
3.tcp的協(xié)議數(shù)據(jù)不會丟，己端總是在收到ack時才會清除緩沖區(qū)內(nèi)容。數(shù)據(jù)是可靠的，但是會粘包。
?
十、粘包
須知：只有TCP有粘包現(xiàn)象，UDP永遠(yuǎn)不會粘包。（原因詳見第3點）
1、socket收發(fā)消息的原理
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??? ? ?socket發(fā)送原理圖
?
2、為什么會出現(xiàn)所謂的粘包
原因：接收方不知道消息之間的界限，不知道一次性提取多少字節(jié)的數(shù)據(jù)所造成的。
此外，發(fā)送方引起的粘包是由TCP協(xié)議本身造成的，TCP為提高傳輸效率，發(fā)送方往往要收集到足夠多的數(shù)據(jù)后才發(fā)送一個TCP段。若連續(xù)幾次需要send的數(shù)據(jù)都很少，通常TCP會根據(jù)優(yōu)化算法把這些數(shù)據(jù)合成一個TCP段后一次發(fā)送出去，這樣接收方就收到了粘包數(shù)據(jù)。
?
3、tcp會發(fā)生粘包的兩種情況如下：
1、發(fā)送端多次send間隔較短，并且數(shù)據(jù)量較小，tcp會通過Nagls算法，封裝成一個包，發(fā)送到接收端，接收端不知道這個包由幾部分組成，所以就會產(chǎn)生粘包。
2、數(shù)據(jù)量發(fā)送的大，接收端接收的小，再接一次，還會出現(xiàn)上次沒有接收完成的數(shù)據(jù)。就會出現(xiàn)粘包。
?
示例1：?發(fā)送端多次send間隔較短，并且數(shù)據(jù)量較小，tcp會通過Nagls算法，封裝成一個包，發(fā)送到接收端，接收端不知道這個包由幾部分組成，所以就會產(chǎn)生粘包。
server服務(wù)端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8082) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)conn,addr=tcp_server.accept()data1=conn.recv(buffer_size) #指定buffer_size ,得到的結(jié)果就是通過Nagle算法，隨機(jī)接收次數(shù)。 print('第1次數(shù)據(jù)',data1)data2=conn.recv(buffer_size) print('第2次數(shù)據(jù)',data2)data3=conn.recv(buffer_size) print('第3次數(shù)據(jù)',data3) View Code?
client客戶端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import timeip_port=('127.0.0.1',8082) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)tcp_client.send('hello'.encode('utf-8')) tcp_client.send('world'.encode('utf-8')) tcp_client.send('egon'.encode('utf-8'))time.sleep(1000) View Code?
執(zhí)行結(jié)果：
第1次數(shù)據(jù) b'helloworldegon' #不確定接收次數(shù)。?
示例2：指定接收字節(jié)數(shù)，相當(dāng)于服務(wù)端知道接收長度，就不會出現(xiàn)粘包現(xiàn)象
粘包服務(wù)端
from socket import * ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)conn,addr=tcp_server.accept()data1=conn.recv(5) #指定每次接收字節(jié)數(shù)，就不會出現(xiàn)粘包現(xiàn)象 print('第一次數(shù)據(jù)',data1)data2=conn.recv(5) print('第2次數(shù)據(jù)',data2)data3=conn.recv(5) print('第3次數(shù)據(jù)',data3) View Code?
粘包客戶端
from socket import * import time ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)tcp_client.send('hello'.encode('utf-8')) tcp_client.send('world'.encode('utf-8')) tcp_client.send('egon'.encode('utf-8'))time.sleep(1000) View Code?
執(zhí)行結(jié)果：
1 第1次數(shù)據(jù) b'hello' #不會出現(xiàn)粘包現(xiàn)象，發(fā)送三次，就接收三次 2 第2次數(shù)據(jù) b'world' 3 第3次數(shù)據(jù) b'egon'?
示例3：數(shù)據(jù)量發(fā)送的大，接收端接收的小，再接一次，還會出現(xiàn)上次沒有接收完成的數(shù)據(jù)。就會出現(xiàn)粘包。
粘包服務(wù)端
from socket import * ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)conn,addr=tcp_server.accept()data1=conn.recv(1) print('第1次數(shù)據(jù)',data1)# data2=conn.recv(5) # print('第2次數(shù)據(jù)',data2) # # data3=conn.recv(1) # print('第3次數(shù)據(jù)',data3) View Code?
粘包客戶端
from socket import * import time ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024 #接收的數(shù)據(jù)只有1024 tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)tcp_client.send('helloworldegon'.encode('utf-8'))time.sleep(1000) View Code?
執(zhí)行結(jié)果：?
1 第1次數(shù)據(jù) b'h' 2 第2次數(shù)據(jù) b'ellow' #發(fā)送的數(shù)據(jù)過大，接收的數(shù)據(jù)設(shè)置的較小，就會出現(xiàn)導(dǎo)致粘包 3 第3次數(shù)據(jù) b'o'?
4、udp永遠(yuǎn)不會粘包
示例：
udp不粘包服務(wù)端
from socket import * ip_port=('127.0.0.1',8080) buffer_size=1024udp_server=socket(AF_INET,SOCK_DGRAM) #數(shù)據(jù)報 udp_server.bind(ip_port)data1=udp_server.recvfrom(10) print('第1次',data1)data2=udp_server.recvfrom(10) print('第2次',data2)data3=udp_server.recvfrom(10) print('第3次',data3)data4=udp_server.recvfrom(2) print('第4次',data4) View Code?
udp不粘包客戶端
from socket import * ip_port=('127.0.0.1',8080) buffer_size=1024udp_client=socket(AF_INET,SOCK_DGRAM) #udp叫數(shù)據(jù)報 udp_client.sendto(b'hello',ip_port) udp_client.sendto(b'world',ip_port) udp_client.sendto(b'egon',ip_port) View Code?
?執(zhí)行結(jié)果：
1 第1次 (b'hello', ('127.0.0.1', 57813)) #udp沒有Nagle優(yōu)化算法 2 第2次 (b'world', ('127.0.0.1', 57813)) #每次都是一次獨立的包，所以不會出現(xiàn)粘包現(xiàn)象 3 第3次 (b'egon', ('127.0.0.1', 57813))?
5、qq聊天(由于udp無連接，所以可以同時多個客戶端去跟服務(wù)端通信)
udp_socket_server服務(wù)端代碼：
#實現(xiàn)類似于QQ聊天功能#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socket ip_port=('127.0.0.1',8081) udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udp_server_sock.bind(ip_port)while True:qq_msg,addr=udp_server_sock.recvfrom(1024)print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))back_msg=input('回復(fù)消息: ').strip()udp_server_sock.sendto(back_msg.encode('utf-8'),addr) View Code?
udp_socket_client客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)qq_name_dic={'努力哥':('127.0.0.1',8081),'劉哥':('127.0.0.1',8081),'李哥':('127.0.0.1',8081),'王哥':('127.0.0.1',8081), }while True:qq_name=input('請選擇聊天對象: ').strip() #選擇字典中的聊天對象，再發(fā)送消息while True:msg=input('請輸入消息,回車發(fā)送: ').strip()if msg == 'quit':breakif not msg or not qq_name or qq_name not in qq_name_dic:continueudp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))udp_client_socket.close() View Code?
執(zhí)行結(jié)果：
先啟動服務(wù)端,再啟動客戶端向服務(wù)端發(fā)送消息：
#客戶端發(fā)送消息請選擇聊天對象: 努力哥 請輸入消息,回車發(fā)送: 吃飯沒有 來自[127.0.0.1:8081]的一條消息:還沒吃呢 請輸入消息,回車發(fā)送: #服務(wù)端接收消息來自[127.0.0.1:62642]的一條消息:吃飯沒有 回復(fù)消息: 還沒吃呢?
補(bǔ)充知識：
1、tcp是可靠傳輸
tcp在數(shù)據(jù)傳輸時，發(fā)送端先把數(shù)據(jù)發(fā)送到自己的緩存中，然后協(xié)議控制將緩存中的數(shù)據(jù)發(fā)往對端，對端返回一個ack=1，發(fā)送端則清理緩存中的數(shù)據(jù)，對端返回ack=0，則重新發(fā)送數(shù)據(jù)，所以tcp是可靠的。
?
2、udp是不可靠傳輸
?udp發(fā)送數(shù)據(jù)，對端是不會返回確認(rèn)信息的，因此不可靠。
?
十一、解決粘包的辦法
法一：比較(LOW)版本
?示例：
low_socket_server服務(wù)端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nulige#low版解決粘包版本服務(wù)端 from socket import * import subprocess ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)while True:conn,addr=tcp_server.accept()print('新的客戶端鏈接',addr)while True:#收消息try:cmd=conn.recv(buffer_size)if not cmd:breakprint('收到客戶端的命令',cmd)#執(zhí)行命令，得到命令的運行結(jié)果cmd_resres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err=res.stderr.read()if err:cmd_res=errelse:cmd_res=res.stdout.read()#發(fā)送消息if not cmd_res:cmd_res='執(zhí)行成功'.encode('gbk')length=len(cmd_res) #計算長度conn.send(str(length).encode('utf-8')) #把長度發(fā)給客戶端client_ready=conn.recv(buffer_size) #卡著一個recvif client_ready == b'ready': #如果收到客戶端的ready消息，就說明準(zhǔn)備好了。conn.send(cmd_res) #就可以send給客戶端發(fā)送消息啦！except Exception as e:print(e)break View Code?
low_socket_client客戶端
執(zhí)行結(jié)果：
?View Code總結(jié)：
（為何low): ?程序的運行速度遠(yuǎn)快于網(wǎng)絡(luò)傳輸速度，所以在發(fā)送一段字節(jié)前，先用send去發(fā)送該字節(jié)流長度，這種方式會放大網(wǎng)絡(luò)延遲帶來的性能損耗。
?
法二：節(jié)省網(wǎng)絡(luò)傳輸版本（牛逼版本）
為字節(jié)流加上自定義固定長度報頭，報頭中包含字節(jié)流長度，然后一次send到對端，對端在接收時，先從緩存中取出定長的報頭，然后再取真實數(shù)據(jù)。
示例：(沒實現(xiàn)多客戶端并發(fā)）
?tcp_socket_server服務(wù)端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import subprocess import struct ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_server=socket(AF_INET,SOCK_STREAM) tcp_server.bind(ip_port) tcp_server.listen(back_log)while True:conn,addr=tcp_server.accept()print('新的客戶端鏈接',addr)while True:#收try:cmd=conn.recv(buffer_size)if not cmd:breakprint('收到客戶端的命令',cmd)#執(zhí)行命令，得到命令的運行結(jié)果cmd_resres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE,stdin=subprocess.PIPE)err=res.stderr.read()if err:cmd_res=errelse:cmd_res=res.stdout.read()#發(fā)if not cmd_res:cmd_res='執(zhí)行成功'.encode('gbk')length=len(cmd_res)data_length=struct.pack('i',length)conn.send(data_length)conn.send(cmd_res)except Exception as e:print(e)break View Code?
?tcp_socket_client客戶端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import struct from functools import partial ip_port=('127.0.0.1',8080) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)while True:cmd=input('>>: ').strip()if not cmd:continueif cmd == 'quit':breaktcp_client.send(cmd.encode('utf-8'))#解決粘包length_data=tcp_client.recv(4)length=struct.unpack('i',length_data)[0]recv_size=0recv_data=b''while recv_size < length:recv_data+=tcp_client.recv(buffer_size)recv_size=len(recv_data)print('命令的執(zhí)行結(jié)果是 ',recv_data.decode('gbk')) tcp_client.close() View Code?
執(zhí)行結(jié)果：
?View Code?
十二、用到的相關(guān)模塊知識講解
?1、subprocess模塊
subprocess 作用：啟動一個新的進(jìn)程并與之通信
?語法：
subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)
?參數(shù)：
Popen類： ? ?用Popen來創(chuàng)建進(jìn)程，并與進(jìn)程進(jìn)行復(fù)雜的交互
shell=True: ?指定的命令行會通過shell來執(zhí)行
stdin : ? 標(biāo)準(zhǔn)輸入
stdout : 標(biāo)準(zhǔn)輸出
stderr : ?標(biāo)準(zhǔn)錯誤的文件句柄
PIPE : ? ?管道 ,默認(rèn)值 為: None, 表示不做重定向，管道可以用來接收數(shù)據(jù)。
?
?示例1：執(zhí)行dir命令，就會交給shell解釋器執(zhí)行
import subprocess #導(dǎo)入模塊 命令： >>> subprocess.Popen("dir", shell=True) #執(zhí)行dir命令，交給shell解釋器執(zhí)行 執(zhí)行結(jié)果： <subprocess.Popen object at 0x00A7B950>Directory of C:\Python3.5 2016/11/21 14:14 <DIR> . 2016/11/21 14:14 <DIR> .. 2016/11/21 14:14 <DIR> DLLs 2016/11/21 14:14 <DIR> Doc 2016/11/21 14:14 <DIR> include 2016/11/21 14:14 <DIR> Lib 2016/11/21 14:14 <DIR> libs 2016/06/25 22:08 30,345 LICENSE.txt 2016/06/25 21:48 340,667 NEWS.txt 2016/06/25 22:02 39,576 python.exe 2016/06/25 22:02 51,864 python3.dll 2016/06/25 22:02 3,127,960 python35.dll 2016/06/25 22:02 39,576 pythonw.exe 2016/06/25 21:48 8,282 README.txt 2016/11/21 14:14 <DIR> Scripts 2016/11/21 14:14 <DIR> tcl 2016/11/21 14:14 <DIR> Tools 2016/03/17 22:48 85,840 vcruntime140.dll8 File(s) 3,724,110 bytes10 Dir(s) 211,565,547,520 bytes free View Code?
示例2：subprocess 把標(biāo)準(zhǔn)輸出放入管道中，屏幕上就不會輸出內(nèi)容
示例2：把標(biāo)準(zhǔn)輸出放入管道中，屏幕上就不會輸出內(nèi)容。 res=subprocess.Popen("dir", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE) #執(zhí)行dir命令，交給shell解釋器執(zhí)行，通過標(biāo)準(zhǔn)類型和subprocess.PIPE放入管道中。>>> res.stdout.read() #讀取管道里面的數(shù)據(jù)，在程序中，讀取也不會輸出到屏幕上。 執(zhí)行結(jié)果： b' Volume in drive C has no label.\r\n Volume Serial Number is 4C49-9FA8\r\n\r\n Directory of C:\\Python3.5\r\n\r\n2016/11/21 14:14 <DIR> .\r\n2016/11/21 14:14 <DIR> ..\r\n2016/11/21 14:14 <DIR> DLLs\r\n2016/11/21 14:14 <DIR> Doc\r\n2016/11/21 14:14 <DIR> include\r\n2016/11/21 14:14 <DIR> Lib\r\n2016/11/21 14:14 <DIR> libs\r\n2016/06/25 22:08 30,345 LICENSE.txt\r\n2016/06/25 21:48 340,667 NEWS.txt\r\n2016/06/25 22:02 39,576 python.exe\r\n2016/06/25 22:02 51,864 python3.dll\r\n2016/06/25 22:02 3,127,960 python35.dll\r\n2016/06/25 22:02 39,576 pythonw.exe\r\n2016/06/25 21:48 8,282 README.txt\r\n2016/11/21 14:14 <DIR> Scripts\r\n2016/11/21 14:14 <DIR> tcl\r\n2016/11/21 14:14 <DIR> Tools\r\n2016/03/17 22:48 85,840 vcruntime140.dll\r\n 8 File(s) 3,724,110 bytes\r\n 10 Dir(s) 211,560,914,944 bytes free\r\n'>>> res.stdout.read() #再read一次，內(nèi)容就為空，說明讀取完成啦！ b'' #顯示為：bytes類型 View Code?
?示例3：subprocess 執(zhí)行一個系統(tǒng)沒有的命令，就會產(chǎn)生正常的輸出
#執(zhí)行一個系統(tǒng)沒有的命令，就會產(chǎn)生正常的輸出>>> res=subprocess.Popen("sfsfdsfdsfs", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)>>> res.stdout.read() #讀取沒有內(nèi)容 b''>>> res.stderr.read() #有正常的輸出 b"'sfsfdsfdsfs' is not recognized as an internal or external command,\r\noperable program or batch file.\r\n" View Code?
?
2、struct模塊
struct模塊作用：解決bytes和其他二進(jìn)制數(shù)據(jù)類型的轉(zhuǎn)換
示例用法：
struct.pack('i',12)
參數(shù)說明：
pack函數(shù)作用：把任意數(shù)據(jù)類型變成bytes
i 表示4字節(jié)無符號整數(shù)。
示例1：
>>> import struct >>> struct.pack('i',12) #把后面的整形數(shù)據(jù)，封裝成一個bytes類型 b'\x0c\x00\x00\x00' #長度就是4>>> l=struct.pack('i',12313123) >>> len(l) 4 #長度就是4 View Code?
?示例2：
>>> struct.pack('i',1) b'\x01\x00\x00\x00'#反解 >>> struct.unpack('i',l) (12313123,)#查看類型 >>> l=struct.pack('i',1) >>> type(l) <class 'bytes'> #bytes類型 View Code?
?
Format Characters(格式化字符)：
| x | pad byte | no value | ? | ? |
| c | char | bytes of length 1 | 1 | ? |
| b | signed?char | integer | 1 | (1),(3) |
| B | unsigned?char | integer | 1 | (3) |
| ? | _Bool | bool | 1 | (1) |
| h | short | integer | 2 | (3) |
| H | unsigned?short | integer | 2 | (3) |
| i | int | integer | 4 | (3) |
| I | unsigned?int | integer | 4 | (3) |
| l | long | integer | 4 | (3) |
| L | unsigned?long | integer | 4 | (3) |
| q | long?long | integer | 8 | (2), (3) |
| Q | unsigned?long?long | integer | 8 | (2), (3) |
| n | ssize_t | integer | ? | (4) |
| N | size_t | integer | ? | (4) |
| e | (7) | float | 2 | (5) |
| f | float | float | 4 | (5) |
| d | double | float | 8 | (5) |
| s | char[] | bytes | ? | ? |
| p | char[] | bytes | ? | ? |
| P | void?* | integer | ? | (6) |
?
詳細(xì)用法參考：
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431955007656a66f831e208e4c189b8a9e9f3f25ba53000
官方文檔參考：(英文文檔）
https://docs.python.org/3/library/struct.html#format-characters
?
3、urandom模塊
作用：產(chǎn)生隨機(jī)數(shù)
>>> import os >>> os.urandom(32) #產(chǎn)生32位字節(jié)隨機(jī)數(shù) b'=\xbcC\xa3\xe0\xd5\x12\xe4CZ?\xd9Q{\x97\x89g7lvD\xd4\xed\xd8\xeau\xc1\x9c\xb6\xd8fR'?
示例：使用md5 + os.urandom(n) 產(chǎn)生隨機(jī)字符串
import os from hashlib import md5for i in range(5): #循環(huán)幾次就產(chǎn)生幾次隨機(jī)數(shù)print(md5(os.urandom(32)).hexdigest())執(zhí)行結(jié)果：
1fc70d335903283e1ac8165a28fbdddb 7a1305507f485e4d3c03f4e0c200ab6d 824db1b1076302f46166bbd93c41f0dd a350c246781d5a6139d18df267e50485 f38fb315a24e33d1703df81fe6b7a4e2?
十三、socket 實現(xiàn)并發(fā)
SocketServer是基于socket寫成的一個更強(qiáng)大的模塊。
SocketServer簡化了網(wǎng)絡(luò)服務(wù)器的編寫。它有4個類：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。這4個類是同步進(jìn)行處理的，另外通過ForkingMixIn和ThreadingMixIn類來支持異步。
?
在python3中該模塊是socketserver
在python2中該模塊是Socketserver
分情況導(dǎo)入導(dǎo)入模塊 try:import socketserver #Python 3 except ImportError:import SocketServer #Python 2服務(wù)器
服務(wù)器要使用處理程序，必須將其出入到服務(wù)器對象，定義了5個基本的服務(wù)器類型(就是“類”)。BaseServer，TCPServer，UnixStreamServer，UDPServer，UnixDatagramServer。注意：BaseServer不直接對外服務(wù)。
?
關(guān)系如下：
?服務(wù)器：
要使用處理程序，必須將其傳入到服務(wù)器的對象，定義了四個基本的服務(wù)器類。
（1）TCPServer(address,handler)?? 支持使用IPv4的TCP協(xié)議的服務(wù)器，address是一個（host,port）元組。Handler是BaseRequestHandler或StreamRequestHandler類的子類的實例。
（2）UDPServer(address,handler)?? 支持使用IPv4的UDP協(xié)議的服務(wù)器，address和handler與TCPServer中類似。
（3）UnixStreamServer(address,handler)?? 使用UNIX域套接字實現(xiàn)面向數(shù)據(jù)流協(xié)議的服務(wù)器，繼承自TCPServer。
（4）UnixDatagramServer(address,handler)? 使用UNIX域套接字實現(xiàn)數(shù)據(jù)報協(xié)議的服務(wù)器，繼承自UDPServer。
?
這四個類的實例都有以下方法。
1、s.socket?? 用于傳入請求的套接字對象。
2、s.sever_address? 監(jiān)聽服務(wù)器的地址。如元組（"127.0.0.1",80）
3、s.RequestHandlerClass ? 傳遞給服務(wù)器構(gòu)造函數(shù)并由用戶提供的請求處理程序類。
4、s.serve_forever() ?處理無限的請求 ?#無限處理client連接請求
5、s.shutdown() ? 停止serve_forever()循環(huán)
?
SocketServer模塊中主要的有以下幾個類：
1、BaseServer??? 包含服務(wù)器的核心功能與混合類（mix-in）的鉤子功能。這個類主要用于派生，不要直接生成這個類的類對象，可以考慮使用TCPServer和UDPServer類。
2、TCPServer ? ? 基本的網(wǎng)絡(luò)同步TCP服務(wù)器
3、UDPServer ? ? 基本的網(wǎng)絡(luò)同步UDP服務(wù)器
4、ForkingTCPServer?? ?是ForkingMixIn與TCPServer的組合
5、ForkingUDPServer 是ForkingMixIn與UDPServer的組合
6、ThreadingUDPServer 是ThreadingMixIn和UDPserver的組合
7、ThreadingTCPServer 是ThreadingMixIn和TCPserver的組合
8、BaseRequestHandler 必須創(chuàng)建一個請求處理類，它是BaseRequestHandler的子類并重載其handle()方法。
9、StreamRequestHandler ? ? ?實現(xiàn)TCP請求處理類的
10、DatagramRequestHandler 實現(xiàn)UDP請求處理類的
11、ThreadingMixIn 實現(xiàn)了核心的線程化功能，用于與服務(wù)器類進(jìn)行混合(mix-in)，以提供一些異步特性。不要直接生成這個類的對象。
12、ForkingMixIn ? 實現(xiàn)了核心的進(jìn)程化功能，用于與服務(wù)器類進(jìn)行混合(mix-in)，以提供一些異步特性。不要直接生成這個類的對象。
?
關(guān)系圖如下：
創(chuàng)建服務(wù)器的步驟：
1：首先必須創(chuàng)建一個請求處理類
2：它是BaseRequestHandler的子類
3：該請求處理類是BaseRequestHandler的子類并重新寫其handle()方法
?
實例化 ?請求處理類傳入服務(wù)器地址和請求處理程序類
最后實例化調(diào)用serve_forever() ?#無限處理client請求
?
記住一個原則：對tcp來說：self.request=conn
示例：
1、tcp_socket_server服務(wù)端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nulige#服務(wù)端已經(jīng)實現(xiàn)并發(fā)，處理客戶端請求import socketserverclass MyServer(socketserver.BaseRequestHandler): #基本的通信循環(huán)def handle(self):print('conn is: ',self.request) #與client的鏈接請求信息print('addr is: ',self.client_address) #獲取client的地址和端口號#通信循環(huán)while True:#收消息data=self.request.recv(1024)print('收到客戶端的消息是',data)#發(fā)消息 self.request.sendall(data.upper())if __name__ == '__main__':s=socketserver.ThreadingTCPServer(('127.0.0.1',8000),MyServer) #開啟多線程，綁定地址，和處理通信的類s.serve_forever() #連接循環(huán) View Code?
tcp_socket_client客戶端
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8000) back_log=5 buffer_size=1024tcp_client=socket(AF_INET,SOCK_STREAM) tcp_client.connect(ip_port)while True:msg=input('>>: ').strip()if not msg:continueif msg == 'quit':breaktcp_client.send(msg.encode('utf-8'))data=tcp_client.recv(buffer_size)print('收到服務(wù)端發(fā)來的消息: ',data.decode('utf-8'))tcp_client.close() View Code?
執(zhí)行結(jié)果：
開啟一個服務(wù)端程序，再開多個客戶端，向服務(wù)器發(fā)送命令：
#客戶端1 >>: hello #輸入要發(fā)送的消息 收到服務(wù)端發(fā)來的消息: HELLO#客戶端2 >>: word 收到服務(wù)端發(fā)來的消息: WORD#服務(wù)端 conn is: <socket.socket fd=412, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62813)> addr is: ('127.0.0.1', 62813) 收到客戶端的消息是 b'hello' #客戶端收到的消息 conn is: <socket.socket fd=256, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62816)> addr is: ('127.0.0.1', 62816) 收到客戶端的消息是 b'word' View Code?
?
2、udp實現(xiàn)并發(fā)
記住一個原則：對udp來說：self.request=(client_data_bytes,udp的套接字對象)
實例：
?udp_socket_server服務(wù)端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligeimport socketserverclass MyServer(socketserver.BaseRequestHandler):def handle(self):print(self.request)print('收到客戶端的消息是',self.request[0])self.request[1].sendto(self.request[0].upper(),self.client_address) #發(fā)送的是第1個消息，第2個地址if __name__ == '__main__':s=socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer) #多線程s.serve_forever() View Code?
udp_socket_client客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * ip_port=('127.0.0.1',8080) buffer_size=1024udp_client=socket(AF_INET,SOCK_DGRAM) #數(shù)據(jù)報while True:msg=input('>>: ').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)data,addr=udp_client.recvfrom(buffer_size)# print(data.decode('utf-8'))print(data) View Code?
執(zhí)行結(jié)果：
先啟動服務(wù)端，再開多個客戶端，向服務(wù)端發(fā)送消息。
#客戶端 >>: welcome #輸入要發(fā)送的消息 b'WELCOME'>>: hello b'HELLO' >>: #服務(wù)端 (b'welcome', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>) 收到客戶端的消息是 b'welcome' #服務(wù)端接收到的消息 (b'hello', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>) 收到客戶端的消息是 b'hello' View Code?
?
十四、認(rèn)證客戶端的鏈接合法性
如果你想在分布式系統(tǒng)中實現(xiàn)一個簡單的客戶端鏈接認(rèn)證功能，又不像SSL那么復(fù)雜，那么利用hmac+加鹽的方式來實現(xiàn)
tcp_socket_server服務(wù)端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import hmac,ossecret_key=b'linhaifeng bang bang bang' #加段代碼（加鹽） def conn_auth(conn):'''認(rèn)證客戶端鏈接:param conn::return:'''print('開始驗證新鏈接的合法性')msg=os.urandom(32)conn.sendall(msg)h=hmac.new(secret_key,msg)digest=h.digest()respone=conn.recv(len(digest))return hmac.compare_digest(respone,digest)def data_handler(conn,bufsize=1024):if not conn_auth(conn):print('該鏈接不合法,關(guān)閉')conn.close()returnprint('鏈接合法,開始通信')while True:data=conn.recv(bufsize)if not data:breakconn.sendall(data.upper())def server_handler(ip_port,bufsize,backlog=5):'''只處理鏈接:param ip_port::return:'''tcp_socket_server=socket(AF_INET,SOCK_STREAM)tcp_socket_server.bind(ip_port)tcp_socket_server.listen(backlog)while True:conn,addr=tcp_socket_server.accept()print('新連接[%s:%s]' %(addr[0],addr[1]))data_handler(conn,bufsize)if __name__ == '__main__':ip_port=('127.0.0.1',9999)bufsize=1024server_handler(ip_port,bufsize) View Code?
tcp_socket_client客戶端：
#!/usr/bin/env python # -*- coding:utf-8 -*- #Author: nuligefrom socket import * import hmac,ossecret_key=b'linhaifeng bang bang bang' #加鹽 def conn_auth(conn):'''驗證客戶端到服務(wù)器的鏈接:param conn::return:'''msg=conn.recv(32)h=hmac.new(secret_key,msg)digest=h.digest()conn.sendall(digest)def client_handler(ip_port,bufsize=1024):tcp_socket_client=socket(AF_INET,SOCK_STREAM)tcp_socket_client.connect(ip_port)conn_auth(tcp_socket_client)while True:data=input('>>: ').strip()if not data:continueif data == 'quit':breaktcp_socket_client.sendall(data.encode('utf-8'))respone=tcp_socket_client.recv(bufsize)print(respone.decode('utf-8'))tcp_socket_client.close()if __name__ == '__main__':ip_port=('127.0.0.1',9999)bufsize=1024client_handler(ip_port,bufsize) View Code?
轉(zhuǎn)載于:https://www.cnblogs.com/shuai1991/p/10588302.html
總結(jié)
以上是生活随笔為你收集整理的python网络编程-socket编程的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： [Swift]LeetCode1013.
- 下一篇： lightgbm 数据不平衡_不平衡数据