3.初識Socket-UDP編程
server端：

import socket

sk = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
sk.bind(("127.0.0.1", 8089))
msg, address = sk.recvfrom(1024)
print(msg)
sk.sendto(b'hi', address)

client端：

import socket

sk = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)

sk.sendto(b'hello', ("127.0.0.1", 8089))
msg, address = sk.recvfrom(1024)
print(msg)

跟TCP編程原理差不多，只是UDP不用長時間建立連接，發(fā)送一個包，不用等回復，也不需要理會對方收到還是沒收到，沒有嚴格意義上的服務端和客戶端

4.黏包現(xiàn)象
在使用TCP協(xié)議進行數(shù)據(jù)傳輸?shù)臅r候, 會有以下問題出現(xiàn).
client端：

import socket

sk = socket.socket()  # 創(chuàng)建通道
print("客戶端初始化完成")
sk.connect(("127.0.0.1", 8088))  # 建立連接
print("客戶端連接成功")

sk.send("哈哈".encode("utf-8"))
sk.send("哈哈".encode("utf-8")) #發(fā)送兩次
print("發(fā)送完畢")
sk.close()

server端：

import socket

# 創(chuàng)建socket通道
sk = socket.socket()
sk.bind(("127.0.0.1", 8088))  # 綁定ip和端口
sk.listen()  # 開始監(jiān)聽
print("服務器就緒，等待連接")
conn, address = sk.accept()  # 程序阻塞，等待連接
print("有客戶端連接，ip是：", address)  # address是客戶端的ip和端口

msg1 = conn.recv(1024)
print(msg1.decode("utf-8"))
msg2 = conn.recv(1024)
print(msg2.decode("utf-8"))
sk.close()

server端收到的內(nèi)容：

可以看到，兩次發(fā)送的內(nèi)容，黏在一起，變成了一個包，就是典型的黏包現(xiàn)象。
那么如何解決黏包問題呢? 很簡單. 之所以出現(xiàn)黏包就是因為數(shù)據(jù)沒有邊界. 直接把兩個包混合成了一個包. 那么我可以在發(fā)送數(shù)據(jù)的時候. 指定邊界. 告訴對方. 我接下來這個數(shù)據(jù)包有多大. 對面接收數(shù)據(jù)的時候呢, 先讀取該數(shù)據(jù)包的大小.然后再讀取數(shù)據(jù). 就不會產(chǎn)生黏包了.
普通話: 發(fā)送數(shù)據(jù)的時候制定數(shù)據(jù)的格式: 長度+數(shù)據(jù) 接收的時候就知道有多少是當前這個數(shù)據(jù)包的大小了. 也就相當于定義了分隔邊界了.
展示一波操作：
client端：

import socket

sk = socket.socket()  # 創(chuàng)建通道
print("客戶端初始化完成")
sk.connect(("127.0.0.1", 8088))  # 建立連接
print("客戶端連接成功")

s = "哈哈"
bs = sk.send(s.encode("utf-8"))
# 計算數(shù)據(jù)長度.格式化成四位數(shù)字
bs_len = format(len(bs), "04d").encode("utf-8")
# 發(fā)送數(shù)據(jù)之前，先發(fā)送數(shù)據(jù)的長度
sk.send(bs_len)
sk.send(bs)

# 發(fā)送第二次
sk.send(bs_len)
sk.send(bs)

print("發(fā)送完畢")
sk.close()

server端：

import socket

# 創(chuàng)建socket通道
sk = socket.socket()
sk.bind(("127.0.0.1", 8088))  # 綁定ip和端口
sk.listen()  # 開始監(jiān)聽
print("服務器就緒，等待連接")
conn, address = sk.accept()  # 程序阻塞，等待連接
print("有客戶端連接，ip是：", address)  # address是客戶端的ip和端口

# 接收數(shù)據(jù)長度4個字節(jié)，轉(zhuǎn)化成數(shù)字
bs_len = int(conn.recv(4).decode("utf-8"))
# 讀取數(shù)據(jù)
msg1 = conn.recv(1024)
print(msg1.decode("utf-8"))
# 再接收數(shù)據(jù)長度，讀取數(shù)據(jù)
bs_len = int(conn.recv(4).decode("utf-8"))
msg2 = conn.recv(1024)
print(msg2.decode("utf-8"))
sk.close()

但是，你應該發(fā)現(xiàn)了，這種傳輸?shù)姆绞诫m然能解決黏包問題，但是每次接收都要先定義接收的長度，喵的豈不是太累了？？這個問題，python也有自己的態(tài)度，代碼堅決要給你搞簡單，就引入了一個新的模塊struct，這是重點，拿小本本記下來，要考??！
展示一下struct的用法：

import struct

ret = struct.pack("i", 123456789)  # 把數(shù)字打包成字節(jié)
print(ret)

print(len(ret))  # 4  不論數(shù)字大小，定死了4個字節(jié)

# 把字節(jié)還原回數(shù)字
ds = b'\x15\xcd[\x07'
num = struct.unpack("i", ds)[0]   # num返回的是一個元祖，取索引為0的元素，也就是第一個元素，就是我們傳輸?shù)臄?shù)字
print(num)   # 123456789

好的，回歸到黏包的問題上來，論如何優(yōu)雅的解決黏包的問題：
client端：

import socket
import struct

sk = socket.socket()  # 創(chuàng)建通道
print("客戶端初始化完成")
sk.connect(("127.0.0.1", 8088))  # 建立連接
print("客戶端連接成功")

msg_bs = "你好呀".encode("utf-8")
msg_struct_len = struct.pack("i", len(msg_bs))
sk.send(msg_struct_len)
sk.send(msg_bs)
print("發(fā)送完畢")
# 發(fā)送第二次
sk.send(msg_struct_len)
sk.send(msg_bs)
print("發(fā)送完畢")

sk.close()

server端：

import socket
import struct

# 創(chuàng)建socket通道
sk = socket.socket()
sk.bind(("127.0.0.1", 8088))  # 綁定ip和端口
sk.listen()  # 開始監(jiān)聽
print("服務器就緒，等待連接")
conn, address = sk.accept()  # 程序阻塞，等待連接
print("有客戶端連接，ip是：", address)  # address是客戶端的ip和端口

msg_struct_len = conn.recv(4)
msg_len = struct.unpack("i", msg_struct_len)[0]
data = conn.recv(msg_len)
print(data.decode("utf-8"))
print("接收完畢")
# 接收第二個包
msg_struct_len = conn.recv(4)
msg_len = struct.unpack("i", msg_struct_len)[0]
data = conn.recv(msg_len)
print(data.decode("utf-8"))
print("接收完畢")

sk.close()

但是吧，這樣也是稍顯繁瑣了，如果多次使用，也可將用到的struct模塊，封裝起來，需要用到的時候，就導入這個自定義的模塊：
封裝的模塊my_struct_util.py：

import struct

def my_send(sk, msg):
    msg_len = msg.encode("utf-8")
    msg_struct_len = struct.pack("i", len(msg_len))
    sk.send(msg_struct_len)
    sk.send(msg_len)

def my_recv(sk):
    msg_struct_len = sk.recv(4)
    msg_len = struct.unpack("i", msg_struct_len)[0]
    data = sk.recv(msg_len)
    print(data.decode("utf-8"))

client端：

import socket
import my_socket_util as msu

sk = socket.socket()  # 創(chuàng)建通道
print("客戶端初始化完成")
sk.connect(("127.0.0.1", 8088))  # 建立連接
print("客戶端連接成功")
msu.my_send(sk, "你好嗎")
msu.my_send(sk, "你好嗎")

sk.close()

server端：

import socket
import my_socket_util as msu

# 創(chuàng)建socket通道
sk = socket.socket()
sk.bind(("127.0.0.1", 8088))  # 綁定ip和端口
sk.listen()  # 開始監(jiān)聽
print("服務器就緒，等待連接")
conn, address = sk.accept()  # 程序阻塞，等待連接
print("有客戶端連接，ip是：", address)  # address是客戶端的ip和端口

msu.my_recv(conn)
msu.my_recv(conn)
sk.close()

這樣，是不是就簡便了很多呢~~