网络编程练习这些就ok

Posted 战争热诚

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了网络编程练习这些就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:\文件传输\client\download‘

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:\文件传输\server\a.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  \n已经下载大小  :%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()

  

以上是关于网络编程练习这些就ok的主要内容,如果未能解决你的问题,请参考以下文章

前端面试题之手写promise

使用 Git 来管理 Xcode 中的代码片段

学习 《UNIX网络编程》

7道SparkSQL编程练习题

Linux基础 7-6 Bash脚本编程练习3

Linux基础 7-6 Bash脚本编程练习3