python网络编程

目录

服务端不随客户端发生变化

1，第一代网络编程（服务器只能接受数据）

2，第二代网络编程（服务器可以接受多个客户端的消息）

3，第三代网络编程（服务器可以和多个客户建立联系并发送短信）

4，第四代网络编程（服务器可以自动回复客户端，当某个客户端发送end时结束链接，但服务端不会结束）

5，网络编程服务端建立过程

6，网络编程使用套接字中   accept简介

7，网络编程使用套接字中   connect简介

---

服务端不随客户端发生变化

"""
    客户端
"""

from socket import *
from threading import Thread


def recv_data():
    while True:
        # 接受服务器数据
        recv_data = client_socket.recv(1024)
        recv_content = recv_data.decode('gbk')
        print(f'服务器说：{recv_content}')
        if recv_content == 'end':
            print('结束接受消息')
            break


def send_data():
    while True:
        # 给服务器发消息
        msg = input('>')
        client_socket.send(msg.encode('gbk'))
        if msg == 'end':
            break


if __name__ == '__main__':
    client_socket = socket(AF_INET, SOCK_STREAM)
    client_socket.connect(('192.168.9.7', 6551))  # 链接无线局域网ip4

    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)

    t1.start()
    t2.start()

    t1.join()
    t2.join()

    client_socket.close()

1，第一代网络编程（服务器只能接受数据）

"""
    此服务器只能链接一个用户,并且不能发送消息
"""

from socket import *
from threading import Thread


def recv_data():
    while True:
        recv_data = client_socket.recv(1024)  # 最大接受1024字符
        recv_content = recv_data.decode('gbk')
        print(f'客户端：{recv_content},来自：{client_info}')
        if recv_content == 'end':
            print('结束接受消息')
            break


def send_data():
    while True:
        msg = input('>')
        client_socket.send(msg.encode('gbk'))
        if msg == 'end':
            print('结束发送消息')
            break


if __name__ == '__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)  # 建立TCP套接字
    server_socket.bind(('192.168.43.88', 8899))  # 本机监听8899端口  链接无线局域网ip4
    server_socket.listen(5)
    print('等待接受链接')
    client_socket, client_info = server_socket.accept()
    print('一个用户端建立连接成功')
    t1 = Thread(target=recv_data)
    t2 = Thread(target=send_data)
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    client_socket.close()
    server_socket.close()

2，第二代网络编程（服务器可以接受多个客户端的消息）

"""
    此服务器可以链接多个客户
"""

from socket import *
from threading import Thread

"""
    服务器只能接受不能发送
"""

def handle_client(client_socket, client_info):  # 建立套接字
    while True:
        recv_data = client_socket.recv(1024)  # 最大限制1024字符
        recv_content = recv_data.decode("gbk")
        print(f"客户端说：{recv_content}，来自：{client_info}")
        if recv_content == 'end':
            print("结束接收消息!!!")
            break

    client_socket.close()



if __name__ == '__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)
    server_socket.bind(("192.168.9.7", 8894))  # 本机监听8899端口  链接无线局域网ip4
    server_socket.listen(5)
    print("等待接受连接")

    while True:
        client_socket, client_info = server_socket.accept()
        print("一个客户端建立连接成功！")
        t = Thread(target=handle_client, args=(client_socket, client_info))
        t.start()

3，第三代网络编程（服务器可以和多个客户建立联系并发送短信）

"""
    服务器既可以接受也可以发送
"""
from socket import *
from threading import Thread


def handle_client(client_socket, client_info):
    while True:
        recv_data = client_socket.recv(1024)
        recv_content = recv_data.decode("gbk")
        print(f"客户端说: {recv_content},来自：{client_info}")
        if recv_content == 'end':
            print("结束接收消息!!!")
            break

        msg = input("回复客户端消息: ")
        client_socket.send(msg.encode("gbk"))
        if msg == 'end':
            print('结束发送消息！')
            break

    client_socket.close()


if __name__ == '__main__':
    server_socket = socket(AF_INET, SOCK_STREAM)
    server_socket.bind(("192.168.9.7", 8894))  # 本机监听8899端口  链接无线局域网ip4
    server_socket.listen(5)
    print("等待接受连接")

    while True:
        client_socket, client_info = server_socket.accept()
        print("一个客户端建立连接成功！")
        t = Thread(target=handle_client, args=(client_socket, client_info))
        t.start()

4，第四代网络编程（服务器可以自动回复客户端，当某个客户端发送end时结束链接，但服务端不会结束）

"""
    实现服务器一对多个用户，自动回复，客户输入end后断开与服务的链接
"""

from socket import *
from threading import Thread


def recv_data(client_socket, client_info):
    while True:
        # 最大字节1024
        recv_data = client_socket.recv(1024)
        recv_content = recv_data.decode('gbk')
        print(f"客户端{recv_content},来自{client_info}")
        client_socket.send("你好，我是people".encode('gbk'))
        if recv_content == 'end':
            client_socket.send('end'.encode('gbk'))
            print("结束接收消息")
            break


def handler(server_socket):
    while True:
        client_socket, client_info = server_socket.accept()
        t1 = Thread(target=recv_data, args=(client_socket, client_info))
        t1.start()
        t1.join()


if __name__ == '__main__':
    # 建立套接字
    server_socket = socket(AF_INET, SOCK_STREAM)
    # 本机监听6551端口
    server_socket.bind(('192.168.9.7', 6551))
    server_socket.listen(5)
    print('等待链接')
    handler(server_socket)
    server_socket.close()

5，网络编程服务端建立过程

        1，创建TCP套接字：server_socket = socket(AF_INET, SOCK_STREAM)

        2，配置监听端口，设置每秒监听的个数：

                server_socket.bind(("127.0..1"，8899))# 本机监听8899端口

                server_socket.listen(5)

        3，连接：配置结束后等待用户连结发送数据

        4，解析用户发送的数据：

                client_socket, client_info = server_socket.accept()

                recv_data = cLient_socket.recv(1024) # 最大接收1024字节

                print(f"收到信息:{recv_data.decode('gbk')},来自:{client_info}")

6，网络编程使用套接字中   accept简介

accept函数主要用于服务器端，一般位于listen函数之后，默认会阻塞进程，直到有一个客户请求连接，建立好连接后，它返回的一个新的套接字 socketfd_new ，此后，服务器端即可使用这个新的套接字socketfd_new与该客户端进行通信，而sockfd 则继续用于监听其他客户端的连接请求。

7，网络编程使用套接字中   connect简介

connect这一步位于客户端的第二步，调用connect阻塞客户程序，传输层实体开始建立连接，当连接建立完成时，取消阻塞；

该函数作用：向服务端发起连接请求