网络编程练习这些就ok

1，什么是C/S架构？

    C指的是client（客户端软件），S指的是Server（服务端软件）
    一个C/S架构就是，实现服务端软件与客户端软件基于网络通信。

互联网中处处是C/S架构
　　    如12306网站是服务端，你的浏览器是客户端（B/S架构也是C/S架构的一种）
　　    腾讯作为服务端为你提供视频，你得下个腾讯视频客户端才能看它的视频）

C/S架构与socket的关系：
        我们学习socket就是为了完成C/S架构的开发

　　

2，互联网协议是什么？分别介绍五层协议中每一层的功能？

    英语成为世界上所有人通信的统一标准，计算机之间的通信也应该有一个像英语一样的通信标准，
这个标准称之为互联网协议， 可以很明确地说：互联网协议就是计算机界的英语，网络就是物理链接
介质+互联网协议。 我们需要做的是，让全世界的计算机都学会互联网协议，这样任意一台计算机在
发消息时都严格按照协议规定的格式去组织数据，接收方就可以按照相同的协议解析出结果了，这就
实现了全世界的计算机都能无障碍通信。 按照功能不同，人们将互联网协议分为osi七层或tcp/ip五
层或tcp/ip四层（我们只需要掌握tcp/ip五层协议即可），这种分层就好比是学习英语的几个阶段，
每个阶段应该掌握专门的技能或者说完成特定的任务，比如：1、学音标 2、学单词 3、学语法 4、写作文

　　

    简单说，计算机之间的通信标准，就称为互联网协议

    按照功能不同，人们将互联网协议分为osi七层或tcp/ip五层或tcp/ip四层

    tcp/ip四层：应用层，传输层，网络层，网络接口层

    tcp/ip五层：应用层，传输层，网络层，数据链路层，物理层

    osi七层：应用层，表示层，会话层，传输层，网络层，数据链路层，物理层

　　

3，基于tcp协议通信，为何建立链接需要三次握手，而断开链接却需要四次挥手

为什么要三次挥手？

　　在只有两次“握手”的情形下，假设Client想跟Server建立连接，但是却因为中途连接请求的
数据报丢失了，故Client端不得不重新发送一遍；这个时候Server端仅收到一个连接请求，因此
可以正常的建立连接。但是，有时候Client端重新发送请求不是因为数据报丢失了，而是有可能
数据传输过程因为网络并发量很大在某结点被阻塞了，这种情形下Server端将先后收到2次请求，
并持续等待两个Client请求向他发送数据...问题就在这里，Cient端实际上只有一次请求，而
Server端却有2个响应，极端的情况可能由于Client端多次重新发送请求数据而导致Server端
最后建立了N多个响应在等待，因而造成极大的资源浪费！所以，“三次握手”很有必要！

　　为什么要四次挥手？

　　试想一下，假如现在你是客户端你想断开跟Server的所有连接该怎么做？
第一步，你自己先停止向Server端发送数据，并等待Server的回复。但事情还没有完，
虽然你自身不往Server发送数据了，但是因为你们之前已经建立好平等的连接了，
所以此时他也有主动权向你发送数据；故Server端还得终止主动向你发送数据，
并等待你的确认。其实，说白了就是保证双方的一个合约的完整执行！

　　三次握手：client发送请求建立通道；server收到请求并同意，同时也发送请求建通道；client收到请求并同意，建立完成

　　四次挥手：client发送请求断开通道；server收到请求并同意，同时还回复client上一条消息；server也发送请求断开通道；client受到消息结束

为什么TCP协议终止链接要四次？

1、当主机A确认发送完数据且知道B已经接受完了，想要关闭发送数据口（当然确认信号还是可以发），
就会发FIN给主机B。

2、主机B收到A发送的FIN，表示收到了，就会发送ACK回复。

3、但这是B可能还在发送数据，没有想要关闭数据口的意思，所以FIN与ACK不是同时发送的，
而是等到B数据发送完了，才会发送FIN给主机A。

4、A收到B发来的FIN，知道B的数据也发送完了，回复ACK， A等待2MSL以后，没有收到B传来的
任何消息，知道B已经收到自己的ACK了，A就关闭链接，B也关闭链接了。

　　

4，为何基于tcp协议的通信比基于udp协议的通信更可靠？

tcp:可靠 对方给了确认收到信息，才发下一个，如果没收到确认信息就重发
udp:不可靠 一直发数据，不需要对方回应

（1）UDP：user datagram protocol（用户数据报协议）
特点：
——1：面向无连接：传输数据之前源端和目的端不需要建立连接
——2：每个数据报的大小都限制在64k（8个字节）以内
——3：面向报文的不可靠协议（即发出去的数据不一定会接收到）
——4：传输速率快，效率高
——5：现实生活实例：邮局寄件，实时在线聊天，视频协议等等
（2）TCP：transmission control protocol（传输控制协议）
 特点：
——1：面向连接：传输数据之前需要建立连接
——2：在连接过程中进行大量的数据传输
——3：通过“三次握手”的方式完成连接，是安全可靠的协议
——4：传输效率低，速度慢
 

　　

‍5，流式协议指的是什么协议，数据报协议指的是什么协议？

TCP协议，可靠传输
数据报协议: UDP协议，不可传输
也就是TCP和UDP的区别：
    TCP是面向连接的，可靠的字节流服务
    UDP是面向无连接的数据报服务

　　

6，什么是socket？简述基于tcp协议的套接字通信流程流式协议：

    Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，
Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，
对用户来说，一组简单的接口就是全部。

服务端：创建socket对象，绑定ip端口bind(),  设置最大链接数listen(),  accept()与客户端
的connect()创建双向管道， send(), recv(),close()

客户端：创建socket对象，connect()与服务端accept()创建双向管道 ,  send(), recv(),close()

　　

7，什么是粘包？ socket 中造成粘包的原因是什么？ 哪些情况会发生粘包现象？

    粘包：数据粘在一起，主要因为：接收方不知道消息之间的界限，不知道一次性提取
多少字节的数据造成的数据量比较小，时间间隔比较短，就合并成了一个包，
这是底层的一个优化算法（Nagle算法）

　　

8，基于socket开发一个聊天程序，实现两端互相发送和接收消息

　　服务端：

# _*_ coding: utf-8 _*_ 
# 8，基于socket开发一个聊天程序，实现两端互相发送和接收消息
import socket
ip_port = ('127.0.0.1',8088)
link =  socket.socket(socket.AF_INET,socket.SOCK_STREAM)
link.bind(ip_port)
link.listen(5)

print("等待数据连接：。。》》")
# 阻塞直到有连接为止，有了一个新连接进来后，就会为这个请求生成一个连接对象
conn, addr = link.accept()

client_data = conn.recv(1024)
print("这是收到的消息：",client_data.decode('utf-8'))
conn.send(client_data.upper())

conn.close()
link.close()

客户端

# _*_ coding: utf-8 _*_ 
# 8，基于socket开发一个聊天程序，实现两端互相发送和接收消息/
import socket
ip_port = ('127.0.0.1',8088)
link =  socket.socket(socket.AF_INET,socket.SOCK_STREAM)
link.connect(ip_port)

print("开始发送数据")
cmd = input("请输入：>>").strip()
link.send(cmd.encode('utf-8'))
data = link.recv(1028)
print(data)

link.close()

　　

9，基于tcp socket，开发简单的远程命令执行程序，允许用户执行命令，并返回结果

服务端：

# _*_ coding: utf-8 _*_
# 9，基于tcp socket，开发简单的远程命令执行程序，允许用户执行命令，并返回结果
import socket
import struct
import subprocess

ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.bind(ip_port)
sk.listen(5)
while True: #连接循环
    conn,addr = sk.accept()
    print(conn,addr)
    while True:  #通信循环
        client_data = conn.recv(1024)
        #处理过程
        res = subprocess.Popen(client_data.decode('utf-8'),shell=True,
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
        stdout = res.stdout.read()
        stderr = res.stderr.read()
        # 先发报头(转成固定长度的bytes类型，那么怎么转呢？就用到了struct模块)
        length = len(stdout)+len(stderr)
        header = struct.pack('i',length)
        conn.send(header)
        conn.send(stderr)
        conn.send(stdout)
    conn.close()
sk.close()

conn.close()
sk.close()

客户端

# _*_ coding: utf-8 _*_ 
# 9，基于tcp socket，开发简单的远程命令执行程序，允许用户执行命令，并返回结果
import socket
import struct

ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.connect(ip_port)
while True:
    cmd = input("请输入命令:>>").strip()
    if not cmd:continue
    sk.send(cmd.encode('utf-8'))
    header_struct = sk.recv(1024)
    unpack_res = struct.unpack('i',header_struct)
    total_size = unpack_res[0]
    recv_size = 0
    total_data = b''
    while recv_size < total_size:
        recv_data = sk.recv(1024)
        recv_size += len(recv_data)
        total_data += recv_data
    print("返回的消息：%s"%total_data.decode('gbk'))
sk.close()

　　

10，基于tcp协议编写简单FTP程序，实现上传、下载文件功能，并解决粘包问题

 客户端

# _*_ coding: utf-8 _*_

import socket
import struct
import json
downlaod_dir = r'D:文件传输clientdownload'

ip_port = ('127.0.0.1',8808)
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect(ip_port)
while True:
    cmd = input(">>>").strip()  #get D:文件传输servera.avi
    if not cmd:continue
    phone.send(cmd.encode('utf-8'))
    #接受文件的内容，以写的方式打开一个新文件，接受服务端发来的文件内容，并写入客户端的新文件
    #第一步，先收报头的长度，然后解包
    obj = phone.recv(1024)
    header_size = struct.unpack('i',obj)[0]
    #第二部 再收报头
    header_bytes = phone.recv(header_size)

    #第三部，从报头中解析除对真实数据的描述信息
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)
    '''
     header_dic = {
                'filename':filename,  #a.avi
                'md5':'dsdsd',
                'file_size':os.path.getsize(filename)
            }'''
    print(header_dic)
    total_size = header_dic['file_size']
    filename = header_dic['filename']

    #第四步，接受真实的数据
    with open('%s/%s'%(downlaod_dir,filename),'wb') as f:
        recv_size = 0
        # recv_data = b''
        while recv_size <total_size:
            res = phone.recv(1024)
            # recv_data += res
            f.write(res)
            recv_size += len(res)
            print("总大小： %s  
已经下载大小  ：%s"%(total_size,recv_size))

    # print(recv_data.decode('utf-8'))
phone.close()

　　

服务端

# _*_ coding: utf-8 _*_
import subprocess
import socket
import struct
import json
import os
share_dir =r'/文件传输/server/share'

phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_port = ('127.0.0.1',8808)
phone.bind(ip_port)
phone.listen(5)
print("starting....")
while True:  #链接循环
    conn,client_addr = phone.accept()
    print(client_addr)
    while True: #通信循环
        try:
            #收命令
            res = conn.recv(1024)   #b'get a.txt'
            if not res :continue
            #解析命令，提取相应的参数
            cmds = res.decode('utf-8').split()
            filename = cmds[1]
            #以读的方式打开文件，读取文件内容发送给客户端
            # with open(filename,'rb') as f:
            #     conn.s
              #制定固定长度的报头
            header_dic = {
                'filename':filename,  #a.avi
                'md5':'dsdsd',
                'file_size':os.path.getsize(r"%s/%s"%(share_dir,filename))
            }
            header_json = json.dumps(header_dic)
            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,filename),'rb') as f:
                # conn.send(f.read())
                for line in f:
                    conn.send(line)


        except ConnectionResetError:
            break
    conn.close()
phone.close()

　　

函数版本服务端

# _*_ coding: utf-8 _*_ 
import socket
import os
import struct
import pickle

dirname = os.path.dirname(os.path.abspath(__file__))
filepath = os.path.join(dirname, 'share')

def get(cmds,conn):
    filename = cmds[1]
    file_path = os.path.join(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)
        conn.send(struct.pack('i', len(header_bytes)))
        conn.send(header_bytes)

        with open(file_path, 'rb') as f:
            for line in f:
                conn.send(line)
    else:
        conn.send(struct.pack('i', 0))

def put(cmds,conn):
    pass

def run():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    print('starting...')
    while True:
        conn, client_addr = server.accept()
        print(client_addr)
        while True:
            try:
                res = conn.recv(1024)
                if not res: continue
                cmds = res.decode('utf-8').split()
                if cmds[0] == 'get':
                    get(cmds,conn)
                elif cmds[0] == 'put':
                    put(cmds,conn)
            except ConnectionResetError:
                break
        conn.close()

    server.close()

if __name__ == '__main__':
    run()

　　

函数版本客户端

# _*_ coding: utf-8 _*_ 
import socket
import struct
import pickle
import os

dirname = os.path.dirname(os.path.abspath(__file__))
filepath = os.path.join(dirname,'download')

def get(client):
    obj = client.recv(4)
    header_size = struct.unpack('i', obj)[0]
    if header_size == 0:
        print('文件不存在')
    else:
        header_types = client.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' % (filepath, filename), 'wb') as f:
            recv_size = 0
            while recv_size < file_size:
                res = client.recv(1024)
                f.write(res)
                recv_size += len(res)
                print('总大小：%s 已下载：%s' % (file_size, recv_size))

def put():
    pass

def run():
    client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    client.connect(('127.0.0.1',8080))
    while True:
        msg = input(">>>:").strip()  # get a.txt
        if not msg:continue
        client.send(msg.encode('utf-8'))

        cmds = msg.split()
        if cmds[0] == 'get':
            get(client)
        elif cmds[0] == 'put':
            put()

    client.close()

if __name__ == '__main__':
    run()

　　

面向对象版本服务端

# _*_ coding: utf-8 _*_ 
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:
            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)
            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()

服务端

　　

面向对象版本客户端

# _*_ coding: utf-8 _*_ 
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()

客户端

　　

11，基于udp协议编写程序，实现功能

 服务端：

# _*_ coding: utf-8 _*_ 
import socket
ip_port = ('127.0.0.1',8808)
udp_server_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server_client.bind(ip_port)
while True:
    conn,addr = udp_server_client.recvfrom(1024)
    print(conn,addr)

    udp_server_client.sendto(conn.upper(),addr)

　　

客户端：

# _*_ coding: utf-8 _*_ 
import socket
ip_port = ('127.0.0.1',8808)
udp_server_client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    cmd = input(">>>>").strip()
    if not cmd:
        continue
    udp_server_client.sendto(cmd.encode('utf-8'),ip_port)
    back_cmd,addr = udp_server_client.recvfrom(1024)
    print(back_cmd.decode('utf-8'))

　　

UDP不会发生粘包现象，下面举例说明

客户端

# _*_ coding: utf-8 _*_ 
import socket

ip_port = ('127.0.0.1',8989)
client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
client.sendto('hello'.encode('utf-8'),ip_port)
client.sendto('james'.encode('utf-8'),ip_port)
client.close()

　　

服务端

# _*_ coding: utf-8 _*_ 
import socket

ip_port = ('127.0.0.1',8989)
server = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(ip_port)
res1 = server.recvfrom(5)
print("res1:",res1)
res2 = server.recvfrom(5)
print("res2:",res2)
server.close()

　　

12，执行指定的命令，让客户端可以查看服务端的时间

13，执行指定的命令，让客户端可以与服务的的时间同步

服务端

# _*_ coding: utf-8 _*_ 
import socket
import subprocess
import time

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8080))
while True:
    data, client_addr = server.recvfrom(1024)
    print(data, client_addr)
    obj = subprocess.Popen(data.decode('utf-8'),shell=True,  # time 命令在windows 下不能用
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)
    stdout = obj.stdout.read()
    stderr = obj.stderr.read()
    print(stdout+stderr)
    server.sendto(stdout+stderr,client_addr)
    if data.decode('utf-8') == 'time':
        str_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
        # str_time = '2017-01-01 00:00:00'
        server.sendto(str_time.encode('gbk'), client_addr)

server.close()

　　

客户端

# _*_ coding: utf-8 _*_ 
import socket
import os
import time
client = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
    msg = input('>>>:').strip()
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
    data,server_addr = client.recvfrom(1024)
    print(data.decode('utf-8'),server_addr)
    localtime = time.localtime()
    os.system("date %d-%d-%d" % (localtime.tm_year, localtime.tm_mon, localtime.tm_mday))  # 设置日期
    os.system("time %d:%d:%d.0" % (localtime.tm_hour, localtime.tm_min, localtime.tm_sec))  # 设置时间

client.close()