饮冰三年-人工智能-Python-19 Python网络编程

时间：2023-03-09 09:04:07
饮冰三年-人工智能-Python-19 Python网络编程

饮冰三年-人工智能-Python-19 Python网络编程

Socket：套接字。作用：我们只需要安照socket的规定去编程，就不需要深入理解tcp/udp协议也可以实现

1：TCP协议

1.1  客户端服务端循环收发消息

# 1：引入stock模块（导包）

import socket

#2：创建服务端对象

tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#3：绑定接口地址和端口号

ip_port=("127.0.0.1",8000)

back_log=5

buffer_size=1024

tcp_server.bind(ip_port)

#4: 开启监听(设置监听数量)

tcp_server.listen(back_log)

print("服务端开始运行了")

# 5：准备接收消息

conn, add = tcp_server.accept()

while True:

    #6：接收消息

    data=conn.recv(buffer_size)

    print("客户端发送的消息是：",data.decode("utf-8"))

    #7：发送消息

    conn.send(data.upper())

# 8：关闭连接

conn.close()

# 9：关闭服务端对象

tcp_server.close()

服务端

#1:引入模块

from socket import *

#2：创建对象

tcp_client = socket(AF_INET,SOCK_STREAM)

#3：建立连接

ip_port=("127.0.0.1",8000)

buffer_size=1024

tcp_client.connect(ip_port)

while True:

    msg=input("请输入待发送的消息：")

    #4：发消息

    tcp_client.send(msg.encode("utf-8"))

    # 5：收消息

    data=tcp_client.recv(buffer_size)

    print("收到服务端传来的消息",data.decode("utf-8"))

tcp_client.close()

客户端

1.2 服务端循环链接请求来收发消息

# 1：引入stock模块（导包）

import socket

#2：创建服务端对象

tcp_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

#3：绑定接口地址和端口号

ip_port=("127.0.0.1",8000)

back_log=5

buffer_size=1024

tcp_server.bind(ip_port)

#4: 开启监听(设置监听数量)

tcp_server.listen(back_log)

print("服务端开始运行了")

while True:

    # 5：准备接收消息

    conn, add = tcp_server.accept()

    while True:

        # 客户端断开连接的时候会报错

        try:

            # 6：接收消息

            data = conn.recv(buffer_size)

            # 据说Linux系统即使客户端断开连接也不会抛异常，这是需要手处理一下

            if not data:break

            print("客户端发送的消息是：", data.decode("utf-8"))

            # 7：发送消息

            conn.send(data.upper())

        except Exception:

            break

    # 8：关闭连接

    conn.close()

# 9：关闭服务端对象

tcp_server.close()

# 改进方向

#     1：把5和8放入到循环中，这样就可以实现多连接了

#     2：在内部连接中设置break方法

服务端

#1:引入模块

from socket import *

#2：创建对象

tcp_client = socket(AF_INET,SOCK_STREAM)

#3：建立连接

ip_port=("127.0.0.1",8000)

buffer_size=1024

tcp_client.connect_ex(ip_port)

while True:

    msg=input("请输入待发送的消息：")

    #如果不加这句，当输入换行时，服务器端会阻塞

    if len(msg)==0:

        continue

    #4：发消息

    tcp_client.send(msg.encode("utf-8"))

    # 5：收消息

    data=tcp_client.recv(buffer_size)

    print("收到服务端传来的消息",data.decode("utf-8"))

tcp_client.close()

客户端

1.3 从代码层面解决 “通常每个套接字地址(协议/网络地址/端口)只允许使用一次。”问题，在bind前加下一句代码

tcp_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

2：UDP协议

2.1  客户端服务端循环收发消息

# 1：引入stock模块（导包）

from socket import *

from time import strftime

#2：创建服务端对象

udp_server =socket(AF_INET,SOCK_DGRAM)

#3：绑定接口地址和端口号

ip_port=("127.0.0.1",8000)

back_log=5

buffer_size=1024

udp_server.bind(ip_port)

print("服务端开始运行了")

while True:

    while True:

        # 客户端断开连接的时候会报错

        try:

            # 6：接收消息

            data ,add= udp_server.recvfrom(buffer_size)

            print("客户端发送的消息是：", data.decode("utf-8"))

            # 7：发送消息

            time_fmt='%Y-%m-%d %X'

            data=strftime(time_fmt)

            udp_server.sendto(data.encode("utf-8"),add)

        except Exception:

            break

# 9：关闭服务端对象

udp_server.close()

# udp与tcp的不同之处

#     1：不需要连接s.listen()  监听和 s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

#     2：通过recvfrom()接收数据;sendto()发送数据

#     3：既然没有连接，也就无所谓谁先启动，或者客户端关闭后是否会引发异常等情况

服务端

#1:引入模块

from socket import *

#2：创建对象

udp_client = socket(AF_INET,SOCK_DGRAM)

#3：建立连接

ip_port=("127.0.0.1",8000)

buffer_size=1024

udp_client.connect_ex(ip_port)

while True:

    msg=input("按任意键获取时间：")

    # 4：发消息

    udp_client.sendto(msg.encode("utf-8"), ip_port)

    # 5：收消息

    data, add = udp_client.recvfrom(buffer_size)

    print("收到服务端传来的时间", data)

tcp_client.close()

客户端

3：练习

　　3.1 远程操作

　　需要使用subprocess模块　　

from socket import *

import subprocess

ip_port = ("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)

tcp_server.bind(ip_port)

tcp_server.listen(back_log)

while True:

    conn, add = tcp_server.accept()

    print(add)

    while True:

        try:

            cmd = conn.recv(buffer_size);

            if not cmd:

                conn.close()

                break

            res = subprocess.Popen(cmd.decode("utf-8"), shell=True,

                                   stderr=subprocess.PIPE,

                                   stdout=subprocess.PIPE,

                                   stdin=subprocess.PIPE,

                                   )

            err = res.stderr.read()

            if err:

                cmd_res = err

            else:

                cmd_res = res.stdout.read()

            # 发

            conn.send(cmd_res)

        except Exception as e:

            print(e)

            conn.close()

            break

    conn.close()

top_server.close()

TCP-Server-1.0

from socket import *

ip_port=("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:

    cmd = input(">>: ").strip()

    if not cmd:

        continue

    if cmd == "quit":

        break

    tcp_client.send(cmd.encode("utf-8"))

    cmd_res = tcp_client.recv(buffer_size)

    print(cmd_res.decode("gbk"))

tcp_client.close()

TCP-Client-1.0

　　会出现粘包现象：1：tcp-ip内部算法优化，会把短时间内几个小的send信息包在一起发送（tcp-ip的send本身没有界限）2：一次发送量大，一次接受不全

from socket import *

import subprocess

ip_port = ("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)

tcp_server.bind(ip_port)

tcp_server.listen(back_log)

while True:

    conn, add = tcp_server.accept()

    print(add)

    while True:

        try:

            cmd = conn.recv(buffer_size);

            if not cmd:

                conn.close()

                break

            res = subprocess.Popen(cmd.decode("utf-8"), shell=True,

                                   stderr=subprocess.PIPE,

                                   stdout=subprocess.PIPE,

                                   stdin=subprocess.PIPE,

                                   )

            err = res.stderr.read()

            if err:

                cmd_res = err

            else:

                cmd_res = res.stdout.read()

            # 为了解决粘包的问题，可以在发送的时候先把长度发过去

            length=str(len(cmd_res)).encode("utf-8")

            conn.send(length)

            # 如果直接这么发的话，会出现由于tcp优化出现的粘包情况。

            client_s = conn.recv(buffer_size);

            print("===>",client_s)

            if client_s==b"ready":

                conn.send(cmd_res)

        except Exception as e:

            print(e)

            conn.close()

            break

    conn.close()

top_server.close()

TCP-Server-2.0

from socket import *

ip_port=("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:

    cmd = input(">>: ").strip()

    if not cmd:

        continue

    if cmd == "quit":

        break

    tcp_client.send(cmd.encode("utf-8"))

    res_length=tcp_client.recv(buffer_size);

    #把获取到的长度转化成intleiixng

    cmd_res=""

    if res_length:

        tcp_client.send("ready".encode("utf-8"))

        res_length = int(res_length.decode("gbk"))

        print(res_length)

        # 循环遍历接收

        while len(cmd_res)<res_length:

            cur_res=tcp_client.recv(buffer_size).decode("gbk")

            cmd_res = cmd_res+cur_res

            print(cur_res)

tcp_client.close()

TCP-client-2.0

# 通过引入struct模块，编制一个报文长度，实现一次发送

import struct

from socket import *

import subprocess

ip_port = ("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)

tcp_server.bind(ip_port)

tcp_server.listen(back_log)

while True:

    conn, add = tcp_server.accept()

    print(add)

    while True:

        try:

            cmd = conn.recv(buffer_size);

            if not cmd:

                conn.close()

                break

            res = subprocess.Popen(cmd.decode("utf-8"), shell=True,

                                   stderr=subprocess.PIPE,

                                   stdout=subprocess.PIPE,

                                   stdin=subprocess.PIPE,

                                   )

            err = res.stderr.read()

            if err:

                cmd_res = err

            else:

                cmd_res = res.stdout.read()

            # 为了解决粘包的问题，可以在发送的时候先把长度发过去

            length=struct.pack("i",len(cmd_res))

            conn.send(length)

            conn.send(cmd_res)

            print(struct.unpack("i",length)[0])

        except Exception as e:

            print(e)

            conn.close()

            break

    conn.close()

top_server.close()

TCP-Service # 通过引入struct模块，编制一个报文长度，实现一次发送

# 通过引入struct模块，编制一个报文长度，实现一次发送

from socket import *

import struct

ip_port=("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:

    cmd = input(">>: ").strip()

    if not cmd:

        continue

    if cmd == "quit":

        break

    tcp_client.send(cmd.encode("utf-8"))

    #把获取到的长度转化成intleiixng

    cmd_res=b''

    res_length = tcp_client.recv(4)

    length=struct.unpack("i",res_length)[0]

    # 循环遍历接收

    while len(cmd_res) < length:

        cur_res = tcp_client.recv(buffer_size)

        cmd_res = cmd_res + cur_res

    print(cmd_res.decode("gbk"))

tcp_client.close()

TCP-client-# 通过引入struct模块，编制一个报文长度，实现一次发送

# 通过引入struct模块，实现一次发送

# 通过socketServer实现并发

import struct

from socket import *

import subprocess

import socketserver

ip_port = ("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

# 定义一个实例化的类，主要用于收发消息

class My_server(socketserver.BaseRequestHandler):

    def handle(self):

        try:

            while True:

                # 收消息

                cmd = self.request.recv(buffer_size)

                if not cmd: break

                res = subprocess.Popen(cmd.decode("utf-8"), shell=True,

                                       stderr=subprocess.PIPE, stdout=subprocess.PIPE, stdin=subprocess.PIPE)

                err = res.stderr.read()

                if err:

                    cmd_res = err

                else:

                    cmd_res = res.stdout.read()

                # 为了解决粘包的问题，可以在发送的时候先把长度发过去

                length = struct.pack("i", len(cmd_res))

                self.request.send(length)

                self.request.sendall(cmd_res)

        except Exception as e:

            print(e)

#通过线程创建对象

if __name__=="__main__":

    s=socketserver.ThreadingTCPServer(ip_port,My_server)

    s.serve_forever()

TCP-Service-4.0 通过socketServer实现并发

# 通过引入struct模块，编制一个报文长度，实现一次发送

from socket import *

import struct

ip_port=("127.0.0.1", 8089)

back_log = 5

buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)

tcp_client.connect(ip_port)

while True:

    cmd = input(">>: ").strip()

    if not cmd:

        continue

    if cmd == "quit":

        break

    tcp_client.send(cmd.encode("utf-8"))

    #把获取到的长度转化成intleiixng

    cmd_res=b''

    res_length = tcp_client.recv(4)

    length=struct.unpack("i",res_length)[0]

    # 循环遍历接收

    while len(cmd_res) < length:

        cur_res = tcp_client.recv(buffer_size)

        cmd_res = cmd_res + cur_res

    print(cmd_res.decode("gbk"))

tcp_client.close()

TCP-client-4.0 通过socketServer实现并发

4：FTP文件上传与下载

　　4.1实现客户端与服务端的调通

　　首先，创建两个文件夹FTP_server和FTP_client用于存放服务端和客户端的文件

　　4.1.1 FTP_server

　　创建一个bin文件，里面包含启动文件ftp_server.py

　　4.1.1.1 bin文件　　

# 主要用于启动

import os,sys

# 此时的路径是当前执行文件的路径，相当于当前的bin目录下寻找core中的main方法

PATH=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(PATH)

from core import main

if __name__ == '__main__':

    main.ArgvHandler()

ftp_server.py

　创建一个conf文件，里面包含系统的配置信息，settings.py

　　4.1.1.2 conf文件　　

IP="127.0.0.1"

PORT=8089

settings.py

　　创建一个core文件，里面包含系统的核心代码，main.py和server.py

　　4.1.1.3 core文件　　　　

import optparse

#引入optparse模块：其作用是把用户输入的命令匹配成字典形式,参考示例1

import socketserver

#引入socketserver模块：其作用是创建连接对象，启动ftp服务端

from conf import settings

#引入settings模块：其作用是通过配置文件拿到IP地址和端口号

from core import server

#引入server模块：其作用是把主要的逻辑放置到server中，

# 注意：由于main方法不是启动方法，启动方法在bin中，所以需要通过引用的方式实现

class ArgvHandler():

    #功能1：用户输入命令-启动ftp_server

    def __init__(self):

        self.op = optparse.OptionParser()

        options, args = self.op.parse_args()

        self.verify_args(options, args)

    def verify_args(self,options, args):

        #命令分发，通过反射来实现

        cmd=args[0]

        if hasattr(self,cmd):

            fun=getattr(self,cmd)

            fun()

    def start(self):

        print(" the server is working...")

        #启动方法

        s=socketserver.ThreadingTCPServer((settings.IP,settings.PORT),server.ServerHandler)

        s.serve_forever()

'''

示例1：---开始

self.op = optparse.OptionParser()

self.op.add_option("-s", "--server", dest="Server")

self.op.add_option("-p", "--port", dest="Port")

options, args = self.op.parse_args()

print(options)

print(options.Server)

print(args)

示例1在Terminal中输入命令

D:\Code\FTP\FTP_server\bin> python ftp_server.py -s 127.0.0.1 -p 8089 abc

示例1运行结果

{'Server': '127.0.0.1', 'Port': '8089'}

127.0.0.1

['abc']

示例1--结束

'''

main.py

import socketserver

class ServerHandler(socketserver.BaseRequestHandler):

    #主要用于服务端的处理方法

    def handle(self):

        print("ok")

server.py

　　创建一个logger文件，主要用户记录日志

　　4.1.1.4 logger文件　　

　   4.1.2 FTP_client

　　里面先简单设置一个ftp_client.py的测试客户端　　

import socket

sk=socket.socket()

sk.connect(("127.0.0.1",8089))

ftp_client.py

饮冰三年-人工智能-Python-19 Python网络编程饮冰三年-人工智能-Python-19 Python网络编程

相关文章