【醍醐灌顶】Python网络编程-简单示例

🌌 专注Golang，Python语言，云原生，人工智能领域得博主；
💜 过去经历的意义在于引导你，而非定义你；
📢 欢迎点赞 👍 收藏 ⭐留言！

01-tcp客户端程序开发

import socket


if __name__ == '__main__':
    # 1. 创建 socket 对象(socket.socket(ip 类型, 协议))
    # socket.AF_INET  ipv4     socket.AF_INET6  ipv6
    # socket.SOCK_STREAM tcp
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 固定的写法
    # 2. 和服务器建立连接(socket对象.connect((服务器 ip 地址, 端口号))) 类型是元组
    client_socket.connect(('192.168.155.43', 8080))
    print('连接建立成功......')
    # 3. 发送信息(socket对象.send(发送的信息))   类型  bytes
    send_data = '你好服务器,我是客户端 9527....'.encode()  # 默认是 utf-8
    client_socket.send(send_data)
    # 4. 接收对法发的信息(socket对象.recv(一次接收多少字节的数据))
    # 如果对方没有发送信息, recv 函数会在此阻塞等待
    buf = client_socket.recv(4096)
    try:
        print(buf.decode())
    except UnicodeDecodeError:
        print(buf.decode('gbk'))

    # 5. 关闭连接(socket对象.close())
    client_socket.close()

02-tcp 服务端程序开发

import socket


if __name__ == '__main__':
    # 1. 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2. 绑定 IP 和端口 bind((ip, 端口))  元组类型
    # server_socket.bind(('192.168.155.43', 9000))
    server_socket.bind(('', 9000))  # 绑定服务器中任意的一个网卡
    # 3. 设置监听, 参数,代表同时链接服务器的客户端数, 链接成功之后,就不占用这个名额
    server_socket.listen(128)
    print('等待连接中......')
    # 4. 阻塞等待客户端的链接, 返回一个元组 (新的socket, (客户端的ip, 端口))
    new_socket, ip_port = server_socket.accept()
    print(f'客户端 {ip_port} 连接了......')
    # 5. 新的 socket 收信息, 阻塞等待
    buf = new_socket.recv(4096)
    print('接收到的信息为', buf.decode())
    # 6. 新的 socket 发信息
    send_data = '信息已收到, over....'.encode()
    new_socket.send(send_data)
    # 7. 关闭
    new_socket.close()
    server_socket.close()

03-设置端口复用

import socket


if __name__ == '__main__':
    # 1. 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口复用
    # level 设置那个级别的 socket,  socket.SOL_SOCKET  当前的 socket
    # optname 设置什么内容(权限)   socket.SO_REUSEADDR  端口复用
    # value  设置为什么值, True
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 2. 绑定 IP 和端口 bind((ip, 端口))  元组类型
    # server_socket.bind(('192.168.155.43', 9000))
    server_socket.bind(('', 9000))  # 绑定服务器中任意的一个网卡
    # 3. 设置监听, 参数,代表同时链接服务器的客户端数, 链接成功之后,就不占用这个名额
    server_socket.listen(128)
    print('等待连接中......')
    # 4. 阻塞等待客户端的链接, 返回一个元组 (新的socket, (客户端的ip, 端口))
    new_socket, ip_port = server_socket.accept()
    print(f'客户端 {ip_port} 连接了......')
    # 5. 新的 socket 收信息, 阻塞等待
    buf = new_socket.recv(4096)
    print('接收到的信息为', buf.decode())
    # 6. 新的 socket 发信息
    send_data = '信息已收到, over....'.encode()
    new_socket.send(send_data)
    # 7. 关闭
    new_socket.close()
    server_socket.close()

04-判断客户端程序的断开

import socket


if __name__ == '__main__':
    # 1. 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 设置端口复用
    # level 设置那个级别的 socket,  socket.SOL_SOCKET  当前的 socket
    # optname 设置什么内容(权限)   socket.SO_REUSEADDR  端口复用
    # value  设置为什么值, True
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 2. 绑定 IP 和端口 bind((ip, 端口))  元组类型
    # server_socket.bind(('192.168.155.43', 9000))
    server_socket.bind(('', 9000))  # 绑定服务器中任意的一个网卡
    # 3. 设置监听, 参数,代表同时链接服务器的客户端数, 链接成功之后,就不占用这个名额
    server_socket.listen(128)
    print('等待连接中......')
    # 4. 阻塞等待客户端的链接, 返回一个元组 (新的socket, (客户端的ip, 端口))
    new_socket, ip_port = server_socket.accept()
    print(f'客户端 {ip_port} 上线了......')
    # 5. 新的 socket 收信息, 阻塞等待
    # 当对方的 socket close 之后, 自己的 socket 不再阻塞了, recv 接收的内容是 空字符串, 长度为 0
    buf = new_socket.recv(4096)
    if buf:
        print('接收到的信息为', buf.decode())
        # 6. 新的 socket 发信息
        send_data = '信息已收到, over....'.encode()
        new_socket.send(send_data)
    else:
        print(f'客户端{ip_port} 下线了.....')
    # 7. 关闭
    new_socket.close()
    server_socket.close()

05-多任务版本的服务器

import socket
import threading


def handle_client_request(n_socket, client_ip_port):
    # 5. 新的 socket 收信息, 阻塞等待
    # 当对方的 socket close 之后, 自己的 socket 不再阻塞了, recv 接收的内容是 空字符串, 长度为 0
    while True:
        buf = n_socket.recv(4096)
        if buf:
            print(f'接收到{client_ip_port}的信息:', buf.decode())
            # 6. 新的 socket 发信息
            send_data = '信息已收到, over....'.encode()
            n_socket.send(send_data)
        else:
            print(f'客户端{client_ip_port} 下线了.....')
            break
    # 7. 关闭
    n_socket.close()


if __name__ == '__main__':
    # 1. 创建 socket 对象
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    # 2. 绑定 IP 和端口 bind((ip, 端口))  元组类型
    server_socket.bind(('', 9000))  # 绑定服务器中任意的一个网卡
    # 3. 设置监听, 参数,代表同时链接服务器的客户端数, 链接成功之后,就不占用这个名额
    server_socket.listen(128)
    print('等待连接中......')
    while True:  # 循环等待客户端的链接
        new_socket, ip_port = server_socket.accept()
        print(f'客户端 {ip_port} 上线了......')
        # 创建线程,执行任务
        sub_thread = threading.Thread(target=handle_client_request, args=(new_socket, ip_port))
        # 启动线程
        sub_thread.start()

    server_socket.close()  # 关闭监听的 socket

06-gevent 的使用

# 1. 导入 gevent
import gevent


def sing(singer, song):
    for i in range(5):
        print(f'{singer} 正在唱歌 {song}......')
        # gevent 遇到 I/O 耗时阻塞操作,会切换协程
        gevent.sleep(0.1)  # 切换协程


def dance(dancer, name):
    for i in range(8):
        print(f"{dancer} 正在跳舞{name}------")
        gevent.sleep(0.1)


if __name__ == '__main__':
    # 2. 创建协程对象
    g1 = gevent.spawn(sing, '学友', '冰雨')
    g2 = gevent.spawn(dance, '小春', 'xxxxx')

    # 3. 阻塞等待协程对象  join, gevent 遇到 I/O 耗时阻塞操作,会切换协程
    g1.join()
    g2.join()

07-补丁

# 1. 导入 gevent
import gevent
import time
from gevent import monkey

monkey.patch_all()  # 使用 gevent 中模块替换系统中的模块


def sing(singer, song):
    for i in range(5):
        print(f'{singer} 正在唱歌 {song}......')
        # gevent 遇到 I/O 耗时阻塞操作,会切换协程
        # gevent.sleep(0.1)  # 切换协程
        time.sleep(0.1)


def dance(dancer, name):
    for i in range(8):
        print(f"{dancer} 正在跳舞{name}------")
        # gevent.sleep(0.1)
        time.sleep(0.1)


if __name__ == '__main__':
    # 2. 创建协程对象
    g1 = gevent.spawn(sing, '学友', '冰雨')
    g2 = gevent.spawn(dance, '小春', 'xxxxx')

    # 3. 阻塞等待协程对象  join, gevent 遇到 I/O 耗时阻塞操作,会切换协程
    g1.join()
    g2.join()