Python之路(第三十二篇) 网络编程:udp套接字、简单文件传输

一、UDP套接字

服务端

  # udp是无链接的,先启动哪一端都不会报错
# udp没有链接,与tcp相比没有链接循环,只有通讯循环
server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建一个服务器的套接字
server.bind() #绑定服务器套接字
inf_loop: #服务器无限循环
cs = server.recvfrom()/server.sendto() # 对话(接收与发送)
server.close() # 关闭服务器套接字

  

客户端

  
  client = socket()   # 创建客户套接字
comm_loop: # 通讯循环
client.sendto()/client.recvfrom() # 对话(发送/接收)
client.close() # 关闭客户套接字

  

简单例子

服务端

  import socket

ip_port = ('127.0.0.1',8081)
server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(ip_port)
while True:
print('udp服务端开始运行了')
data,addr = server.recvfrom(1024)
print(data.decode('utf-8'))
msg = input("请输入").strip()
server.sendto(msg.encode("utf-8"),addr)

  

客户端

  
  import socket

ip_port = ('127.0.0.1', 8081)
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
while True:
print('udp客户端开始运行了')
msg = input("请输入").strip()
server.sendto(msg.encode("utf-8"), ip_port)
data, addr = server.recvfrom(1024)
print(data.decode("utf-8"))

  

注意:udp 可以发空 数据报协议 说是发空,其实不是空 ,还有一个IP 端口的信息,发空时 带个端口信息,

tcp:不是一一对应的,udp:是一一对应的 数据报完整的

用upd做一个ntp时间服务器

服务端

  
  import socket
import time

ip_port = ("127.0.0.1",8080)
buffer_size = 1024
ntp_server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
ntp_server.bind(ip_port)

while True:
data,addr = ntp_server.recvfrom(buffer_size)
print("收到客户端的命令是",data.decode("utf-8"))
if not data:
fmt = "%Y-%m-%d %X"
else:
fmt = data.decode("utf-8")
time_now = time.strftime(fmt,time.localtime())
ntp_server.sendto(time_now.encode("utf-8"),addr)

  

客户端

  
  import socket

ip_port = ("127.0.0.1",8080)
buffer_size = 1024
ntp_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

while True:
msg = input(">>>")
ntp_client.sendto(msg.encode("utf-8"),ip_port)
recv_msg,addr = ntp_client.recvfrom(buffer_size)
print(recv_msg.decode("utf-8"))

  

基于udp简单实现QQ聊天

服务端

  from socket import *
udp_server= socket(AF_INET,SOCK_DGRAM)
udp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
udp_server.bind(('127.0.0.1',8080))
print('start running...')

while True:
qq_msg,addr = udp_server.recvfrom(1024)
print('来自[%s:%s]的一条消息:\033[44m%s\033[0m'%(addr[0],addr[1],qq_msg.decode('utf-8')))
back_msg = input('回复消息:>>').strip()
udp_server.sendto(back_msg.encode('utf-8'),addr)
udp_server.close()

  

客户端

  
  from socket import *
udp_client = socket(AF_INET,SOCK_DGRAM)
qq_name_dic = {
'pony':('127.0.0.1',8080),
'jack':('127.0.0.1',8080),
'charles':('127.0.0.1',8080),
'nick':('127.0.0.1',8080)
}
while True:
print("QQ名单列表:")
for i in qq_name_dic.keys():
print(i)
qq_name = input('请输入聊天对象:>>').strip()
if qq_name not in qq_name_dic: continue
while True:
msg = input('请输入消息,回车发送:').strip()
if msg=='quit':break
if not msg or not qq_name or qq_name not in qq_name_dic:continue
udp_client.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])
back_msg,addr = udp_client.recvfrom(1024)
print('来自[%s:%s]的一条消息:\033[41m%s\033[0m'%(addr[0],addr[1],back_msg.decode('utf-8')))
udp_client.close()

  

二、tcp与udp对比

tcp基于链接通信,数据流式协议

  • 基于链接,则需要listen(backlog),指定连接池的大小

  • 基于链接,必须先运行的服务端,然后客户端发起链接请求

  • 对于mac/linux系统:如果客户端断开了链接,那服务端的链接recv将会阻塞,通讯循环收到的是一直空(解决方法是:服务端在收消息后加上if判断,空消息就break掉通信循环)

  • 对于windows系统:如果一端断开了链接,那另外一端的链接也跟着出错,(解决方法是:服务端通信循环内加异常处理,捕捉到异常后就break掉通讯循环)

  • 相对于upd传输速度慢

  • 流式协议 会粘包 不可以发空 send recv 不是 一 一对应

  • tcp适用于:

    • 数据一定要可靠

    • 远程执行命令

    • 下载文件

udp无链接,数据报式协议

  • 无链接,因而无需listen(backlog),更加没有什么链接池

  • 无链接,udp的sendto不用管是否有一个正在运行的服务端可以一直发消息,只不过数据可能会丢失

  • recvfrom收的数据小于sendto发送的数据时,在mac和linux系统上数据直接丢失,在windows系统上发送的比接收的大直接报错

  • 只有sendto发送数据没有recvfrom收数据,数据丢失

  • 数据报协议 不会粘包 可以发空 sendto recvfrom 一 一 对应 数据报协议 数据不安全 有可能发送数据 > 1024 或者网络网络异常 数据没了

  • udp适用于

    • QQ

    • 查询操作 eg: ntp时间服务器 dns服务器(查域名,转ip) 能保证查询效率高,数据虽然不可靠,传输过程中可能会发生数据丢失

三、基于socket实现文件网络传输

简单版本

服务端

  
  import socket
import os
import hashlib
import json
import struct

ip_port = ("127.0.0.1",9001)
back_log = 5
buffer_size = 1024
base_path = os.path.dirname(os.path.abspath(__file__))
share_path =os.path.join(base_path,"share")

ftp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ftp_server.bind(ip_port)
ftp_server.listen(back_log)

def creat_md5(file):
md5_value = hashlib.md5()
with open(file,"rb") as f:
while True:
data = f.read(1024)
if not data:
break
md5_value.update(data)
return md5_value.hexdigest()


while True:
print("FTP服务器开始运行啦!")
conn,address = ftp_server.accept()
while True:
try:
# 第一步:收命令
res = conn.recv(8096) #"get a.txt"
if not res: continue
# 第二步:解析命令, 提取相应的命令参数
cmds = res.decode("utf-8").split()
file_name = cmds[1]
if cmds[0] == "get":

file_path = os.path.join(share_path,file_name)
file_md5 = creat_md5(file_path)
file_size = os.path.getsize(file_path)
#第三步:以读的方式打开文件,读取文件内容 发送给客户端,
# 1、先自制报头,传递文件的相关信息
header_dic = {
"filename":file_name,
"filemd5":file_md5,
"filesize":file_size
}
header_json = json.dumps(header_dic).encode("utf-8")
header_length = len(header_json)
header_struct = struct.pack("i",header_length)
# 2、发送报头的长度
conn.send(header_struct)
# 3、发送报头,传递文件的各种信息
conn.send(header_json)
# 4、打开文件,读取内容,一行一行的发送读取的内容给客户端
with open(file_path,"rb") as f:
for line in f:
conn.send(line)

except Exception as e:
print(e)
break
conn.close()

  

客户端

  
  import socket
import os
import struct
import json
import time

ip_port = ("127.0.0.1", 9001)
buffer_size = 1024
base_path = os.path.dirname(os.path.abspath(__file__))
download_path = os.path.join(base_path,"download")

ftp_client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ftp_client.connect(ip_port)

while True:
# 第一步:写命令,发送命令给服务端
cmd = input("请输入命令: ")
if not cmd: continue
if cmd == "quit": break
ftp_client.send(cmd.encode("utf-8"))
# 第二步:收取自制报头的长度
header_struct = ftp_client.recv(4)
header_length = struct.unpack("i", header_struct)[0]
print("报头长度",header_length)
# 第三步:收取自制报头的信息
header_json = ftp_client.recv(header_length).decode("utf-8")
header_dic = json.loads(header_json)
print("报头字典",header_dic)
# 第四步:根据报头信息拼出文件的各种信息
file_name = header_dic["filename"]
file_md5 = header_dic["filemd5"]
file_size = header_dic["filesize"]
file_download_path = os.path.join(download_path,file_name)
# 第五步:以写的方式打开一个新文件,接收服务端发来的文件内容写入客户的新文件
with open(file_download_path,"wb") as f:
data_size = 0
start_time = time.perf_counter()
while data_size < file_size:
line = ftp_client.recv(buffer_size)
f.write(line)
data_size = data_size + len(line)
# print("已经写入数据",data_size)
download_percent = int((data_size/file_size)*100)
# print("百分比",download_percent)
a = "*" * download_percent
# print(a)
b = "." * (100 - download_percent)
# print(b)
c = (data_size/file_size)*100
during_time = time.perf_counter() - start_time
print("\r{:3.0f}%[{}-{}]共计用时:{:.3f}s".format(c,a,b,during_time),end="")
# sys.stdout.flush()
print("\n" + "执行结束")
ftp_client.close()

  

基于类写的文件传输

服务端

  
  import socket
import os
import struct
import pickle


class TCPServer:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
listen_count = 5
max_recv_bytes = 8192
coding = 'utf-8'
allow_reuse_address = False
# 下载的文件存放路径
down_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'share')
# 上传的文件存放路径
upload_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'upload')

def __init__(self,server_address,bind_and_listen=True):
self.server_address = server_address
self.socket = socket.socket(self.address_family,self.socket_type)

if bind_and_listen:
try:
self.server_bind()
self.server_listen()
except Exception:
self.server_close()

def server_bind(self):
if self.allow_reuse_address: #重用ip和端口
self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
self.socket.bind(self.server_address)

def server_listen(self):
self.socket.listen(self.listen_count)

def server_close(self):
self.socket.close()

def server_accept(self):
return self.socket.accept()

def conn_close(self,conn):
conn.close()

def run(self):
print('starting...')
while True:
self.conn,self.client_addr = self.server_accept()
print(self.client_addr)
while True:
try:
res = self.conn.recv(self.max_recv_bytes)
if not res:continue
cmds = res.decode(self.coding).split()
if hasattr(self,cmds[0]):
func = getattr(self,cmds[0])
func(cmds)
except Exception:
break
self.conn_close(self.conn)

def get(self,cmds):
""" 下载
1.找到下载的文件
2.发送 header_size
3.发送 header_bytes file_size
4.读文件 rb 发送 send(line)
5.若文件不存在,发送0 client提示:文件不存在
:param cmds: 下载的文件 eg:['get','a.txt']
:return:
"""
filename = cmds[1]
file_path = os.path.join(self.down_filepath, filename)
if os.path.isfile(file_path):
header = {
'filename': filename,
'md5': 'xxxxxx',
'file_size': os.path.getsize(file_path)
}
header_bytes = pickle.dumps(header) #直接用pickle转为bytes,不用json+encode转为bytes
self.conn.send(struct.pack('i', len(header_bytes)))
self.conn.send(header_bytes)
with open(file_path, 'rb') as f:
for line in f:
self.conn.send(line)
else:
self.conn.send(struct.pack('i', 0))

def put(self,cmds):
""" 上传
1.接收4个bytes 得到文件的 header_size
2.根据 header_size 得到 header_bytes header_dic
3.根据 header_dic 得到 file_size
3.以写的形式 打开文件 f.write()
:param cmds: 下载的文件 eg:['put','a.txt']
:return:
"""
obj = self.conn.recv(4)
header_size = struct.unpack('i', obj)[0]
header_bytes = self.conn.recv(header_size)
header_dic = pickle.loads(header_bytes)
print(header_dic)
file_size = header_dic['file_size']
filename = header_dic['filename']

with open('%s/%s' % (self.upload_filepath, filename), 'wb') as f:
recv_size = 0
while recv_size < file_size:
res = self.conn.recv(self.max_recv_bytes)
f.write(res)
recv_size += len(res)


tcp_server = TCPServer(('127.0.0.1',8080))
tcp_server.run()
tcp_server.server_close()

  

客户端

import socket
import struct
import pickle
import os class FTPClient:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
# 下载的文件存放路径
down_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'download')
# 上传的文件存放路径
upload_filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'share')
coding = 'utf-8'
max_recv_bytes = 8192 def __init__(self, server_address, connect=True):
self.server_address = server_address
self.socket = socket.socket(self.address_family, self.socket_type)
if connect:
try:
self.client_connect()
except Exception:
self.client_close() def client_connect(self):
self.socket.connect(self.server_address) def client_close(self):
self.socket.close() def run(self):
while True:
# get a.txt 下载 put a.txt 上传
msg = input(">>>:").strip()
if not msg: continue
self.socket.send(msg.encode(self.coding))
cmds = msg.split()
if hasattr(self,cmds[0]):
func = getattr(self,cmds[0])
func(cmds) def get(self, cmds):
""" 下载
1.得到 header_size
2.得到 header_types header_dic
3.得到 file_size file_name
4.以写的形式 打开文件
:param cmds: 下载的内容 eg: cmds = ['get','a.txt']
:return:
"""
obj = self.socket.recv(4)
header_size = struct.unpack('i', obj)[0]
if header_size == 0:
print('文件不存在')
else:
header_types = self.socket.recv(header_size)
header_dic = pickle.loads(header_types)
print(header_dic)
file_size = header_dic['file_size']
filename = header_dic['filename'] with open('%s/%s' % (self.down_filepath, filename), 'wb') as f:
recv_size = 0
while recv_size < file_size:
res = self.socket.recv(self.max_recv_bytes)
f.write(res)
recv_size += len(res)
print('总大小:%s 已下载:%s' % (file_size, recv_size))
else:
print('下载成功!') def put(self, cmds):
""" 上传
1.查看上传的文件是否存在
2.上传文件 header_size
3.上传文件 header_bytes
4.以读的形式 打开文件 send(line)
:param cmds: 上传的内容 eg: cmds = ['put','a.txt']
:return:
"""
filename = cmds[1]
file_path = os.path.join(self.upload_filepath, filename)
if os.path.isfile(file_path):
file_size = os.path.getsize(file_path)
header = {
'filename': os.path.basename(filename),
'md5': 'xxxxxx',
'file_size': file_size
}
header_bytes = pickle.dumps(header)
self.socket.send(struct.pack('i', len(header_bytes)))
self.socket.send(header_bytes) with open(file_path, 'rb') as f:
send_bytes = b''
for line in f:
self.socket.send(line)
send_bytes += line
print('总大小:%s 已上传:%s' % (file_size, len(send_bytes)))
else:
print('上传成功!')
else:
print('文件不存在') ftp_client = FTPClient(('127.0.0.1',8080))
ftp_client.run()
ftp_client.client_close()

  

上一篇:winform展示Unity3D文件(支持动态改变文件路径)


下一篇:python 第六天