• UDP网络通信（发送端+接收端）实例 —— Python

    简介
    在网络通信编程中，用的最多的就是UDP和TCP通信了，原理这里就不分析了，网上介绍也很多，这里简单列举一下各自的优缺点和使用场景

    通信方式优点缺点适用场景
    UDP及时性好，快速视网络情况，存在丢包

    与嵌入式设备通信，实时控制

    场景

    TCP丢包会自动重发，理论上不用担心丢包问题延时相对大一些

    通信可靠性场景，比如IoT设备

    控制，状态同步

    一、socket
    我们要进行网络通信，那么就要用到socket，socket即网络套接字，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。
    在 Python 中，使用socket 模块的函数 socket 就可以创建一个socket对象，socket()函数的参数分别有family, type, proto。

    1.其中family参数是指协议域，又称为协议族（family），常用的协议族有，AF_INET、AF_INET6、...等等，AF_INET指ipv4，AF_INET6即为ipv6；
    2.然后是type，type指定socket类型，有SOCK_STREAM（流式套接字，主要用于 TCP 协议）和SOCK_DGRAM（数据报套接字，主要用于 UDP 协议）等等；
    3.proto就是指定的协议，常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议，但是type和proto不可以随意组合，当proto参数为0或者不填时，会自动选择type类型对应的默认协议。

    二、UDP发送数据
    首先我们要导入socket包

    import socket

    创建一个udp套接字，ipv4协议，使用SOCK_DGRAM参数，不填proto，就会默认自动选择udp协议；

    1. # 1、创建一个UDP套接字
    2. udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    然后我们把要接收数据的那一端的ip地址和端口号放在一个元组里准备好

    1. ​​​# 2. 准备接收方的地址和端口，'127.0.0.1:9999'表示目的ip地址，9999表示目的端口号
    2. udp_addr = ('127.0.0.1', 9999)  # 注意这是一个元组，其中ip地址是字符串，端口号是数字​

      准备好后就可以使用sendto函数进行发送了，要注意，需要对字符串进行编码才可以发送

    1. # 3. 发送数据到指定的ip和端口
    2. udp_socket.sendto("Hello,I am a UDP socket.".encode('utf-8'), dest_addr)

    发送完就可以关闭套接字了

    1. # 4. 关闭套接字
    2. udp_socket.close()

    例程一：UDP server端，UDP数据接收

    1. ​
    2. ​
    3. #!/usr/bin/python3
    4. # -*- coding: utf-8 -*-
    5.  
    6. """
    7. udp通信例程：udp server端，修改udp_addr元组里面的ip地址，即可实现与目标机器的通信，
    8. 此处以单机通信示例，ip为127.0.0.1，实际多机通信，此处应设置为目标客户端ip地址
    9. """
    10.  
    11. from time import sleep
    12. import socket
    13.  
    14.  
    15. def main():
    16.     # udp 通信地址，IP+端口号
    17.     udp_addr = ('127.0.0.1', 9999)
    18.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    19.     # 绑定端口
    20.     udp_socket.bind(udp_addr)
    21.  
    22.     # 等待接收对方发送的数据
    23.     while True:
    24.         recv_data = udp_socket.recvfrom(1024)  # 1024表示本次接收的最大字节数
    25.         # 打印接收到的数据
    26.         print("[From %s:%d]:%s" % (recv_data[1][0], recv_data[1][1], recv_data[0].decode("utf-8")))
    27.  
    28. if __name__ == '__main__':
    29.     print("当前版本： ", __version__)
    30.     print("udp server ")
    31.     main()
    32.  
    33. ​
    34.  
    35. ​

     代码解析 

    1.socket函数中第二个参数就是通信类型，此处SOCK_DGRAM 就是指定使用UDP通信
    2.服务端需要使用bind函数绑定端口，客户端不需要，因为客户端发送的时候已经带了端口参数

    例程二：UDP client端，UDP数据发送

    1. #!/usr/bin/python3
    2. # -*- coding: utf-8 -*-
    3.  
    4. """
    5. udp通信例程：udp client端，修改udp_addr元组里面的ip地址，即可实现与目标机器的通信，
    6. 此处以单机通信示例，ip为127.0.0.1，实际多机通信，此处应设置为目标服务端ip地址
    7. """
    8.  
    9. from time import sleep
    10. import socket
    11.  
    12. def main():
    13.     # udp 通信地址，IP+端口号
    14.     udp_addr = ('127.0.0.1', 9999)
    15.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    16.  
    17.     # 发送数据到指定的ip和端口,每隔1s发送一次，发送10次
    18.     for i in range(10):
    19.         udp_socket.sendto(("Hello,I am a UDP socket for: " + str(i)) .encode('utf-8'), udp_addr)
    20.         print("send %d message" % i)
    21.         sleep(1)
    22.  
    23.     # 5. 关闭套接字
    24.     udp_socket.close()
    25.  
    26.  
    27. if __name__ == '__main__':
    28.     print("当前版本： ", __version__)
    29.     print("udp client ")
    30.     main()


    例程三：多线程实现UDP数据收发

    1. #!/usr/bin/python3
    2. # -*- coding: utf-8 -*-
    3.  
    4. """
    5. python多线程通信
    6. """
    7.  
    8. from time import sleep
    9. import socket
    10. import threading
    11.  
    12. # 定义全局变量
    13. t1_count = 0
    14. t2_count = 0
    15.  
    16.  
    17. def udp_received_hundle(s):
    18.     global t1_count
    19.     print("this is thread 1 running")
    20.     while True:
    21.         t1_count += 1
    22.         print("thread 1 第 %s 次运行" % t1_count)
    23.         recv_data = s.recvfrom(1024)  # 1024表示本次接收的最大字节数
    24.         # 打印接收到的数据
    25.         print("[From %s:%d]:%s" % (recv_data[1][0], recv_data[1][1], recv_data[0].decode("utf-8")))
    26.  
    27.  
    28. def udp_send_hundle(s):
    29.     global t2_count
    30.     print("this is thread 2 running")
    31.     while True:
    32.         t2_count += 1
    33.         print("")
    34.         print("thread 2 第 %s 次运行" % t2_count)
    35.         s.sendto(("Hello,I am a UDP socket for: " + str(t2_count)).encode('utf-8'), udp_addr)
    36.         print("send %d message" % t2_count)
    37.         print("")
    38.         sleep(1)
    39.  
    40.  
    41. if __name__ == '__main__':
    42.     print("当前版本： ", __version__)
    43.     # 初始化
    44.     # udp 通信地址，IP+端口号
    45.     udp_addr = ('127.0.0.1', 9999)
    46.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    47.     # 绑定端口:
    48.     udp_socket.bind(udp_addr)
    49.  
    50.     # 定义线程
    51.     thread_list = []
    52.     t1 = threading.Thread(target=udp_received_hundle, args=(udp_socket, ))
    53.     thread_list.append(t1)
    54.     t2 = threading.Thread(target=udp_send_hundle, args=(udp_socket, ))
    55.     thread_list.append(t2)
    56.  
    57.     for t in thread_list:
    58.         t.setDaemon(True)
    59.         t.start()
    60.     for t in thread_list:
    61.         t.join()
    62.  
    63.     print("exit all task.")
    64.     print('all process end.')

    代码解析
    这里用到了多线程，虽然python中的多线程是假的多线程，实际上是一个线程分时复用，这里我们不深究，如果平常用到也就几个小任务跑一跑，抄我这个作业就ok。
    多线程实际上是从t.join()后才开始正式运行的，这里一定要注意，不能漏了这个函数。
    udp的收发与上面的例程几乎是一样的。
    代码运行效果如下

    1. 当前版本：  1.0.0
    2. this is thread 1 running
    3. thread 1 第 1 次运行
    4. this is thread 2 running
    5.  
    6. thread 2 第 1 次运行
    7. send 1 message
    8.  
    9. [From 127.0.0.1:9999]:Hello,I am a UDP socket for: 1
    10. thread 1 第 2 次运行
    11.  
    12. thread 2 第 2 次运行
    13. send 2 message
    14.  
    15. [From 127.0.0.1:9999]:Hello,I am a UDP socket for: 2
    16. thread 1 第 3 次运行
    17.  
    18. thread 2 第 3 次运行
    19. send 3 message
    20.  
    21. [From 127.0.0.1:9999]:Hello,I am a UDP socket for: 3
    22. thread 1 第 4 次运行
    23.  
    24. thread 2 第 4 次运行
    25. send 4 message
    26.  
    27. [From 127.0.0.1:9999]:Hello,I am a UDP socket for: 4
    28. thread 1 第 5 次运行
    29.  
    30. thread 2 第 5 次运行
    31. send 5 message

     使用网络调试助手，测试程序
    注意，如果不是在本机windows系统上运行python程序，在Ubuntu虚拟机或者其他局域网内的机器上运行，要把windows的防火墙关了！！！
    然后我们让其每隔一秒发送一次，发送10次，发送成功

    完整代码：

    1. ​#!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3. # Author: William
    4.  
    5. import socket,time
    6.  
    7. def main():
    8.     # 1、创建一个UDP套接字
    9.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    10.  
    11.     # 2. 准备接收方的地址和端口，'192.168.0.107'表示目的ip地址，8080表示目的端口号
    12.     dest_addr = ('192.168.8.226', 12341)  # 注意这是一个元组，其中ip地址是字符串，端口号是数字
    13.  
    14.     # 3. 发送数据到指定的ip和端口
    15.     for i in range(10):
    16.         udp_socket.sendto("Hello,I am a UDP socket.".encode('utf-8'), dest_addr)
    17.         time.sleep(1)
    18.  
    19.     # 4. 关闭套接字
    20.     udp_socket.close()
    21.  
    22. if __name__ == '__main__':
    23.     main()
    24.  
    25. ​

    三、UDP接收数据
    在之前发送数据的时候，我们可以看到，其端口号是一直在变得，那么我们要接收数据，就需要知道其端口号是什么，所以我们要先固定一个端口号，使用bind函数

    1. # 2. 绑定本地的相关信息，如果不绑定，则系统会随机分配一个端口号
    2. local_addr = ('', 12344)  # ip地址和端口号，ip一般不用写，表示本机的任何一个ip
    3. udp_socket.bind(local_addr)

    接收数据使用recvfrom函数，其参数为接收的最大数据长度

    1. # 3. 等待接收对方发送的数据
    2. recv_data = udp_socket.recvfrom(1024)  # 1024表示本次接收的最大字节数

    接收完后将其打印出来：

    1. # 4、打印接收到的数据
    2. print(recv_data)

    运行，通过网络调试助手发送数据

     可以看到，打印出来的信息是一个元组，第一项接收到的字符串，第二项也是一个元组，包含对方的IP地址和端口号
    完整代码：

    1. #!/usr/bin/env python
    2. # -*- coding:utf-8 -*-
    3. # Author: William
    4.  
    5. import socket,time
    6.  
    7. def main():
    8.     # 1、创建一个UDP套接字
    9.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    10.  
    11.     # 2. 绑定本地的相关信息，如果不绑定，则系统会随机分配一个端口号
    12.     local_addr = ('', 12344)  # ip地址和端口号，ip一般不用写，表示本机的任何一个ip
    13.     udp_socket.bind(local_addr)
    14.  
    15.     # 3. 等待接收对方发送的数据
    16.     recv_data = udp_socket.recvfrom(1024)  # 1024表示本次接收的最大字节数
    17.  
    18.     # 4、打印接收到的数据
    19.     print(recv_data)
    20.  
    21.     # 5. 关闭套接字
    22.     udp_socket.close()
    23.  
    24. if __name__ == '__main__':
    25.     main()


    四、UDP收发数据
    实现这样一个功能，通过UDP发送10次消息，然后等待接收，将接收的数据及其来源打印出来：

    完成代码：

    1. ​
    2. #!/usr/bin/env python
    3. # -*- coding:utf-8 -*-
    4. # Author: William
    5.  
    6. import socket,time
    7.  
    8. def main():
    9.     # 1、创建一个UDP套接字
    10.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    11.  
    12.     # 2. 绑定本地的相关信息，如果不绑定，则系统会随机分配一个端口号
    13.     udp_socket.bind(('', 12344))
    14.  
    15.     # 3. 发送数据到指定的ip和端口,每隔1s发送一次，发送10次
    16.     for i in range(10):
    17.         udp_socket.sendto("Hello,I am a UDP socket.".encode('utf-8'), ('192.168.8.226', 12341))
    18.         time.sleep(1)
    19.  
    20.     # 4. 等待接收对方发送的数据
    21.     while(True):
    22.         recv_data = udp_socket.recvfrom(1024)
    23.         # 打印接收到的数据
    24.         print("[From %s:%d]:%s"%(recv_data[1][0],recv_data[1][1],recv_data[0].decode("utf-8")))
    25.  
    26.     # 5. 关闭套接字
    27.     udp_socket.close()
    28.  
    29. if __name__ == '__main__':
    30.     main()
    31.  
    32. ​


    五、同时收发数据
    现在实现这样一个功能，即运行程序，然后在控制台输入字符串发送出去，同时，还可以接收数据，我使用多线程来实现这个程序，不过要实现方便接收，我们在程序的开始，将IP地址和端口号打印出来，实现效果如下：

    实现代码：

    1. ​
    2. #!/usr/bin/env python
    3. # -*- coding:utf-8 -*-
    4. # Author: William
    5.  
    6. import socket,time,threading
    7.  
    8. def recv_thread(socket):
    9.     # 等待接收对方发送的数据
    10.     while(True):
    11.         try:
    12.             recv_data = socket.recvfrom(1024)
    13.             # 打印接收到的数据
    14.             print("[From %s:%d]:%s"%(recv_data[1][0],recv_data[1][1],recv_data[0].decode("utf-8")))
    15.         except Exception:
    16.             break
    17.  
    18. def main():
    19.     # 1、创建一个UDP套接字
    20.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    21.  
    22.     # 2、绑定本地的相关信息，如果不绑定，则系统会随机分配一个端口号
    23.     udp_socket.bind(('', 12344))
    24.  
    25.     # 3、打印本机ip地址和端口号
    26.     print("local ipaddr and port->",socket.gethostbyname(socket.gethostname())+":12344")
    27.  
    28.     # 4、创建一个线程，用来接收数据
    29.     t = threading.Thread(target=recv_thread, args=(udp_socket,))
    30.     t.start()
    31.  
    32.     # 5、等待输入数据,然后发送出去，直到输入的数据为'quit'
    33.     while(True):
    34.         print("please input a string.input 'quit' to quit.")
    35.         send_data = input()
    36.         if send_data == "quit":
    37.             break
    38.         else:
    39.             udp_socket.sendto(send_data.encode('utf-8'), ("192.168.8.226",12341))
    40.  
    41.     # 6、关闭套接字
    42.     udp_socket.close()
    43.  
    44. def main1():
    45.     # 1、创建一个UDP套接字
    46.     udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    47.  
    48.     # 2. 准备接收方的地址和端口，'192.168.0.107'表示目的ip地址，8080表示目的端口号
    49.     dest_addr = ('192.168.8.226', 12341)  # 注意这是一个元组，其中ip地址是字符串，端口号是数字
    50.  
    51.     # 3. 发送数据到指定的ip和端口
    52.     for i in range(1):
    53.         udp_socket.sendto("Hello,I am a UDP socket.".encode('utf-8'), dest_addr)
    54.         time.sleep(1)
    55.  
    56.     # 4. 等待接收对方发送的数据
    57.     recv_data = udp_socket.recvfrom(1024)  # 1024表示本次接收的最大字节数
    58.  
    59.     # 5、打印接收到的数据
    60.     print(recv_data)
    61.     # 4. 关闭套接字
    62.     udp_socket.close()
    63.  
    64. if __name__ == '__main__':
    65.     main()
    66.  
    67.  
    68. ​

    结语
    这里只是UDP的简单使用，给大家一个示例参考，在实际应用过程中，涉及到复杂数据通信，还需要使用通信协议，协议收发，解包等函数，另外数据缓存也很关键，尤其是大数据量的情况下，通常会用到队列相关知识，这一部分就留给大家自行研究吧，如果这篇文章对你有用，不妨点赞关注，你的支持是我最大的动力。

  • 相关阅读:
    【SQL】Spark SQL 比较上下两条数据，多个字段多个条件，赋值一个结果字段成一个array，
    我又学会了使用Range实现网络文件下载的断点续传
    时间轴_量子计算机
    排序算法之基数排序
    Java项目：ssm流浪狗领养系统
    【AWS实验】 使用 Lake Formation 设置数据湖
    SQL基础理论篇（一）：什么是SQL
    alibaba Canal 增量订阅 & 消费组件，了解，安装，部署实践
    jdbc（DriverManager+Connection+Statement+ResultSet）+SQL注入+开启预编译+数据连接池
    架构与思维：微服务架构的思想本质
  • 原文地址：https://blog.csdn.net/xuezhe5212/article/details/140344334