第三模块：网络编程

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#实现端口的复用
phone.bind((‘127.0.0.1‘,9997))#服务器端必须绑定ip以及端口，整个是以集合的方式导入

phone.listen(5)#服务器端侦听，队列中最大值为5，不过一次只能对应一个


print("holding.............")#验证已经等待接入
conn,client_add = phone.accept() #分别是数据以及客户端的ip地址信息

while True:
    try:
        cmd =conn.recv(1024)#cmd是接收的数据，最大是1024
        if not cmd :break#只用于linux环境下
        print("客户端数据：",cmd)
        conn.send(cmd.upper())#将接收的数据，变为大写发送回去
    except ConnectionResetError:#用于windows
        break


conn.close()#通话结束
phone.close()#电话关机

import socket


phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字


phone.connect((‘127.0.0.1‘,9997))#联络服务器，拨打服务器ip以及端口

while True:
    cmd = input(‘---->‘).strip()
    if not cmd:continue#如果输入为空则继续下一次循环
    phone.send(cmd.encode(‘utf-8‘))#将要发送的信息已utf-8的形式
    data = phone.recv(1024)#接收数据最大是1024字节
    print(data.decode(‘utf-8‘))#打印数据


phone.close()#客户端关机

import socket

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#实现端口的复用
phone.bind((‘127.0.0.1‘,9997))#服务器端必须绑定ip以及端口，整个是以集合的方式导入

phone.listen(5)#服务器端侦听，队列中最大值为5，不过一次只能对应一个

while True:
    print("holding.............")#验证已经等待接入
    conn,client_add = phone.accept() #分别是数据以及客户端的ip地址信息

    while True:
        try:
            cmd =conn.recv(1024)#cmd是接收的数据，最大是1024
            if not cmd :break#只用于linux环境下
            print("客户端数据：",cmd)
            conn.send(cmd.upper())#将接收的数据，变为大写发送回去
        except ConnectionResetError:#用于windows
            break


    conn.close()#通话结束,每一次连接结束，都应该将连接结束然后等待新的连接
phone.close()#电话关机

#执行命令，返回命令执行状态 ， 0 or 非0
>>> retcode = subprocess.call(["ls", "-l"])

#执行命令，如果命令结果为0，就正常返回，否则抛异常
>>> subprocess.check_call(["ls", "-l"])
0

#接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果 
>>> subprocess.getstatusoutput(‘ls /bin/ls‘)
(0, ‘/bin/ls‘)

#接收字符串格式命令，并返回结果
>>> subprocess.getoutput(‘ls /bin/ls‘)
‘/bin/ls‘

#执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
>>> res=subprocess.check_output([‘ls‘,‘-l‘])
>>> res
b‘total 0\ndrwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM\n‘

常用参数：

args：shell命令，可以是字符串或者序列类型（如：list，元组）
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
shell：同上
cwd：用于设置子进程的当前目录
env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
下面这2条语句执行会有什么区别？

a=subprocess.run(‘sleep 10‘,shell=True,stdout=subprocess.PIPE)
a=subprocess.Popen(‘sleep 10‘,shell=True,stdout=subprocess.PIPE)
区别是Popen会在发起命令后立刻返回，而不等命令执行结果。这样的好处是什么呢？

如果你调用的命令或脚本 需要执行10分钟，你的主程序不需卡在这里等10分钟，可以继续往下走，干别的事情，每过一会，通过一个什么方法来检测一下命令是否执行完成就好了。

Popen调用后会返回一个对象，可以通过这个对象拿到命令执行结果或状态等，该对象有以下方法

poll()

Check if child process has terminated. Returns returncode

wait()

Wait for child process to terminate. Returns returncode attribute.

terminate()终止所启动的进程Terminate the process with SIGTERM

kill() 杀死所启动的进程 Kill the process with SIGKILL

communicate()与启动的进程交互，发送数据到stdin,并从stdout接收输出，然后等待任务结束

>>> a = subprocess.Popen(‘python3 guess_age.py‘,stdout=subprocess.PIPE,stderr=subprocess.PIPE,stdin=subprocess.PIPE,shell=True)

>>> a.communicate(b‘22‘)

(b‘your guess:try bigger\n‘, b‘‘)
send_signal(signal.xxx)发送系统信号

pid 拿到所启动进程的进程号

import socket
import subprocess

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#实现端口的复用
phone.bind((‘127.0.0.1‘,9997))#服务器端必须绑定ip以及端口，整个是以集合的方式导入

phone.listen(5)#服务器端侦听，队列中最大值为5，不过一次只能对应一个


print("holding.............")#验证已经等待接入
conn,client_add = phone.accept() #分别是数据以及客户端的ip地址信息

while True:
    try:
        cmd =conn.recv(1024)#cmd是接收的数据，最大是1024
        if not cmd :break#只用于linux环境下
        obj = subprocess.Popen(cmd.decode(‘gbk‘),shell=True,#跳出python，用系统自带的系统解析器解析,由于是windows，解码使用gbk
                               stdout=subprocess.PIPE,#输出正确的输出结果
                               stderr=subprocess.PIPE #输出错误的输出结果
                               )
        stdout = obj.stdout.read() #正确输出
        stderr = obj.stderr.read() #错误输出
        conn.send(stdout+stderr)#将系统执行的结果发送回去
    except ConnectionResetError:#用于windows
        break


conn.close()#通话结束
phone.close()#电话关机

C:\Users\gao-bq.KDDICAN\AppData\Local\Programs\Python\Python35\python.exe D:/PycharmProjects/s2018/day6/实验三/客户端.py
---->ping 192.168.0.1

正在 Ping 192.168.0.1 具有 32 字节的数据:
来自 192.168.0.1 的回复: 字节=32 时间=1ms TTL=64
来自 192.168.0.1 的回复: 字节=32 时间=1ms TTL=64
来自 192.168.0.1 的回复: 字节=32 时间=4ms TTL=64
来自 192.168.0.1 的回复: 字节=32 时间=2ms TTL=64

192.168.0.1 的 Ping 统计信息:
    数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
往返行程的估计时间(以毫秒为单位):
    最短 = 1ms，最长 = 4ms，平均 = 2ms

---->ipconfig \A

错误: 无法识别或不完整的命令行。

conn.send(stdout+stderr)#原本的

conn.send (stdout)#修改后，将一个拆分为俩个，由于俩个发送间隔短，所以俩个根据TCP的算法会一起打包发送
conn.send(stderr)

import socket
import subprocess
import struct

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#实现端口的复用
phone.bind((‘127.0.0.1‘,9997))#服务器端必须绑定ip以及端口，整个是以集合的方式导入
phone.listen(5)#服务器端侦听，队列中最大值为5，不过一次只能对应一个


print("holding.............")#验证已经等待接入
conn,client_add = phone.accept() #分别是数据以及客户端的ip地址信息
print(client_add)

while True:
    try:
        cmd =conn.recv(1024)#cmd是接收的数据，最大是1024
        if not cmd :break#只用于linux环境下
        obj = subprocess.Popen(cmd.decode(‘gbk‘),shell=True,#跳出python，用系统自带的解析器解析
                               stdout=subprocess.PIPE,#输出正确的输出结果
                               stderr=subprocess.PIPE #输出错误的输出结果
                               )
        stdout = obj.stdout.read()
        stderr = obj.stderr.read()
        #发送数据
        #第一步：制作固定长度的报头
        total_size = len(stdout) + len(stderr)  # 确定要发数据的总大小
        header = struct.pack(‘i‘, total_size)  # 制作报头，将数据大小打包进去
        #第二步：发送报头信息
        conn.send(header)  # 发送报头

        #第三步：发送真实数据

        conn.send(stdout)#发送数据
        conn.send(stderr)#发送数据

    except ConnectionResetError:#用于windows
        break


conn.close()#通话结束
phone.close()#电话关机

import socket
import struct

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.connect((‘127.0.0.1‘,9997))#联络服务器，拨打服务器ip以及端口

while True:
    cmd = input(‘---->‘).strip()
    if not cmd:continue#如果输入为空则继续下一次循环
    phone.send(cmd.encode(‘gbk‘))#将要发送的信息已utf-8的形式
    #接收数据
    #第一步：接收报头
    header = phone.recv(4)#这里接收4的原因是在服务器端固定报头长度为4，i为4，l为8
    #第二步：从报头中接收真实的描述信息
    total_size = struct.unpack(‘i‘,header)[0]
    #第三步：接收真实的数据
    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‘))#打印数据


phone.close()#客户端关机

import socket
import subprocess
import struct
import json

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#实现端口的复用
phone.bind((‘127.0.0.1‘,9997))#服务器端必须绑定ip以及端口，整个是以集合的方式导入
phone.listen(5)#服务器端侦听，队列中最大值为5，不过一次只能对应一个


print("holding.............")#验证已经等待接入
conn,client_add = phone.accept() #分别是数据以及客户端的ip地址信息
print(client_add)

while True:
    try:
        cmd =conn.recv(1024)#cmd是接收的数据，最大是1024
        if not cmd :break#只用于linux环境下
        obj = subprocess.Popen(cmd.decode(‘gbk‘),shell=True,#跳出python，用系统自带的解析器解析
                               stdout=subprocess.PIPE,#输出正确的输出结果
                               stderr=subprocess.PIPE #输出错误的输出结果
                               )
        stdout = obj.stdout.read()
        stderr = obj.stderr.read()
        #发送数据
        #第一步：制作固定长度的报头
        header_dict ={
            ‘file_name‘:‘a.txt‘,
            ‘md5‘:‘xxxxx‘,
            ‘total_size‘:len(stdout) + len(stderr),
        }#报头字典
        header_json = json.dumps(header_dict)#将报头转换为json模式
        header_bytes = header_json.encode(‘gbk‘)#将json模式的数据转换为byte类型

        #第二步，发送报头长度
        conn.send(struct.pack(‘i‘, len(header_bytes)))  # 发送报头的长度

        #第三步：发送报头信息
        conn.send(header_bytes)  # 发送报头

        #第四步：发送真实数据

        conn.send(stdout)#发送数据
        conn.send(stderr)#发送数据

    except ConnectionResetError:#用于windows
        break


conn.close()#通话结束
phone.close()#电话关机

import socket
import struct
import json

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.connect((‘127.0.0.1‘,9997))#联络服务器，拨打服务器ip以及端口

while True:
    cmd = input(‘---->‘).strip()
    if not cmd:continue#如果输入为空则继续下一次循环
    phone.send(cmd.encode(‘gbk‘))#将要发送的信息已utf-8的形式
    #接收数据
    #第一步：接收报头长度
    obj = phone.recv(4)
    header_size = struct.unpack(‘i‘,obj)[0]

    #第二步：接收真实的报头信息
    header_bytes = phone.recv(header_size)

    #第三步：从报头中接收真实的描述信息
    header_json = header_bytes.decode(‘gbk‘) #从接收的包中反解码出json格式的包
    header_dic = json.loads(header_json)#从json包中反解码字典
    print(header_dic)
    total_size = header_dic[‘total_size‘]#从字典中获取文件大小

    #第四步：接收真实的数据
    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‘))#打印数据


phone.close()#客户端关机

import socket
import struct
import json
import os

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)#实现端口的复用
phone.bind((‘127.0.0.1‘,9997))#服务器端必须绑定ip以及端口，整个是以集合的方式导入
phone.listen(5)#服务器端侦听，队列中最大值为5，不过一次只能对应一个


print("holding.............")#验证已经等待接入
conn,client_add = phone.accept() #分别是数据以及客户端的ip地址信息
print(client_add)

while True:
    try:
        #1.收命令
        rec =conn.recv(8096)#接收文件
        if not rec :break#只用于linux环境下

        #2.解析命令
        cmds = rec.decode(‘utf-8‘).split()
        filname = cmds[1]
        #发送数据
        #第一步：制作固定长度的报头
        header_dict ={
            ‘file_name‘:‘filename‘,
            ‘md5‘:‘xxxxx‘,
            ‘total_size‘:os.path.getsize(filname)
        }#报头字典
        header_json = json.dumps(header_dict)#将报头转换为json模式
        header_bytes = header_json.encode(‘utf-8‘)#将json模式的数据转换为byte类型

        #第二步，发送报头长度
        conn.send(struct.pack(‘i‘, len(header_bytes)))  # 发送报头的长度

        #第三步：发送报头信息
        conn.send(header_bytes)  # 发送报头

        #第四步：发送真实数据
        with open(filname,‘rb‘) as f:
            for line in f:
                conn.send(line)

    except ConnectionResetError:#用于windows
        break


conn.close()#通话结束
phone.close()#电话关机

import socket
import struct
import json

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)#实例化一个对象，括号内第一个是基于网络通信的套接字，第二个是基于TCP的套接字
phone.connect((‘127.0.0.1‘,9997))#联络服务器，拨打服务器ip以及端口

while True:
    cmd = input(‘---->‘).strip()
    if not cmd:continue#如果输入为空则继续下一次循环
    phone.send(cmd.encode(‘utf-8‘))#将要发送的信息已utf-8的形式
    #接收数据
    #第一步：接收报头长度
    obj = phone.recv(4)
    header_size = struct.unpack(‘i‘,obj)[0]

    #第二步：接收真实的报头信息
    header_bytes = phone.recv(header_size)

    #第三步：从报头中接收真实的描述信息
    header_json = header_bytes.decode(‘gbk‘) #从接收的包中反解码出json格式的包
    header_dic = json.loads(header_json)#从json包中反解码字典
    print(header_dic)
    total_size = header_dic[‘total_size‘]#从字典中获取文件大小
    filename = header_dic[‘file_name‘]


    #第四步：接收真实的数据
    with open(filename,‘wb‘)as f:
        recv_size = 0
        while recv_size<total_size:
            line = phone .recv(1024)
            f.write(line)
            recv_size += len(line)



phone.close()#客户端关机