　　　　　　　　　　　　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、附加功能：支持文件的断点续传

python全栈开发中级班全程笔记（第三模块、第二章（网络编程））

python全栈开发第三模块

第二章：网络编程

猜你喜欢