AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

第十七章 Python网络编程

2024-04-24 33
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 第十七章 Python网络编程

Socket简介

在网络上的两个程序通过一个双向的通信连接实现数据的交换，这个链接的一端称为一个Socket（套接字），用于描述IP地址和端口。

建立网络通信连接至少要一对端口号（Socket），Socket本质是编程接口（API），对TCP/IP的封装，提供了网络通信能力。

每种服务都打开一个Socket，并绑定到端口上，不同的端口对应不同的服务，就像http对应80端口。

Socket是面向C/S（客户端/服务器）模型设计，客户端在本地随机申请一个唯一的Socket号，服务器拥有公开的socket，任何客户端都可以向它发送连接请求和信息请求。

比如：用手机打电话给10086客服，你的手机号就是客户端，10086客服是服务端。必须在知道对方电话号码前提下才能与对方通讯。

Socket数据处理流程如图：

wKiom1hFB3ihlqXzAAD9zEGLSeA858.png

17.1 socket

在Python中提供此服务的模块是socket和SocketServer，下面是socket常用的类、方法：

方法 描述
socket.socket([family[, type[, proto]]]) socket初始化函数，（地址族，socket类型，协议编号）协议编号默认0
socket.AF_INET IPV4协议通信
socket.AF_INET6 IPV6协议通信
socket.SOCK_STREAM socket类型，TCP
socket.SOCK_DGRAM socket类型，UDP
socket.SOCK_RAW 原始socket，可以处理普通socker无法处理的报文，比如ICMP
socket.SOCK_RDM 更可靠的UDP类型，保证对方收到数据
socket.SOCK_SEQPACKET 可靠的连续数据包服务

socket.socket()对象有以下方法：

accept() 接受连接并返回(socket object, address info)，address是客户端地址
bind(address) 绑定socket到本地地址，address是一个双元素元组（host，port）
listen(backlog) 开始接收连接，backlog是最大连接数，默认1
connect(address) 连接socket到远程地址
connect_ex(address) 连接socket到远程地址，成功返回0，错误返回error值
getpeername() 返回远程端地址(hostaddr, port)
gettimeout() 返回当前超时的值，单位秒，如果没有设置返回none
recv(buffersize[, flags]) 接收来自socket的数据，buffersize是接收数据量
send(data[, flags]) 发送数据到socket，返回值是发送的字节数
sendall(data[, flags]) 发送所有数据到socket，成功返回none，失败抛出异常
setblocking(flag) 设置socket为阻塞（flag是true）或非阻塞（flag是flase）

温习下TCP与UDP区别：

TCP和UDP是OSI七层模型中传输层提供的协议，提供可靠端到端的传输服务。

TCP（Transmission Control Protocol，传输控制协议），面向连接协议，双方先建立可靠的连接，再发送数据。适用于可靠性要求高的应用场景。

UDP（User Data Protocol，用户数据报协议），面向非连接协议，不与对方建立连接，直接将数据包发送给对方，因此相对TCP传输速度快 。适用于可靠性要求低的应用场景。

17.1.1 TCP编程

下面创建一个服务端TCP协议的Socket演示下。

先写一个服务端：

#!/usr/bin/python
# -*- coding: utf-8 -*-
import socket
HOST = ''                 # 为空代表所有可用的网卡
PORT = 50007              # 任意非特权端口
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, PORT))
s.listen(1)   # 最大连接数
conn, addr = s.accept()   # 返回客户端地址
print 'Connected by', addr
while 1:
    data = conn.recv(1024)   # 每次最大接收客户端发来数据1024字节
    if not data: break       # 当没有数据就退出死循环 
    print "Received: ", data # 打印接收的数据
    conn.sendall(data)       # 把接收的数据再发给客户端
conn.close()

再写一个客户端：

#!/usr/bin/python
# -*- coding: utf-8 -*-
import socket
HOST = '192.168.1.120'    # 远程主机IP
PORT = 50007              # 远程主机端口
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall('Hello, world') # 发送数据
data = s.recv(1024)       # 接收服务端发来的数据
s.close()
print 'Received: ', data


写好后，打开一个终端窗口执行：

# python socket-server.py
监听中...
# 直到客户端运行会接收到下面数据并退出
Connected by ('192.168.1.120', 37548)
Received:  Hello, world

再打开一个终端窗口执行：

# netstat -antp |grep 50007
tcp        0      0 0.0.0.0:50007           0.0.0.0:*               LISTEN      72878/python
# python socket-client.py
Received： Hello, world

通过实验了解搭到Socket服务端工作有以下几个步骤：

1）打开socket

2）绑定到一个地址和端口

3）监听进来的连接

4）接受连接

5）处理数据

17.1.2 UDP编程

import socket
HOST = ''               
PORT = 50007             
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((HOST, PORT))
while 1:
    data, addr = s.recvfrom(1024)
    print 'Connected by', addr
    print "Received: ", data
    s.sendto("Hello %s"% repr(addr), addr)
conn.close()

客户端：

import socket
HOST = '192.168.1.99'                 
PORT = 50007             
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.sendto(data, (HOST, PORT))
data = s.recv(1024)
s.close()
print 'Received: ', data

运行方式与TCP编程一样。

使用UDP协议时，服务端就少了listen()和accept()，不需要建立连接就直接接收客户端的数据，也是把数据直接发送给客户端。

客户端少了connect()，同样直接通过sendto()给服务器发数据。

而TCP协议则前提先建立三次握手。

17.1.3 举一个更直观的socket通信例子

客户端发送bash命令，服务端接收到并执行，把返回结果回应给客户端。

服务端：

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import subprocess
import socket
HOST = ''               
PORT = 50007             
try:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind((HOST, PORT))
    s.listen(1)
except socket.error as e:
    s.close()
    print e
    sys.exit(1)
while 1:
    conn, addr = s.accept()
    print 'Connected by', addr
    while 1:
        # 每次读取1024字节
        data = conn.recv(1024)
        if not data: # 客户端关闭服务端会收到一个空数据
            print repr(addr) + " close."
            conn.close()
            break     
        print "Received: ", data
        cmd = subprocess.Popen(data, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
        result_tuple = cmd.communicate()
        if cmd.returncode != 0 or cmd.returncode == None:
            result = result_tuple[1]
            # result = cmd.stderr.read()
        else:
            result = result_tuple[0]
            # result = cmd.stdout.read()  # 读不到标准输出，不知道为啥，所以不用
        if result:
            conn.sendall(result)
        else:
            conn.sendall("return null")
s.close()

客户端：

#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import socket
HOST = '192.168.1.120'   
PORT = 50007             
try:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((HOST, PORT))
except socket.error as e:
    s.close()
    print e
    sys.exit(1)
while 1:
    cmd = raw_input("Please input command: ")
    if not cmd: continue
    s.sendall(cmd)
    recv_data = s.recv(1024)
    print 'Received: ', recv_data
s.close()

查看运行效果，先运行服务端，再运行客户端：

# python socket-server.py
Connected by ('192.168.1.120', 45620)
Received:  ls
Received:  touch a.txt
Received:  ls

# python socket-client.py
Please input command: ls
Received: 
socket-client.py
socket-server.py
Please input command: touch a.txt
Received:  return null
Please input command: ls
Received: 
a.txt
socket-client.py
socket-server.py
Please input command:

我想通过上面这个例子你已经大致掌握了socket的通信过程。

再举一个例子，通过socket获取本机网卡IP：

>>> socket.gethostname()
'ubuntu'
>>> socket.gethostbyname(socket.gethostname())
'127.0.1.1'
>>> s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
>>> s.connect(('10.255.255.255', 0))
>>> s.getsockname()
('192.168.1.120', 35765)
>>> s.getsockname()[0]
'192.168.1.120'

 

博客地址：http://lizhenliang.blog.51cto.com

QQ群：323779636（Shell/Python运维开发群）

 

17.2 SocketServer

ScoketServer是Socket服务端库，比socket库更高级，实现了多线程和多线程，并发处理多个客户端请求。

下面是几个常用的类：

SocketServer.TCPServer(server_address, 

RequestHandlerClass, bind_and_activate=True)

 服务器类，TCP协议

SocketServer.UDPServer(server_address, 

RequestHandlerClass, bind_and_activate=True)

 服务器类，UDP协议

SocketServer.BaseServer(server_address, 

RequestHandlerClass)

 这个是所有服务器对象的超类。它定义了接口，不提供大多数方法，在子类中进行。
SocketServer.BaseRequestHandler 这个是所有请求处理对象的超类。它定义了接口，一个具体的请求处理程序子类必须定义一个新的handle()方法。
SocketServer.StreamRequestHandler 流式socket，根据socket生成读写socket用的两个文件对象，调用rfile和wfile读写
SocketServer.DatagramRequestHandler 数据报socket，同样生成rfile和wfile，但UDP不直接关联socket。这里rfile是由UDP中读取的数据生成，wfile则是新建一个StringIO，用于写数据
SocketServer.ForkingMixIn/ThreadingMixIn 多进程（分叉）/多线程实现异步。混合类，这个类不会直接实例化。用于实现处理多连接

SocketServer.BaseServer()对象有以下方法：

fileno() 返回一个整数文件描述符上服务器监听的套接字
handle_request() 处理一个请求
serve_forever(poll_interval=0.5) 处理，直至有明确要求shutdown()的请求。轮训关机每poll_interval秒
shutdown() 告诉serve_forever()循环停止并等待
server_close() 清理服务器
address_family 地址族
server_address 监听的地址
RequestHandlerClass 用户提供的请求处理类
socket socket对象上的服务器将监听传入的请求
allow_reuse_address 服务器是否允许地址的重用。默认False
request_queue_size 请求队列的大小。
socket_type socket类型。socket.SOCK_STREAM或socket.SOCK_DGRAM
timeout 超时时间，以秒为单位
finish_request() 实际处理通过实例请求RequestHandleClass并调用其handle()方法
get_request() 必须接受从socket的请求，并返回
handle_error(request, client_address) 如果这个函数被条用handle()
process_request(request, client_address) ?
server_activate() ?
server_bind() 由服务器构造函数调用的套接字绑定到所需的地址
verify_request(request, client_address) 返回一个布尔值，如果该值是True，则该请求将被处理，如果是False，该请求将被拒绝。

创建一个服务器需要几个步骤：

1）创建类，继承请求处理类（BaseRequestHandler），并重载其handle()方法，此方法将处理传入的请求

2）实例化服务器类之一，它传递服务器的地址和请求处理程序类

3）调用handle_request()或serve_forever()服务器对象的方法来处理一个或多个请求

4）调用server_close()关闭套接字

17.2.1 TCP编程

服务端：

#!/usr/bin/python
# -*- coding: utf-8 -*
import SocketServer
class MyTCPHandler(SocketServer.BaseRequestHandler):
    """
    请求处理程序类。
    每个连接到服务器都要实例化一次，而且必须覆盖handle()方法来实现与客户端通信
    """
    def handle(self):
        # self.request 接收客户端数据
        self.data = self.request.recv(1024).strip()
        print "%s wrote:" % (self.client_address[0])
        print self.data
        # 把接收的数据转为大写发给客户端
        self.request.sendall(self.data.upper())
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    # 创建服务器并绑定本地地址和端口
    server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
    # 激活服务器，会一直运行，直到Ctrl-C中断
    server.serve_forever()

另一个请求处理程序类，利用流（类文件对象简化通信提供标准文件接口）：

class MyTCPHandler(SocketServer.StreamRequestHandler):
    def handle(self):
        # self.rfile创建的是一个类文件对象处理程序，就可以调用readline()而不是recv()
        self.data = self.rfile.readline().strip()
        print "%s wrote:" % (self.client_address[0])
        print self.data
        # 同样，self.wfile是一个类文件对象，用于回复客户端
        self.wfile.write(self.data.upper())

客户端：

import socket
import sys
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    sock.connect((HOST, PORT))
    sock.sendall(data + "\n")
    received = sock.recv(1024)
finally:
    sock.close()
print "Sent: %s" % data
print "Received: %s" % received

服务端结果：

# python TCPClient.py hello
Sent: hello
Received: HELLO
# python TCPClient.py nice
Sent: nice
Received: NICE

17.2.2 UDP编程

服务端：

import SocketServer
class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        self.data = self.request[0].strip()
        self.socket = self.request[1]
        print "%s wrote:" % (self.client_address[0])
        print self.data
        self.socket.sendto(self.data.upper(), self.client_address)
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = SocketServer.UDPServer((HOST, PORT), MyTCPHandler)
    server.serve_forever()

客户端：

import socket
import sys
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.sendto(data + "\n", (HOST, PORT))
received = sock.recv(1024)
print "Sent: %s" % data
print "Received: %s" % received

与TCP执行结果一样。

17.2.3 异步混合

创建异步处理，使用ThreadingMixIn和ForkingMixIn类。

ThreadingMixIn类的一个例子：

#!/usr/bin/python
# -*- coding: utf-8 -*
import socket
import threading
import SocketServer
class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        data = self.request.recv(1024)
        cur_thread = threading.current_thread()
        response = "%s: %s" % (cur_thread.name, data)
        self.request.sendall(response)
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass
def client(ip, port, message):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((ip, port))
    try:
        sock.sendall(message)
        response = sock.recv(1024)
        print "Received: %s" % response
    finally:
        sock.close()
if __name__ == "__main__":
    # 端口0意味着随机使用一个未使用的端口
    HOST, PORT = "localhost", 0
    server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
    ip, port = server.server_address
    # 服务器启动一个线程，该线程将开始。每个线程处理每个请求
    server_thread = threading.Thread(target=server.serve_forever)
    # 作为守护线程
    server_thread.daemon = True
    server_thread.start()
    print "Server loop running in thread:", server_thread.name
    client(ip, port, "Hello World 1")
    client(ip, port, "Hello World 2")
    client(ip, port, "Hello World 3")
    server.shutdown()
      server.server_close()
 
# python socket-server.py
Server loop running in thread: Thread-1
Received: Thread-2: Hello World 1
Received: Thread-3: Hello World 2
Received: Thread-4: Hello World 3


文章标签：
网络协议
Python
Shell
运维
API
关键词：
Python网络
Python网络编程
网络编程python
李振良_阿良
目录
相关文章
子午s
|
18天前
|
机器学习/深度学习 人工智能 算法
猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
宠物识别系统使用Python和TensorFlow搭建卷积神经网络，基于37种常见猫狗数据集训练高精度模型，并保存为h5格式。通过Django框架搭建Web平台，用户上传宠物图片即可识别其名称，提供便捷的宠物识别服务。
子午s
201 55
mrq4nk6ni2neg
|
2月前
|
Python
Python中的异步编程：使用asyncio和aiohttp实现高效网络请求
【10月更文挑战第34天】在Python的世界里，异步编程是提高效率的利器。本文将带你了解如何使用asyncio和aiohttp库来编写高效的网络请求代码。我们将通过一个简单的示例来展示如何利用这些工具来并发地处理多个网络请求，从而提高程序的整体性能。准备好让你的Python代码飞起来吧！
mrq4nk6ni2neg
84 2
土木林森
|
2月前
|
数据采集 存储 JSON
Python网络爬虫：Scrapy框架的实战应用与技巧分享
【10月更文挑战第27天】本文介绍了Python网络爬虫Scrapy框架的实战应用与技巧。首先讲解了如何创建Scrapy项目、定义爬虫、处理JSON响应、设置User-Agent和代理，以及存储爬取的数据。通过具体示例，帮助读者掌握Scrapy的核心功能和使用方法，提升数据采集效率。
土木林森
116 6
子午s
|
28天前
|
机器学习/深度学习 人工智能 算法
【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
宠物识别系统，本系统使用Python作为主要开发语言，基于TensorFlow搭建卷积神经网络算法，并收集了37种常见的猫狗宠物种类数据集【'阿比西尼亚猫（Abyssinian）', '孟加拉猫（Bengal）', '暹罗猫（Birman）', '孟买猫（Bombay）', '英国短毛猫（British Shorthair）', '埃及猫（Egyptian Mau）', '缅因猫（Maine Coon）', '波斯猫（Persian）', '布偶猫（Ragdoll）', '俄罗斯蓝猫（Russian Blue）', '暹罗猫（Siamese）', '斯芬克斯猫（Sphynx）', '美国斗牛犬
子午s
152 29
【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
游客akle7anmklvj6
|
3天前
|
算法 网络协议 Python
探秘Win11共享文件夹之Python网络通信算法实现
本文探讨了Win11共享文件夹背后的网络通信算法，重点介绍基于TCP的文件传输机制，并提供Python代码示例。Win11共享文件夹利用SMB协议实现局域网内的文件共享，通过TCP协议确保文件传输的完整性和可靠性。服务器端监听客户端连接请求，接收文件请求并分块发送文件内容；客户端则连接服务器、接收数据并保存为本地文件。文中通过Python代码详细展示了这一过程，帮助读者理解并优化文件共享系统。
游客akle7anmklvj6
18 4
mrq4nk6ni2neg
|
28天前
|
机器学习/深度学习 人工智能 算法
深度学习入门：用Python构建你的第一个神经网络
在人工智能的海洋中，深度学习是那艘能够带你远航的船。本文将作为你的航标，引导你搭建第一个神经网络模型，让你领略深度学习的魅力。通过简单直观的语言和实例，我们将一起探索隐藏在数据背后的模式，体验从零开始创造智能系统的快感。准备好了吗？让我们启航吧！
mrq4nk6ni2neg
70 3
bruce_xiaowei
|
2月前
|
网络安全 Python
Python网络编程小示例：生成CIDR表示的IP地址范围
本文介绍了如何使用Python生成CIDR表示的IP地址范围，通过解析CIDR字符串，将其转换为二进制形式，应用子网掩码，最终生成该CIDR块内所有可用的IP地址列表。示例代码利用了Python的`ipaddress`模块，展示了从指定CIDR表达式中提取所有IP地址的过程。
bruce_xiaowei
51 6
东方睿赢
|
2月前
|
机器学习/深度学习 自然语言处理 语音技术
Python在深度学习领域的应用，重点讲解了神经网络的基础概念、基本结构、训练过程及优化技巧
本文介绍了Python在深度学习领域的应用，重点讲解了神经网络的基础概念、基本结构、训练过程及优化技巧，并通过TensorFlow和PyTorch等库展示了实现神经网络的具体示例，涵盖图像识别、语音识别等多个应用场景。
东方睿赢
67 8
历年考试不作弊
|
2月前
|
数据采集 XML 存储
构建高效的Python网络爬虫：从入门到实践
本文旨在通过深入浅出的方式，引导读者从零开始构建一个高效的Python网络爬虫。我们将探索爬虫的基本原理、核心组件以及如何利用Python的强大库进行数据抓取和处理。文章不仅提供理论指导，还结合实战案例，让读者能够快速掌握爬虫技术，并应用于实际项目中。无论你是编程新手还是有一定基础的开发者，都能在这篇文章中找到有价值的内容。
历年考试不作弊
98 3
子午s
|
2月前
|
机器学习/深度学习 人工智能 算法
基于Python深度学习的【垃圾识别系统】实现~TensorFlow+人工智能+算法网络
垃圾识别分类系统。本系统采用Python作为主要编程语言，通过收集了5种常见的垃圾数据集（'塑料', '玻璃', '纸张', '纸板', '金属'），然后基于TensorFlow搭建卷积神经网络算法模型，通过对图像数据集进行多轮迭代训练，最后得到一个识别精度较高的模型文件。然后使用Django搭建Web网页端可视化操作界面，实现用户在网页端上传一张垃圾图片识别其名称。
子午s
94 0
基于Python深度学习的【垃圾识别系统】实现~TensorFlow+人工智能+算法网络

热门文章

最新文章

  • 1
    使用Python实现智能食品库存管理的深度学习模型
  • 2
    Python实现常用办公文件格式转换
  • 3
    猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
  • 4
    pyenv 管理多个 Python 版本(1)
  • 5
    Python编程数据结构的深入理解
  • 6
    Python的标准库
  • 7
    利用Python内置函数实现的冒泡排序算法
  • 8
    使用Python实现智能食品消费习惯分析的深度学习模型
  • 9
    使用Python实现深度学习模型的分布式训练
  • 10
    在 Python 中，如何将日期时间类型转换为字符串？
  • 1
    Linux网络编程 网络基础知识
    76
  • 2
    网络编程知识点总结（7）
    56
  • 3
    网络编程知识点总结（6）
    56
  • 4
    网络编程知识点总结（5）
    53
  • 5
    网络编程知识点总结（4）
    47
  • 6
    网络编程知识点总结（3）
    55
  • 7
    网络编程知识点总结（2）
    51
  • 8
    网络编程知识点总结(1)
    49
  • 9
    【Java网络编程】网络编程概述、UDP通信（DatagramPacket 与 DatagramSocket）
    88
  • 10
    【网络编程】理解客户端和服务器并使用Java提供的api实现回显服务器
    59

    • 相关课程

    更多
  • Python Web开发基础
  • Python爬虫实战
  • Python开发基础入门
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • Python选择及循环结构
  • 云端Python及基本操作
  • Python网络通信程序典型应用
  • 容器的自定义网络
  • 容器的共享网络模型

    • 推荐镜像

    更多
  • python-release
  • nodejs-release
  • golang
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月