Python进阶：网络编程

€orn.

已于 2023-03-12 18:41:38 修改

阅读量41

点赞数 1

分类专栏： Python进阶文章标签：网络 python tcp/ip

于 2023-03-12 16:54:58 首次发布

本文链接：https://blog.csdn.net/weixin_45663740/article/details/129477861

版权

Python进阶专栏收录该内容

7 篇文章 0 订阅

订阅专栏

第二章：网络编程

网络：

· 信息连接互通的虚拟平台

IP地址：

· IPV4和IPV6
· 具体网络知识就不多说了

端口和端口号：

· 端口：传输数据的通道
· 端口号：用来管理区分不同端口的号码

端口号的分类：

· 略~

socket：

· socket又称套接字，是程序之间通信的一个工具，程序通信必须基于socket

TCP：

· TCP传输协议（Transmission Control Protocol），面向连接的、可靠的、基于字节流的传输
· TCP可靠传输：
    发送应答机制
    超时重传
    错误校验
    流量控制和阻塞管理

Python3编码转换：

· 使用编解码函数转化为二进制或者特定编码数据
    encode 编码
    decode 解码

TCP网络应用程序开发：

· TCP客户端程序开发
· TCP服务端程序开发

TCP客户端开发流程：

1.创建客户端socket对象
2.和服务器端socket建立连接
3.发送数据
4.接收数据
5。关闭客户端套接字

socket类：

# socket module
import socket
# 创建客户端socket对象使用socket类
# AddressFamily有AF_INET,AF_UNIX
socket.socket(AddressFamily, Type)
# 其中AddressFamily为IP地址有v4和v6，Type为传输协议类型

开发客户端需要用到的函数：

· connect 和服务器建立socket连接
· send 发送数据
· recv 接收数据
· close 关闭连接

TCP服务端开发流程：

1.创建服务端套接字对象
2.绑定IP地址和端口号
3.设置监听
4.等待客户端的连接请求
5.接收数据
6.发送数据
7。关闭套接字

开发服务端要用到的函数：

· bind 绑定IP地址和端口号
· listen 设置监听
· accept 等待客户端的连接请求
· send 发送数据
· recv 接收数据

TCP应用需要注意的点：

· 客户端想要与服务端通信，必须先建立连接
· 客户端一般不需要绑定端口号
· 服务端必须绑定端口号，否则客户端找不到服务端程序
· listen后的套接字是被动套接字，只负责接受新的客户连接请求，不能收发消息
· 连接成功后，服务端会产生新的套接字，收发客户端消息使用该套接字
· 关闭accept返回的套接字意味着和这个客户端已经通信完毕
· 当客户端的套接字调用close后，服务端的recv会解阻塞，返回的数据长度为0，服务端通过此判断客户端
  是否下线，反之服务端关闭套接字，客户端的recv也会阻塞，返回的数据长度为0

socket的send、recv原理剖析

· 创建socket对象时会有一个发送缓冲区和接收缓冲区
· send函数，必须先通过网卡，系统先将数据写入缓冲，然后网卡读入发送出去
· recv函数，原理相反，通过网卡获取数据放入缓冲，然后系统在进行接受

实战部分：

首先我们了过一遍TCP/IP流程，这个流程也是我们编写程序的流程，如下：

请添加图片描述

· 其实我们可以注意到，都需要socket对象，博主关于网络编程的内容不算特别懂
· 所以以我的理解来看，就是一个socket对象封装了我们需要的各种网络编程中的方法
· python中正是依赖此对象，完成程序之间的通信，因此必不可少

因此先开始编写客户端，实际开发中的客户端，也没有这么简单，但是如果看完后面服务端的进阶后
我相信大家也会明白，客户端实际上应该怎么写
客户端新手教程如下：

import socket
if __name__ == '__main__':
    # 建立一个IPV4地址，TCP协议socket对象
    # SOCK_STREAM为TCP-IP协议，SOCK_DGRAM为UDP协议
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 想要连接的地址，必须以元组形式传参
    # 元组第一个参数代表IP地址，只写""代表本机IP
    # 元组第二个参数代表端口号
    client.connect(("", 8080))
    # 然后就可以开始发送信息了
    client.send("hello TCP-IP!")
    # 如果服务端有响应，则开始接收数据
    # 参数代表接受字节数
    recv_data = client.recv(1024)
    # 关闭socket
    client.close()

然后就开始编写服务端，这里我会分三种代码编写，逐步进阶的方式
第一种，建立连接后，唯一程序，短暂收发，通俗地来说就是服务端的新手教程代码：

'''
    第一种，建立连接后，唯一程序，短暂收发，通俗地来说就是服务端的新手教程代码
'''
import socket

if __name__ == '__main__':
    # 同样的先创建socket对象
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定端口，其实与客户端的connect非常像，只不过作为服务端，我们是接收方
    server.bind(("", 8080))
    # 设置监听最大数量，128就是最大可监听数
    server.listen(128)
    # 然后接受客户端socket对象，并获取IP地址，类似实际中写邮件，必须要知道你的地址嘛
    client_socket, ip_port = server.accept()
    # 可以打印出来看看，方便debug
    print(f"客户端地址：{ip_port}")
    # 既然建立了连接，那我肯定要看看你想干啥，因此接受客户端的数据请求
    # 这个地方为啥是用客户端的socket呢？
    # 可以理解为在TCP/IP协议上，抽象出了一个socket层，用来完成TCP/IP的数据传输
    # 而且正因为面向连接，而服务端也不仅只连接一个地方，而是地方1、地方2、……地方n
    # 因此，如果是连接多个对象，作为服务端我只要一个大socket
    # 但是这个大socket，包含许多小socket（客户端）
    # 又因为面向连接，所以服务端单独的使用每一个客户端socket进行单独的连接
    # 既确保了稳定，单独的抽象又保证互不影响，而且安全
    recv_date = client_socket.recv()
    print(f"接收到的数据：{recv_date}")
    # TCP要求收到信息要回复，因此我们需要发送一个收到的信息
    client_socket.send("收到!".encode())
    client_socket.close()
    server.close()

第二种，建立连接后，唯一程序，长期收发：

import socket
'''
    第二种，建立连接后，唯一程序，长期收发：
'''
if __name__ == '__main__':
    # 同样的先创建socket对象
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定端口，其实与客户端的connect非常像，只不过作为服务端，我们是接收方
    server.bind(("", 8080))
    # 设置监听最大数量，128就是最大可监听数
    server.listen(128)
    while True:
        # 然后接受客户端socket对象，并获取IP地址，类似实际中写邮件，必须要知道你的地址嘛
        client_socket, ip_port = server.accept()
        # 可以打印出来看看，方便debug
        print(f"客户端地址：{ip_port}")
        recv_date = client_socket.recv()
        print(f"接收到的数据：{recv_date}")
        # TCP要求收到信息要回复，因此我们需要发送一个收到的信息
        client_socket.send("收到!".encode())
        client_socket.close()
    server.close()

第三种，建立连接后，多个程序，长期收发：

import threading
import socket

'''
    如果想要和多个程序通信，并且不被打扰，利用上一章所学，可以利用多线程的知识
'''


def handle_client(client_socket):
    recv_date = client_socket.recv()
    print(f"接收到的数据：{recv_date}")
    # TCP要求收到信息要回复，因此我们需要发送一个收到的信息
    client_socket.send("收到!".encode())
    client_socket.close()


if __name__ == '__main__':
    # 同样的先创建socket对象
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 绑定端口，其实与客户端的connect非常像，只不过作为服务端，我们是接收方
    server.bind(("", 8080))
    # 设置监听最大数量，128就是最大可监听数
    server.listen(128)
    while True:
        # 然后接受客户端socket对象，并获取IP地址，类似实际中写邮件，必须要知道你的地址嘛
        client_socket, ip_port = server.accept()
        # 可以打印出来看看，方便debug
        print(f"客户端地址：{ip_port}")
        # 建立线程，开启线程，剩下的就交给系统吧
        thread = threading.Thread(target=handle_client, args=(client_socket, ))
        thread.start()
    
    # 按理来说，在关闭服务端之前，应该要回收线程，但博主技术有限
    # 以后学到了，回来补上（狗头）    
    
    server.close()

思考环节：

为什么要用客户端的socket进行收发？

# 然后接受客户端socket对象，并获取IP地址，类似实际中写邮件，必须要知道你的地址嘛
    client_socket, ip_port = server.accept()
    # 可以打印出来看看，方便debug
    print(f"客户端地址：{ip_port}")
    '''
        既然建立了连接，那我肯定要看看你想干啥，因此接受客户端的数据请求
        那这个地方为啥是用客户端的socket呢？
        可以理解为在TCP/IP协议上，抽象出了一个socket层，用来完成面向连接的数据传输
        而且正因为面向连接，而服务端也不仅只接受一个地方的数据
        因此，如果是连接多个对象，作为服务端我只要一个大socket
        但是这个大socket，包含许多小socket（客户端）
        又因为面向连接，所以服务端单独的使用每一个客户端socket进行单独的连接
        既确保了稳定，单独的抽象又保证互不影响，而且安全
    '''
    recv_date = client_socket.recv()
而服务端也不仅只接受一个地方的数据
        因此，如果是连接多个对象，作为服务端我只要一个大socket
        但是这个大socket，包含许多小socket（客户端）
        又因为面向连接，所以服务端单独的使用每一个客户端socket进行单独的连接
        既确保了稳定，单独的抽象又保证互不影响，而且安全
    '''
    recv_date = client_socket.recv()

如果对socket感兴趣的话，可以参考一下这位知乎博主的回答，非常的清晰易懂了
https://www.zhihu.com/question/29637351/answer/1934423848

€orn.

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python进阶：网络编程

Python进阶第二期：网络编程只要是进行开发的人，都离不开这个知识python种网络编程，其实socket的编程，因此掌握socket即可
复制链接

扫一扫

专栏目录