python全栈开发第三模块
第二章:网络编程
一、计算机基础与网络
1、一套完整的计算机系统:由三大部分组成:①应用软件 ②系统软件 ③计算机硬件 ###软件依赖系统,系统操作控制硬件###
2、网络课程目标:让大家写一个 C (client) S (server) 架构软件 (基于网络)
2.1、什么叫网络:网络是在同一通信区域内通过互联网协议(网络通讯标准),实现各个网络终端的互通互联,从而达到相互通讯传输数据
简单来讲:网络就是底层的物理连接介质加上互联网协议
2.2、互联网协议分为以下几种:
2.21、os七层协议:①应(应用层),②表(表示层),③会(会话层),④传(传输层),⑤网(网络层),⑥数(数据链层),⑦物(物理层)
2.22、五层协议:前三层(应、表、会)统称为应(应用层)、传(传输层)、网(网络层)、数(数据链层)、物(物理层)
二、五层协议详解
1、物理层:传输二进制数据
2、数据链层:主要任务是按照一定语言标准,把文件转换成指定格式的二进制,交给物理层
2.1 以太网(Ethernet)MAC 协议(网络中最常见的传输协议)
其中 MAC 协议中规定:
①:一组电信号,称之为组个数据报(或者叫数据帧)
②:一组数据报分为报头(head)和数据(data)两部分
③:报头固定长度为18个字节(前6个字节是原地址,后6个字节是目标地址)
④:规定计算机必须要有网卡,而网卡之上有独一无二的 MAC 地址以供上网使用
2.2 以太网协议的工作方式:
基于 MAC 地址的广播工作方式(吼的方式)完成数据的传递,而这种传递方式只局限于局域网
2.3 小结: 报头head = [原地址 + 目标地址] MAC 协议 = [head(报头) + data(数据)]
3、网络层:IP 协议
3.1 IP地址:和以太网协议相同,也是由报头(此处称IP头)与数据组成。
3.2 IP地址的Arp协议:Arp协议是用来解析IP地址,获得 MAC 地址
注意:以太网在接收数据后会把 IP头和数据打包成一个数据组再加上以太网的报头进行传输,
到达服务端后,也会以相反的方法解包,这样形成一个规则:用IP地址 + MAC地址就可找到全世界的每一台机
4、传输层:
传输层分为 TCP 和 UDP 两种基于端口的协议,一台机器上的端口有 [0——65535]个,每启动一个软件,都会对应范围内唯一的端口,
和上面两种网络协议一样,也有自己的数据头和数据组,如果是TCP端口的协议,则数据头以TCP 发送数据,
4.1 传输原理:
[客户端] [服务端]
[ftp+data]<———打包———[_应用层_]——>[自定义/HTTP/FTP协议]<——[_应用层_]———解包———>[ftp+data]
{tcp/udp+[ftp+data]}<———打包———[_传输层_]—————>【TCP/UCP协议】<—————[_传输层_]———解包———>{tcp/udp+[ftp+data]}
{IP+{tcp/udp+[ftp+data]}}<———打包———[_网络层_]——————>【IP 协议 】<———————[_网络层_]———解包———>{IP+{tcp/udp+[ftp+data]}}
{MAC+{IP+{tcp/udp+[ftp+data]}}}<———打包———[_数据层_]——>Ethernet (以太网协议)<—[_数据层_]——解包——>{MAC+{IP+{tcp/udp+[ftp+data]}}}
{MAC+{IP+{tcp/udp+[ftp+data]}}}转码0101<——[_物理层_]———>转换成二进制(01011)<——[_物理层_]——>0101转码{MAC+{IP+{tcp/udp+[ftp+data]}}}
* 物理层转换二进制并发包到客户端 * | | * 物理层接收二进制并交给服务端 *
|————>发送——>网线(物理链接 ——>接收数据——>|
4.2 小结:IP + 端口就能标识全世界范围内独一无二的软件,
服务端:不容易变动,所以会和IP与端口绑定到一起,
客户端:不会与IP和端口捆绑到一起
5、应用层:应用层也有自己的协议(HTTP/FTP), 也可自定义协议
三、传输层详解
1、站在网络应用开发软件层面来讲,五层协议也可分为 2 大类:即 自定义 和 他定义
1.1 自定义:自己定义应用层
1.2 他定义:不用自己多参与,只需用就可以
2、TCP 协议:
TCP 协议又称流式协议,大致意思就是发包时,把数据包模拟成像水流一样发出去,接收端也一样方式接受,
这就需要双向都同意,才能建立协议,而这个双向协议需要三次握手才能成功,所以被称为可靠传输协议,传输效率相对低,费流量
即:① 客户端:发 SYN=1(建立连接请求信息)SEQ=X(数据包编号信息) 给服务端,
② 服务端:同意后发送ACK=1+X (代表同意发送数据包的确认信息)并发送 SYN=1 与 SEQ=Y 信息回给客户端,
③ 客户端:同意服务端请求信息 ACK=1+Y
连接网络成功
协议通过以后才能正常发送信息,消息发完之后,需断开连接断开连接需要发四次消息确认信息(客户端:同意并接收,服务端:同意并接收)
即: ① 客户端:数据发送完毕时,发 FIN=1(断开连接请求信息)
② 服务端:确认并回复 ACK=1 但不能同时发送断开连接请求,因为这个过程中,有可能自己还没发送完信息
③ 服务端:数据传输完毕后,才能发送 FIN=1 的断开连接请求
③ 客户端:确认并回复 ACK=1
断开网络成功
3、UDP 协议:
UDP协议也是基于端口建立的,只不过与TCP协议相比,它没有通道,也不需要双向同意信息,简单说,就是单方面的行动,自己的动作不需要别人的同意
所以,UDP协议不可靠,但是传输效率更高,节约流量,打广告时,这个协议是一个不错的选择
四、socket 详解
socket (套接字)应用层与TCP/IP协议通信中的中间软件抽象层,他是一组接口,在设计模式中把复杂的TCP/IP协议整合包装成简单的接口,以供调用
1、socket(套接字)2大家族
1.AF_UNIX: 在Unix系统内,一切皆文件,基于文件底层的系统读取数据,2个套接字进程运行在一台机器上,通过访问同一个文件系统,间接通讯
2.AF_INET:被应用于 IPV 6 还有其他的地址家族,在 python 的网络编程界,经常用到 AF_INET
2、基于 C(client) S(server ) 架构的套接字实例:
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
# 1.买手机,
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 插卡打电话
Phone.connect(("127.0.0.1", 3378))
# 发收消息
Phone.send("hello my name is dragon will".encode("utf-8"))
Phone.send("will Loong age is 18".encode("utf-8"))
data1 = Phone.recv(1024)
data = Phone.recv(1024)
print(data, data1)
# 挂电话
Phone.close()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
# 1.买手机,
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM) # AF_INET 定义网络编程的家族,定义数据格式的方法(流式协议)
# print (Phone)
# 2.插卡,调用对象并绑定
Phone.bind(("127.0.0.1", 3378)) # 绑定服务端默认地址和端口(0-65535)其中 0-1024 是给操作系统使用, 1024以后才属于其他软件使用
# 3.开机
Phone.listen(5)
# 4.连接
conn, client_addr = Phone.accept()
# 5.传数据( 收发消息)
data = conn.recv(1024) # 单位是 bytes,1024是最大限制
print("客户数据:%s" % data)
conn.send(data.upper())
# 6.挂电话
conn.close()
# 7.关机
Phone.close()
server
五、制作简单有趣的聊天编程
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
msg = input(">>>:").strip()
Phone.send(msg.encode("utf-8"))
data = Phone.recv(1024)
print(data.decode("utf-8"))
if msg == "q":
break
Phone.close()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
conn, client_addr = Phone.accept()
while True: # 通信循环
data = conn.recv(1024)
print(data.decode("utf-8"))
sdt = input("<<<:").strip()
conn.send(sdt.encode("utf-8"))
if sdt == "q":
break
conn.close()
Phone.close()
server
六、BUG 修复的相关操作
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
msg = input(">>>:").strip()
# TODO 解决消息收发为空或空格
if msg is None:continue
Phone.send(msg.encode("utf-8"))
data = Phone.recv(1024)
print(data.decode("utf-8"))
if msg == "q":
break
Phone.close()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# TODO 为服务端修复BUG:重复使用软件端口编号地址
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
conn, client_addr = Phone.accept()
while True: # 通信循环
try: # TODO 针对 Windows系统 解决处理一方断线或退出程序导致死循环或异常报错
data = conn.recv(1024)
if not data:break # TODO 针对 Linux系统 处理异常方法:
print(data.decode("utf-8"))
sdt = input("<<<:").strip()
conn.send(sdt.encode("utf-8"))
if sdt == "q":
break
except ConnectionResetError: # TODO 注意用捕捉错误的语法
break
conn.close()
Phone.close()
server
七、实现一个服务端与多个客户端交互
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
msg = input(">>>:").strip()
if msg is None:continue
Phone.send(msg.encode("utf-8"))
data = Phone.recv(1024)
print(data.decode("utf-8"))
if msg == "q":
break
Phone.close()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
msg = input(">>>:").strip()
if msg is None:continue
Phone.send(msg.encode("utf-8"))
data = Phone.recv(1024)
print(data.decode("utf-8"))
if msg == "q":
break
Phone.close()
client 1
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
msg = input(">>>:").strip()
if msg is None:continue
Phone.send(msg.encode("utf-8"))
data = Phone.recv(1024)
print(data.decode("utf-8"))
if msg == "q":
break
Phone.close()
client 2
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
msg = input(">>>:").strip()
if msg is None:continue
Phone.send(msg.encode("utf-8"))
data = Phone.recv(1024)
print(data.decode("utf-8"))
if msg == "q":
break
Phone.close()
client 3
# -*-coding: utf-8-*-
# Author:Dragon Will
#
# TODO 实现一个服务端对应多个客户端 ,需要在接收链接时,加上链接循环
import socket
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
while True:
# TODO 加上链接循环
conn, client_addr = Phone.accept()
while True: # 通信循环
try:
data = conn.recv(1024)
if not data:break
print(data.decode("utf-8"))
sdt = input("<<<:").strip()
conn.send(sdt.encode("utf-8"))
if sdt == "q":
break
except ConnectionResetError:
break
conn.close()
Phone.close()
server
八、模拟ssh远程协助执行命令
#!User\57098\My_pycharm_info
# -*- coding: utf-8 -*-
# @Time : 2019/8/3 14:54
# @Author : Dragon will
# @File : 补充知识点.py
# @Software: python学习模块
# TODO
# 双平台操作系统的相应指令解析
# windows平台 对应的指令 linux 平台
# dir : 查看一个文件夹下的子文件与文件名 ls
# ipconfig: 查看本地网卡的 IP 信息 ifconfig
# tasklist: 查看运行进程 ps aux
# TODO
# 如何在系统执行并拿到命令结果:
import subprocess
obj = subprocess.Popen('dir', shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
print(obj.stdout.read().decode("GBK"))
print(obj.stderr.read().decode("GBK"))
ssh知识点
# -*-coding: utf-8-*-
# Author:Dragon Will
# TODO 实现一个服务端对应多个客户端 ,需要在接收链接时,加上链接循环
import socket
import subprocess
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
while True:
# TODO 加上链接循环
conn, client_addr = Phone.accept()
while True: # 通信循环
try:
# 收消息
cmd = conn.recv(1024)
if not cmd:break
print(cmd.decode("utf-8"))
# 执行命令,拿到结果
obj = subprocess.Popen(cmd.decode("utf-8"), shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout = obj.stdout.read()
stderr = obj.stderr.read()
# 把返回给命令结果
print(len(stdout)+len(stderr))
conn.send(stdout+stderr)
# TODO + 号是一个可以优化的点
except ConnectionResetError:
break
conn.close()
Phone.close()
server
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
# 发命令
cmd = input(">>>:").strip()
if cmd is None:continue
Phone.send(cmd.encode("utf-8"))
# 拿结果并打印
data = Phone.recv(1024) # TODO 1024 个字节,传输数据大了可能不够用,需要改进
print(data.decode("GBK")) # TODO 此处解码,一定遵守用什么编码,就用什么解码
Phone.close()
client
九、粘包现象
1、粘包现象:因为数据的接收限制,导致多个包(多个命令的结果)粘在一起,出现答非所问的乱象,最终程序乱套
运行一个程序或软件需要的几个硬件:
CPU处理器:主要部件,负责处理所有任务
内存:存储 CPU 所有数据
硬盘:存储被 CPU 处理好或未处理的内存数据
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
# 发命令
cmd = input(">>>:").strip()
if cmd is None: continue
else: ppt = len(cmd)
Phone.send(str(ppt).encode("utf-8"))
Phone.send(cmd.encode("utf-8"))
# 拿结果并打印
data = Phone.recv(1024) # TODO 1024 个字节,传输数据大了可能不够用,需要改进
print(data.decode("GBK")) # TODO 此处解码,一定遵守用什么编码,就用什么解码
Phone.close()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
# TODO 实现一个服务端对应多个客户端 ,需要在接收链接时,加上链接循环
import socket
import subprocess
"""先实例化一个对象 Phone"""
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
while True:
# TODO 加上链接循环
conn, client_addr = Phone.accept()
while True: # 通信循环
try:
# 收消息
cmd = conn.recv(1024)
cmd1 = conn.recv(cmd.decode("utf-8"))
if not cmd:break
print(cmd.decode("utf-8"))
# 执行命令,拿到结果
obj = subprocess.Popen(cmd.decode("utf-8"), shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout = obj.stdout.read()
stderr = obj.stderr.read()
# 把返回给命令结果
conn.send(stdout+stderr)
# TODO + 号是一个可以优化的点
except ConnectionResetError:
break
conn.close()
Phone.close()
server
2、解决粘包问题
(1)解决粘包的方法有几种
- 把发送和接收包的数据设置更高(但是这种方法很低级不适合现在的场景)
- 把要发送的数据长度提前通知对方,就是定制固定长度的报头
(2)struct 模块详解
#!User\57098\My_pycharm_info
# -*- coding: utf-8 -*-
# @Time : 2019/8/4 21:21
# @Author : Dragon will
# @File : struct模块详解.py
# @Software: python学习模块
import struct
import json
# TODO
# struct 模块是专门负责网络传输打包专用
bys = struct.pack('i', 1077) # TODO 打包数据成固定长度, 并转换为 bytes 类型
# ( 'i' 是一个参数的简称,打包的时候设置什么, 解包就必须要用什么)
obj = struct.unpack('i', bys) # TODO 解包数据 并接转换为 tuple(元祖)类型
print(obj[0])
# TODO 语法参数括号内值的详解
# bys = struct.pack('i', 1077) # 这个括号内的参数,只能有4位数,但是现实中的详细信息远远不止4位数那么简单,所以不够用
bys = struct.pack('l', 10755555557)
obj = struct.unpack('l', bys)
print(obj)
# TODO
# 小结:
# i :表示接受小于4位数的数字格式
# l :表示接受小于8位数的数字格式
# 用 json 把报头格式化后,再用此方法进行打包报头
# 可能报头会很大,但是,用 json 把报头包装后,就会变得很简短,再用 struct 模块进行包装就能解决所有的问题了
# 服务端:报头内容 ————> json格式化 ————> json 格式化后长度 ————> struct.pack 包装先发送发送报头长度 ————> 再发送报头内容 ————> 发送需要内容
# 客户端: 接收报头长度 ————> struct.unpack 解包获取 ————> 接收报头 json 反解 ————> 读取内容长度 ————> 获取内容
header_dict = {
"file_name": "a.txt",
'md5': 5511222,
'total_size': 222555}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode('utf-8')
struct.pack('i', len(header_bytes))
struct 模块
3、解决粘包基础版
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
import subprocess
import struct
# TODO 解决粘包问题基础版(制定报头)
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
while True:
conn, client_addr = Phone.accept()
while True: # 通信循环
try:
cmd = conn.recv(8096)
if not cmd:break
obj = subprocess.Popen(cmd.decode("utf-8"), shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout = obj.stdout.read()
stderr = obj.stderr.read()
# TODO
# 第一步、制作固定长度的报头
total_size = len(stdout)+len(stderr)
header = struct.pack('i', total_size)
# TODO
# 第二步,把数据报头发送给客户段
conn.send(header)
# TODO
# 第三步、把数据发送过去
conn.send(stdout)
conn.send(stderr)
except ConnectionResetError:
break
conn.close()
Phone.close()
server
4、解决粘包终极版
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
import struct
import json
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
# 发命令
cmd = input(">>>:").strip()
if not cmd: continue
Phone.send(cmd.encode("utf-8"))
# 拿结果并打印
# TODO
# 第一步:拿到报头长度
obj = Phone.recv(4)
header_size = struct.unpack('i', obj)[0]
# TODO
# 第二步:再收报头
header_bytes = Phone.recv(header_size)
# TODO
# 第三步:从报头中解析数据描述信息(解包)
header_json = header_bytes.decode("GBK")
header_dict = json.loads(header_json)
print(header_dict)
total_size = header_dict["total_size"]
# TODO
# 第四步:拿到真实数据
recv_size = 0
recv_data = b''
while recv_size < total_size:
res = Phone.recv(1024)
recv_data += res
recv_size += len(res)
print(recv_data.decode("GBK")) # TODO 此处解码,一定遵守用什么编码,就用什么解码
Phone.close()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
import subprocess
import struct
import json
import os
# TODO 文件上传下载功能
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
while True:
conn, client_addr = Phone.accept()
while True: # 通信循环
try:
# 收到命令
res = conn.recv(8096) # b'get a.txt'
if not res:break
# 解析命令提取重要命令参数
cmds = res.decode("GBK").split() # ['gat', 'a.txt']
file_name = cmds[1]
# 以读的方式打开文件,读取文件内容,传给客户端
# TODO
# 第一步、制作固定长度的报头:用字典比较合适
header_dict = {
"file_name": file_name,
'md5': 5511222,
'file_size': os.path.getsize(file_name)}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode("utf-8")
# TODO
# 第二步先发送报头的长度
conn.send(struct.pack('i', len(header_bytes)))
# TODO
# 第三步,把报头发过去
conn.send(header_bytes)
# TODO
# 第四步、把数据发送过去
with open(file_name, 'rb') as f:
# conn.send(f.read())
for line in f:
conn.send(line)
except ConnectionResetError:
break
conn.close()
Phone.close()
server
十、文件传输(上传与下载)
上传与下载相同,无非是客户端与服务端的功能实现互相的调换
1、下载(基于同一目录下的操作代码)
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
import struct
import json
download_dir = r'C:\My_pycharm_info\python学习第三模块(面向对象与网络编程基础)\第2章:网络编程\9.文件传输\下载\clent\download'
# TODO 上面的内存地址应该写入配置文件
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
# 发命令
cmd = input(">>>:").strip()
if not cmd: continue
Phone.send(cmd.encode("utf-8"))
# 拿结果并打印
# TODO
# 第一步:拿到报头长度
obj = Phone.recv(4)
header_size = struct.unpack('i', obj)[0]
# TODO
# 第二步:再收报头
header_bytes = Phone.recv(header_size)
# TODO
# 第三步:从报头中解析数据描述信息(解包)
header_json = header_bytes.decode("GBK")
header_dict = json.loads(header_json)
print(header_dict)
total_size = header_dict["file_size"]
file_name = header_dict['file_name']
# TODO
# 第四步:拿到真实数据
with open('%s/%s' % (download_dir, file_name), 'wb') as f:
recv_size = 0
while recv_size < total_size:
line = Phone.recv(1024)
f.write(line)
recv_size += len(line)
# todo 代替进度条功能
print("总大小:%s 已下载:%s" % (total_size, recv_size))
Phone.close()
client
server
2、用函数实现下载功能
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
import struct
import json
download_dir = r'C:\My_pycharm_info\python学习第三模块(面向对象与网络编程基础)\第2章:网络编程\9.文件传输\用函数实现文件传输\clent\download'
def get(Phone, cmds):
obj = Phone.recv(4)
header_size = struct.unpack('i', obj)[0]
header_bytes = Phone.recv(header_size)
header_json = header_bytes.decode("GBK")
header_dict = json.loads(header_json)
print(header_dict)
total_size = header_dict["file_size"]
file_name = header_dict['file_name']
with open('%s/%s' % (download_dir, file_name), 'wb') as f:
recv_size = 0
while recv_size < total_size:
line = Phone.recv(1024)
f.write(line)
recv_size += len(line)
print("总大小:%s 已下载:%s" % (total_size, recv_size))
def put():
"""此处需要增加一个上传功能"""
pass
def run():
Phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.connect(("127.0.0.1", 3378))
while True:
inp = input(">>>:").strip()
if not inp: continue
Phone.send(inp.encode("utf-8"))
cmds = inp.split()
if cmds[0] == 'get':
get(Phone, cmds)
elif cmds[0] == 'put':
put(Phone, cmds)
Phone.close()
if __name__ == '__main__':
run()
client
# -*-coding: utf-8-*-
# Author:Dragon Will
import socket
import subprocess
import struct
import json
import os
# 函数版文件传输
share_dir = r'C:\My_pycharm_info\python学习第三模块(面向对象与网络编程基础)\第2章:网络编程\9.文件传输\用函数实现文件传输\server\share'
def get(conn, cmds):
file_name = cmds[1]
header_dict = {
"file_name": file_name,
'md5': 5511222,
'file_size': os.path.getsize('%s/%s' % (share_dir, file_name))}
header_json = json.dumps(header_dict)
header_bytes = header_json.encode("utf-8")
conn.send(struct.pack('i', len(header_bytes)))
conn.send(header_bytes)
with open('%s/%s' % (share_dir, file_name), 'rb') as f:
for line in f:
conn.send(line)
def put(conn, cmds):
"""此处需要增加一个上传功能"""
pass
def run():
Phone=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Phone.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
Phone.bind(("127.0.0.1", 3378))
Phone.listen(5)
while True:
conn, client_addr = Phone.accept()
while True: # 通信循环
try:
res = conn.recv(8096) # b'get a.txt'
if not res:break
cmds = res.decode("GBK").split() # ['gat', 'a.txt']
if cmds[0] == "get":
get(conn, cmds)
elif cmds[0] == "put":
put(conn, cmds)
except ConnectionResetError:
break
conn.close()
Phone.close()
if __name__ == '__main__':
run()
server
3、用类实现文件传输
#!User\57098\My_pycharm_info
# -*- coding: utf-8 -*-
# @Software: python学习模块
# @Time : 2019/8/5 16:02
# @File : Client.py
# @Author : Dragon will
import socket
import struct
import subprocess
import json
import os
class MYTCPClient:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding = 'utf-8'
request_queue_size = 5
server_dir = 'file_upload'
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:
self.client_close()
raise
def client_connect(self):
self.socket.connect(self.server_address)
def client_close(self):
self.socket.close()
def run(self):
while True:
inp = input('>>>:').strip()
if not inp:continue
l = inp.split()
cmd = l[0]
if hasattr(self, cmd):
func = getattr(self, cmd)
func(l)
def put(self, args):
cmd = args[0]
filename = args[1]
if not os.path.isfile(filename):
print('file:%s is not exists' % filename)
return
else:
filesize = os.path.getsize(filename)
head_dic = {'cmd': cmd, 'filename': os.path.basename(filename), 'filesize': filesize}
print(head_dic)
head_json = json.dumps(head_dic)
head__json_bytes = bytes(head_json, encoding=self.coding)
head_struct = struct.pack('i', len(head__json_bytes))
self.socket.send(head_struct)
self.socket.send(head__json_bytes)
send_size = 0
with open(filename, 'rb') as f:
for line in f:
self.socket.send(line)
send_size += len(line)
else:
print('upload successful')
tcpserver1 = MYTCPClient(('127.0.0.1', 8002))
tcpserver1.run()
client
#!User\57098\My_pycharm_info
# -*- coding: utf-8 -*-
# @Software: python学习模块
# @Time : 2019/8/5 16:01
# @File : Server.py
# @Author : Dragon will
import socket
import struct
import subprocess
import json
import os
class MYTCPServer:
address_family = socket.AF_INET
socket_type = socket.SOCK_STREAM
allow_reuse_address = False
max_packet_size = 8192
coding = 'utf-8'
request_queue_size = 5
server_dir = 'file_upload'
def __init__(self, server_address, bind_and_activate=True):
self.server_address = server_address
self.socket = socket.socket(self.address_family,
self.socket_type)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def server_bind(self):
if self.allow_reuse_address:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(self.server_address)
self.server_address = self.socket.getsockname()
def server_activate(self):
self.socket.listen(self.request_queue_size)
def server_close(self):
self.socket.accept()
def get_request(self):
return self.socket.accept()
def close_request(self, request):
request.close()
def run(self):
while True:
self.conn, self.client_addr = self.get_request()
print('from client', self.client_addr)
while True:
try:
head_struct = self.conn.recv(4)
if not head_struct:break
head_len = struct.unpack('1', head_struct)[0]
head_json = self.conn.recv(head_len).decode(self.coding)
head_dic = json.loads(head_json)
print(head_dic)
cmd = head_dic['cmd']
if hasattr(self, cmd):
func = getattr(self, cmd)
func(head_dic)
except Exception:
break
def put(self, args):
file_path = os.path.normpath(os.path.join(
self.server_dir,
args['filename']
))
filesize = args['filesize']
recv_size = 0
print('------>', file_path)
with open(file_path, 'wb') as f:
while recv_size < filesize:
recv_data = self.conn.recv(self.max_packet_size)
f.write(recv_data)
print('recvsize:%s filesize:%s' % (recv_size, filesize))
tcpserver1 = MYTCPServer(('127.0.0.1', 8002))
tcpserver1.run()
server
十一、udp协议的套接字
#!User\57098\My_pycharm_info
# -*- coding: utf-8 -*-
# @Software: python学习模块
# @Time : 2019/8/7 21:06
# @File : Server.py
# @Author : Dragon will
from socket import *
server = socket(AF_INET, SOCK_DGRAM) # SOCK_DGRAM 数据报协议,没有粘包问题
server.bind(('127.0.0.1', 8080))
while True:
data, client_addr = server.recvfrom(1024)
# server.sendto(data.upper(), client_addr)
print(data.decode('utf-8'))
cmd = input(">>>:").strip()
server.sendto(cmd.encode('utf-8'), client_addr)
if cmd == 'q':
break
server.close()
server
#!User\57098\My_pycharm_info
# -*- coding: utf-8 -*-
# @Software: python学习模块
# @Time : 2019/8/7 21:06
# @File : Client.py
# @Author : Dragon will
# todo 基于 UDP协议的操作
from socket import *
client = socket(AF_INET, SOCK_DGRAM) # SOCK_DGRAM 数据报协议,没有粘包问题
while True:
msg = input(">>>:").strip()
client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
data, server_addr = client.recvfrom(1024)
if data.decode('utf-8') == 'q':break
print(data.decode('utf-8'))
client.close()
# todo
# udp 协议说明:
# ① udp协议可以发空,因为它自带报头(IP信息与端口信息)
# ② udp协议不会粘包,因为它都是数据报,在 linux 系统,如果服务端发送的数据,接收端接收不完,剩下的数据会直接丢失,
# 在 windows 系统,服务端收不完客户端数据会报错提示接受信息量太大,接收数据设置不够用
# ③ udp 协议的典型(NTP, DNS, QQ) 其他基本上没有可用之处,因为 TCP 比 UDP 协议的安全性高,可靠性强
client
十二、FTP作业讲解
TODO FTP 项目要求与说明
1、用户加密认证:创建一个 ini 文件存储用户数据 密码最好用 md5 加密 #
2、允许多个用户同时登陆:此要求可以先不做,等学完高并发时可以考虑完善
3、每个用户有自己对应的目录,且只能访问自己的目录:在 ini 文件内设置密码和配置路径
4、对用户进行磁盘配额,每个用户的应用内存空间都不相同:(此方法可在 ini 文件内设置文件内存空间的数值,在打印时,加上数值的内存单位,再用 os 模块统计用户剩余存储单位)
5、允许用户在 ftp server 上随意切换目录 # 此功能为选学功能
6、允许用户查看当前目录文件名(同要求 3 一样)
7、允许用户传输与下载文件,保证文件一致性:文件传输时,为文件的报头部分 md5 加密,当用户上传或下载时,通过比对 md5 值的结果获得一致性
8、文件传输过程中,显示进度条
9、附加功能:支持文件的断点续传