大家好我是J哥，今天學習網絡編程，什么是網絡編程呢？

一.楔子

你現在已經學會了寫python代碼，假如你寫了兩個python文件a.py和b.py，分別去運行，你就會發現，這兩個python的文件分別運行的很好。但是如果這兩個程序之間想要傳遞一個數據，你要怎么做呢？

這個問題以你現在的知識就可以解決了，我們可以創建一個文件，把a.py想要傳遞的內容寫到文件中，然后b.py從這個文件中讀取內容就可以了

但是當你的a.py和b.py分別在不同電腦上的時候，你要怎么辦呢？

類似的機制有計算機網盤，qq等等。我們可以在我們的電腦上和別人聊天，可以在自己的電腦上向網盤中上傳、下載內容。這些都是兩個程序在通信。

二.軟件開發的架構

我們了解的涉及到兩個程序之間通訊的應用大致可以分為兩種：

第一種是應用類：qq、微信、網盤、優酷這一類是屬于需要安裝的桌面應用

第二種是web類：比如百度、知乎、博客園等使用瀏覽器訪問就可以直接使用的應用

這些應用的本質其實都是兩個程序之間的通訊。而這兩個分類又對應了兩個軟件開發的架構～

1.C/S架構

C/S即：Client與Server ，中文意思：客戶端與服務器端架構，這種架構也是從用戶層面（也可以是物理層面）來劃分的。

這里的客戶端一般泛指客戶端應用程序EXE，程序需要先安裝后，才能運行在用戶的電腦上，對用戶的電腦操作系統環境依賴較大。

2.B/S架構

B/S即：Browser與Server,中文意思：瀏覽器端與服務器端架構，這種架構是從用戶層面來劃分的。

Browser瀏覽器，其實也是一種Client客戶端，只是這個客戶端不需要大家去安裝什么應用程序，只需在瀏覽器上通過HTTP請求服務器端相關的資源（網頁資源），客戶端Browser瀏覽器就能進行增刪改查。

三.網絡基礎

計算機網絡 - Eva_J - 博客園

1.一個程序如何在網絡上找到另一個程序？

首先，程序必須要啟動，其次，必須有這臺機器的地址，我們都知道我們人的地址大概就是國家\省\市\區\街道\樓\門牌號這樣字。那么每一臺聯網的機器在網絡上也有自己的地址，它的地址是怎么表示的呢？

就是使用一串數字來表示的，例如：127.4.5.6

什么是IP？

IP地址是指互聯網協議地址（英語：Internet Protocol Address，又譯為網際協議地址），是IP Address的縮寫。IP地址是IP協議提供的一種統一的地址格式，它為互聯網上的每一個網絡和每一臺主機分配一個邏輯地址，以此來屏蔽物理地址的差異。IP地址是一個32位的二進制數，通常被分割為4個“8位二進制數”（也就是4個字節）。IP地址通常用“點分十進制”表示成（a.b.c.d）的形式，其中，a,b,c,d都是0~255之間的十進制整數。例：點分十進IP地址（100.4.5.6），實際上是32位二進制數（01100100.00000100.00000101.00000110）。

什么是端口？

"端口"是英文port的意譯，可以認為是設備與外界通訊交流的出口。

在windows上如何查看端口占用的情況？

netstat -aon|findstr "49157" ipconfig tasklist

因此ip地址精確到具體的一臺電腦，而端口精確到具體的程序。

2.osi七層模型

引子

須知一個完整的計算機系統是由硬件、操作系統、應用軟件三者組成,具備了這三個條件，一臺計算機系統就可以自己跟自己玩了（打個單機游戲，玩個掃雷啥的）

如果你要跟別人一起玩，那你就需要上網了，什么是互聯網？

互聯網的核心就是由一堆協議組成，協議就是標準，比如全世界人通信的標準是英語，如果把計算機比作人，互聯網協議就是計算機界的英語。所有的計算機都學會了互聯網協議，那所有的計算機都就可以按照統一的標準去收發信息從而完成通信了。

osi七層模型

人們按照分工不同把互聯網協議從邏輯上劃分了層級：

3.socket概念

socket層

理解socket

Socket是應用層與TCP/IP協議族通信的中間軟件抽象層，它是一組接口。在設計模式中，Socket其實就是一個門面模式，它把復雜的TCP/IP協議族隱藏在Socket接口后面，對用戶來說，一組簡單的接口就是全部，讓Socket去組織數據，以符合指定的協議。

其實站在你的角度上看，socket就是一個模塊。我們通過調用模塊中已經實現的方法建立兩個進程之間的連接和通信。 也有人將socket說成ip+port，因為ip是用來標識互聯網中的一臺主機的位置，而port是用來標識這臺機器上的一個應用程序。 所以我們只要確立了ip和port就能找到一個應用程序，并且使用socket模塊來與之通信。

3.套接字（socket）的發展史

套接字起源于 20 世紀 70 年代加利福尼亞大學伯克利分校版本的 Unix,即人們所說的 BSD Unix。 因此,有時人們也把套接字稱為“伯克利套接字”或“BSD 套接字”。一開始,套接字被設計用在同 一臺主機上多個應用程序之間的通訊。這也被稱進程間通訊,或 IPC。套接字有兩種（或者稱為有兩個種族）,分別是基于文件型的和基于網絡型的。?

基于文件類型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字調用的就是底層的文件系統來取數據，兩個套接字進程運行在同一機器，可以通過訪問同一個文件系統間接完成通信

基于網絡類型的套接字家族

套接字家族的名字：AF_INET

(還有AF_INET6被用于ipv6，還有一些其他的地址家族，不過，他們要么是只用于某個平臺，要么就是已經被廢棄，或者是很少被使用，或者是根本沒有實現，所有地址家族中，AF_INET是使用最廣泛的一個，python支持很多種地址家族，但是由于我們只關心網絡編程，所以大部分時候我么只使用AF_INET)

4.tcp協議和udp協議

TCP（Transmission Control Protocol）可靠的、面向連接的協議（eg:打電話）、傳輸效率低全雙工通信（發送緩存&接收緩存）、面向字節流。使用TCP的應用：Web瀏覽器；電子郵件、文件傳輸程序。

UDP（User Datagram Protocol）不可靠的、無連接的服務，傳輸效率高（發送前時延小），一對一、一對多、多對一、多對多、面向報文，盡最大努力服務，無擁塞控制。使用UDP的應用：域名系統?(DNS)；視頻流；IP語音(VoIP)。

我知道說這些你們也不懂，直接上圖。

四.套接字（socket）初使用

基于TCP協議的socket

tcp是基于鏈接的，必須先啟動服務端，然后再啟動客戶端去鏈接服務端

server端

import socket sk = socket.socket() sk.bind(('127.0.0.1',8898)) #把地址綁定到套接字 sk.listen() #監聽鏈接 conn,addr = sk.accept() #接受客戶端鏈接 ret = conn.recv(1024) #接收客戶端信息 print(ret) #打印客戶端信息 conn.send(b'hi') #向客戶端發送信息 conn.close() #關閉客戶端套接字 sk.close() #關閉服務器套接字(可選)

client端

import socket sk = socket.socket() # 創建客戶套接字 sk.connect(('127.0.0.1',8898)) # 嘗試連接服務器 sk.send(b'hello!') ret = sk.recv(1024) # 對話(發送/接收) print(ret) sk.close() # 關閉客戶套接字

問題：有的小白在重啟服務端時可能會遇到

解決方法：

#加入一條socket配置，重用ip和端口 import socket from socket import SOL_SOCKET,SO_REUSEADDR sk = socket.socket() sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加 sk.bind(('127.0.0.1',8898)) #把地址綁定到套接字 sk.listen() #監聽鏈接 conn,addr = sk.accept() #接受客戶端鏈接 ret = conn.recv(1024) #接收客戶端信息 print(ret) #打印客戶端信息 conn.send(b'hi') #向客戶端發送信息 conn.close() #關閉客戶端套接字 sk.close() #關閉服務器套接字(可選)

基于UDP協議的socket

udp是無鏈接的，啟動服務之后可以直接接受消息，不需要提前建立鏈接

簡單使用

server端

import socket udp_sk = socket.socket(type=socket.SOCK_DGRAM) #創建一個服務器的套接字 udp_sk.bind(('127.0.0.1',8080)) #綁定服務器套接字 msg,addr = udp_sk.recvfrom(1024) print(msg) udp_sk.sendto(b'hi',addr) # 對話(接收與發送) udp_sk.close() # 關閉服務器套接字

client端

import socket ip_port=('127.0.0.1',8080) udp_sk=socket.socket(type=socket.SOCK_DGRAM) udp_sk.sendto(b'hello',ip_port) back_msg,addr=udp_sk.recvfrom(1024) print(back_msg.decode('utf-8'),addr)

帶兩個例子：

?qq聊天

server端

#_*_coding:utf-8_*_ import 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('回復消息: ').strip()udp_server_sock.sendto(back_msg.encode('utf-8'),addr)server

client端

#_*_coding:utf-8_*_ import socket BUFSIZE=1024 udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)qq_name_dic={'tom':('127.0.0.1',8081),'tony':('127.0.0.1',8081),'egg':('127.0.0.1',8081),'kk':('127.0.0.1',8081), }while True:qq_name=input('請選擇聊天對象: ').strip()while True:msg=input('請輸入消息,回車發送,輸入q結束和他的聊天: ').strip()if msg == 'q':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()client

五.黏包

黏包現象

讓我們基于tcp先制作一個遠程執行命令的程序（命令ls -l ; lllllll ; pwd）

res=subprocess.Popen(cmd.decode('utf-8'), shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)的結果的編碼是以當前所在的系統為準的，如果是windows，那么res.stdout.read()讀出的就是GBK編碼的，在接收端需要用GBK解碼且只能從管道里讀一次結果注意

同時執行多條命令之后，得到的結果很可能只有一部分，在執行其他命令的時候又接收到之前執行的另外一部分結果，這種顯現就是黏包。

基于tcp協議實現的黏包

tcp-server

#_*_coding:utf-8_*_ from socket import * import subprocessip_port=('127.0.0.1',8888) BUFSIZE=1024tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5)while True:conn,addr=tcp_socket_server.accept()print('客戶端',addr)while True:cmd=conn.recv(BUFSIZE)if len(cmd) == 0:breakres=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)stderr=res.stderr.read()stdout=res.stdout.read()conn.send(stderr)conn.send(stdout)tcp - server

tcp-client

#_*_coding:utf-8_*_ import socket BUFSIZE=1024 ip_port=('127.0.0.1',8888)s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port)while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaks.send(msg.encode('utf-8'))act_res=s.recv(BUFSIZE)print(act_res.decode('utf-8'),end='')tcp - client

基于udp協議實現的黏包

server

#_*_coding:utf-8_*_ from socket import * import subprocessip_port=('127.0.0.1',9000) bufsize=1024udp_server=socket(AF_INET,SOCK_DGRAM) udp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) udp_server.bind(ip_port)while True:#收消息cmd,addr=udp_server.recvfrom(bufsize)print('用戶命令----->',cmd)#邏輯處理res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stderr=subprocess.PIPE,stdin=subprocess.PIPE,stdout=subprocess.PIPE)stderr=res.stderr.read()stdout=res.stdout.read()#發消息udp_server.sendto(stderr,addr)udp_server.sendto(stdout,addr) udp_server.close()udp - server

client

from socket import * ip_port=('127.0.0.1',9000) bufsize=1024udp_client=socket(AF_INET,SOCK_DGRAM)while True:msg=input('>>: ').strip()udp_client.sendto(msg.encode('utf-8'),ip_port)err,addr=udp_client.recvfrom(bufsize)out,addr=udp_client.recvfrom(bufsize)if err:print('error : %s'%err.decode('utf-8'),end='')if out:print(out.decode('utf-8'), end='')udp - client

注意：只有TCP有粘包現象，UDP永遠不會粘包

UDP（user datagram protocol，用戶數據報協議）是無連接的，面向消息的，提供高效率服務。 不會使用塊的合并優化算法，, 由于UDP支持的是一對多的模式，所以接收端的skbuff(套接字緩沖區）采用了鏈式結構來記錄每一個到達的UDP包，在每個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對于接收端來說，就容易進行區分處理了。 即面向消息的通信是有消息保護邊界的。 對于空消息：tcp是基于數據流的，于是收發的消息不能為空，這就需要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，而udp是基于數據報的，即便是你輸入的是空內容（直接回車），也可以被發送，udp協議會幫你封裝上消息頭發送過去。 不可靠不黏包的udp協議：udp的recvfrom是阻塞的，一個recvfrom(x)必須對唯一一個sendinto(y),收完了x個字節的數據就算完成,若是y;x數據就丟失，這意味著udp根本不會粘包，但是會丟數據，不可靠。

補充說明:udp和tcp一次性發送長度的限制

用UDP協議發送時，用sendto函數最大能發送數據的長度為：65535- IP頭(20) – UDP頭(8)＝65507字節。用sendto函數發送數據時，如果發送數據長度大于該值，則函數會返回錯誤。（丟棄這個包，不進行發送） 用TCP協議發送時，由于TCP是數據流協議，因此不存在包大小的限制（暫不考慮緩沖區的大小），這是指在用send函數時，數據長度參數不受限制。而實際上，所指定的這段數據并不一定會一次性發送出去，如果這段數據比較長，會被分段發送，如果比較短，可能會等待和下一次數據一起發送。

總結

黏包現象只發生在tcp協議中：

1.從表面上看，黏包問題主要是因為發送方和接收方的緩存機制、tcp協議面向流通信的特點。

2.實際上，主要還是因為接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所造成的

黏包的解決方案

解決方案一

問題的根源在于，接收端不知道發送端將要傳送的字節流的長度，所以解決粘包的方法就是圍繞，如何讓發送端在發送數據前，把自己將要發送的字節流總大小讓接收端知曉，然后接收端來一個死循環接收完所有數據。

服務端

#_*_coding:utf-8_*_ import socket,subprocess ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)s.bind(ip_port) s.listen(5)while True:conn,addr=s.accept()print('客戶端',addr)while True:msg=conn.recv(1024)if not msg:breakres=subprocess.Popen(msg.decode('utf-8'),shell=True,\stdin=subprocess.PIPE,\stderr=subprocess.PIPE,\stdout=subprocess.PIPE)err=res.stderr.read()if err:ret=errelse:ret=res.stdout.read()data_length=len(ret)conn.send(str(data_length).encode('utf-8'))data=conn.recv(1024).decode('utf-8')if data == 'recv_ready':conn.sendall(ret)conn.close()服務端

客戶端

#_*_coding:utf-8_*_ import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080))while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaks.send(msg.encode('utf-8'))length=int(s.recv(1024).decode('utf-8'))s.send('recv_ready'.encode('utf-8'))send_size=0recv_size=0data=b''while recv_size < length:data+=s.recv(1024)recv_size+=len(data)print(data.decode('utf-8'))客戶端 存在的問題： 程序的運行速度遠快于網絡傳輸速度，所以在發送一段字節前，先用send去發送該字節流長度，這種方式會放大網絡延遲帶來的性能損耗

解決方案進階

剛剛的方法，問題在于我們我們在發送

我們可以借助一個模塊，這個模塊可以把要發送的數據長度轉換成固定長度的字節。這樣客戶端每次接收消息之前只要先接受這個固定長度字節的內容看一看接下來要接收的信息大小，那么最終接受的數據只要達到這個值就停止，就能剛好不多不少的接收完整的數據了。

struct模塊

該模塊可以把一個類型，如數字，轉成固定長度的bytes

>>> struct.pack('i',1111111111111) struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #這個是范圍

import json,struct #假設通過客戶端上傳1T:1073741824000的文件a.txt#為避免粘包,必須自定制報頭 header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T數據,文件路徑和md5值#為了該報頭能傳送,需要序列化并且轉為bytes head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并轉成bytes,用于傳輸#為了讓客戶端知道報頭的長度,用struck將報頭長度這個數字轉成固定長度:4個字節 head_len_bytes=struct.pack('i',len(head_bytes)) #這4個字節里只包含了一個數字,該數字是報頭的長度#客戶端開始發送 conn.send(head_len_bytes) #先發報頭的長度,4個bytes conn.send(head_bytes) #再發報頭的字節格式 conn.sendall(文件內容) #然后發真實內容的字節格式#服務端開始接收 head_len_bytes=s.recv(4) #先收報頭4個bytes,得到報頭長度的字節格式 x=struct.unpack('i',head_len_bytes)[0] #提取報頭的長度head_bytes=s.recv(x) #按照報頭長度x,收取報頭的bytes格式 header=json.loads(json.dumps(header)) #提取報頭#最后根據報頭的內容提取真實的數據,比如 real_data_len=s.recv(header['file_size']) s.recv(real_data_len)

借助struct模塊，我們知道長度數字可以被轉換成一個標準大小的4字節數字。因此可以利用這個特點來預先發送數據長度

服務端

import socket,struct,json import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加phone.bind(('127.0.0.1',8080))phone.listen(5)while True:conn,addr=phone.accept()while True:cmd=conn.recv(1024)if not cmd:breakprint('cmd: %s' %cmd)res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)err=res.stderr.read()print(err)if err:back_msg=errelse:back_msg=res.stdout.read()conn.send(struct.pack('i',len(back_msg))) #先發back_msg的長度conn.sendall(back_msg) #在發真實的內容conn.close()服務端（自定制報頭）

客戶端

#_*_coding:utf-8_*_ import socket,time,structs=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080))while True:msg=input('>>: ').strip()if len(msg) == 0:continueif msg == 'quit':breaks.send(msg.encode('utf-8'))l=s.recv(4)x=struct.unpack('i',l)[0]print(type(x),x)# print(struct.unpack('I',l))r_s=0data=b''while r_s < x:r_d=s.recv(1024)data+=r_dr_s+=len(r_d)# print(data.decode('utf-8'))print(data.decode('gbk')) #windows默認gbk編碼客戶端（自定制報頭）

我們還可以把報頭做成字典，字典里包含將要發送的真實數據的詳細信息，然后json序列化，然后用struck將序列化后的數據長度打包成4個字節（4個自己足夠用了）

服務端-復雜修改

import socket,struct,json import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加phone.bind(('127.0.0.1',8080))phone.listen(5)while True:conn,addr=phone.accept()while True:cmd=conn.recv(1024)if not cmd:breakprint('cmd: %s' %cmd)res=subprocess.Popen(cmd.decode('utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)err=res.stderr.read()print(err)if err:back_msg=errelse:back_msg=res.stdout.read()headers={'data_size':len(back_msg)}head_json=json.dumps(headers)head_json_bytes=bytes(head_json,encoding='utf-8')conn.send(struct.pack('i',len(head_json_bytes))) #先發報頭的長度conn.send(head_json_bytes) #再發報頭conn.sendall(back_msg) #在發真實的內容conn.close()服務端：定制稍微復雜一點的報頭

客戶端

from socket import * import struct,jsonip_port=('127.0.0.1',8080) client=socket(AF_INET,SOCK_STREAM) client.connect(ip_port)while True:cmd=input('>>: ')if not cmd:continueclient.send(bytes(cmd,encoding='utf-8'))head=client.recv(4)head_json_len=struct.unpack('i',head)[0]head_json=json.loads(client.recv(head_json_len).decode('utf-8'))data_len=head_json['data_size']recv_size=0recv_data=b''while recv_size < data_len:recv_data+=client.recv(1024)recv_size+=len(recv_data)print(recv_data.decode('utf-8'))#print(recv_data.decode('gbk')) #windows默認gbk編碼客戶端

六.socketserver

server端

import socketserver class Myserver(socketserver.BaseRequestHandler):def handle(self):self.data = self.request.recv(1024).strip()print("{} wrote:".format(self.client_address[0]))print(self.data)self.request.sendall(self.data.upper())if __name__ == "__main__":HOST, PORT = "127.0.0.1", 9999# 設置allow_reuse_address允許服務器重用地址socketserver.TCPServer.allow_reuse_address = True# 創建一個server, 將服務地址綁定到127.0.0.1:9999server = socketserver.TCPServer((HOST, PORT),Myserver)# 讓server永遠運行下去，除非強制停止程序server.serve_forever()server端

client

import socketHOST, PORT = "127.0.0.1", 9999 data = "hello"# 創建一個socket鏈接，SOCK_STREAM代表使用TCP協議 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:sock.connect((HOST, PORT)) # 鏈接到客戶端sock.sendall(bytes(data + "\n", "utf-8")) # 向服務端發送數據received = str(sock.recv(1024), "utf-8")# 從服務端接收數據print("Sent: {}".format(data)) print("Received: {}".format(received))client

看到這里就就下你的痕跡吧！算是對J哥最大的支持！

總結

以上是生活随笔為你收集整理的Python基础之网络编程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。