python调用C++代码-方法-使用Pybind11库将C++代码与Python绑定

已于 2024-08-16 14:23:34 修改
阅读量752 收藏 15
点赞数 10
分类专栏： python C++ 文章标签： python c++
于 2024-08-16 11:09:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37647148/article/details/141245632
版权
python 同时被 2 个专栏收录
38 篇文章 3 订阅
订阅专栏
C++
2 篇文章 0 订阅
订阅专栏

python调用C++代码-方法1-使用Pybind11库将C++代码与Python绑定

目的

这个方法的目的是使用Pybind11库将C++代码与Python绑定，从而在Python中调用高效的C++代码。这种方法适用于需要在Python项目中利用C++的性能优势，尤其是在需要高性能计算或已有C++代码库的情况下。

1. 准备工作

安装必要的软件和库：

  1. Python：确保系统中已安装Python（Python 3.x版本）。
  2. C++编译器：
    • Visual Studio：确保安装了包含C++开发工具的Visual Studio（推荐使用）。
    • MinGW：如果你更熟悉GCC编译器，可以使用MinGW。
  3. Pybind11库：通过pip安装Pybind11：
    pip install pybind11
2. 创建项目目录和文件结构

组织你的项目文件：

  1. 创建一个项目目录：

    mkdir your_project_directory
cd your_project_directory

  2. 在这个目录下，创建以下文件：

    • example.cpp: 包含C++源代码。
    • setup.py: 用于定义编译过程的Python脚本。
    • test_example.py: 用于测试生成的Python模块。

文件结构示例：

/your_project_directory
|-- example.cpp       # C++源代码文件
|-- setup.py          # Python构建脚本
|-- test_example.py   # Python测试脚本
3. 编写C++代码

创建example.cpp文件，并写入以下代码：

#include <pybind11/pybind11.h>

// 定义一个简单的C++函数，计算两个整数的和
int add(int a, int b) {
    return a + b;
}

// 使用Pybind11将C++函数绑定到Python模块
PYBIND11_MODULE(example, m) {
    m.def("add", &add, "A function that adds two numbers");
}

解释：

  • #include <pybind11/pybind11.h>：引入Pybind11的核心头文件。
  • int add(int a, int b)：这是一个简单的C++函数，用于计算两个整数的和。
  • PYBIND11_MODULE(example, m)：这是一个宏，用于定义Python模块。example是模块名称，m是模块对象。
4. 编写构建脚本

创建setup.py文件，内容如下：

from setuptools import setup, Extension
import pybind11

# 定义一个扩展模块，指定源文件和包含路径
ext_modules = [
    Extension(
        'example',  # 模块名称
        ['example.cpp'],  # 源文件
        include_dirs=[pybind11.get_include()],  # 包含pybind11头文件的路径
        language='c++'  # 指定使用C++编译
    ),
]

# 定义构建过程
setup(
    name='example',
    ext_modules=ext_modules,
)

解释：

  • setup.py文件使用setuptools来管理构建流程。
  • Extension类用于定义扩展模块的属性，包括模块名称、源文件、包含路径和编译语言。
    我的目录如下：
    在这里插入图片描述
5. 编译C++代码并生成Python模块

使用命令行编译生成Python模块：

  1. 打开命令行（如pycharm-terminal开发者命令行）。
  2. 导航到项目目录：
    cd your_project_directory
  3. 运行以下命令进行编译：
    python setup.py build_ext --inplace
    这条命令会将example.cpp文件编译成一个可直接导入的Python模块（在Windows上通常是example.pyd）。
    进入项目路径进行编译：
    在这里插入图片描述
    成功生成结果如下：
    在这里插入图片描述
    此时项目文件如下：
    在这里插入图片描述
6. 测试生成的Python模块

创建并运行测试脚本：

  1. 创建test_example.py文件，并写入以下代码：

    import example

result = example.add(10, 20)
print(result)  # 预期输出: 30

  2. 运行测试脚本：

    python test_example.py

    如果一切正常，你应该会看到输出结果30。
    测试成功结果如下：
    在这里插入图片描述

总结

通过这个详细的步骤，你可以将C++代码与Python成功绑定。这种方法不仅适用于简单的函数绑定，也可以扩展到更复杂的C++类和模块，使得Python能够利用C++的强大性能。

实战测试

我有一段C++代码的主要功能是通过Modbus TCP协议从远程服务器读取输入寄存器的数据，并将读取到的数据进行解析和显示。
完整代码如下：

#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <stdio.h>
#include <cstdint>
#include <ctime>

#pragma comment(lib, "Ws2_32.lib")  // 链接Ws2_32.lib库

// 定义一些常量
#define IP "192.168.0.150"
#define PORT 6789
#define UNIT_ID 3
#define REGISTER_ADDRESS 1000
#define NUM_REGISTERS 51200
#define MAX_REGISTERS_PER_REQUEST 255
#define MAX_RETRIES 3
#define TIMEOUT_SEC 5  // 超时时间（秒）

// 特定寄存器的地址和含义映射
typedef struct {
    uint16_t address;
    const char* description;
} SpecialRegister;

SpecialRegister special_registers[] = {
    {100, "uhf_db"},
    {101, "reserve"},
    {102, "放电次数"},
    {103, "放电相位"}
};

void create_read_input_registers_request(uint8_t* request, uint16_t address, uint16_t count) {
    uint16_t transaction_id = htons(1);
    uint16_t protocol_id = htons(0);
    uint16_t length = htons(6);
    uint8_t unit_id = UNIT_ID;
    uint8_t function_code = 4;
    uint16_t addr = htons(address);
    uint16_t cnt = htons(count);

    memcpy(request, &transaction_id, 2);
    memcpy(request + 2, &protocol_id, 2);
    memcpy(request + 4, &length, 2);
    memcpy(request + 6, &unit_id, 1);
    memcpy(request + 7, &function_code, 1);
    memcpy(request + 8, &addr, 2);
    memcpy(request + 10, &cnt, 2);
}

void parse_response(uint8_t* response, int response_size, uint16_t* registers) {
    int data_length = response[8];
    if (response_size < 9 + data_length) {
        printf("错误：响应数据不完整\n");
        return;
    }

    for (int i = 0; i < data_length / 2; i++) {
        registers[i] = ntohs(*(uint16_t*)&response[9 + i * 2]);
    }
}

int read_input_registers(SOCKET sockfd, uint16_t address, uint16_t count, uint16_t* registers) {
    uint8_t request[12];
    create_read_input_registers_request(request, address, count);

    if (send(sockfd, (const char*)request, 12, 0) == SOCKET_ERROR) {
        printf("发送请求失败: %ld\n", WSAGetLastError());
        return -1;
    }

    fd_set readfds;
    FD_ZERO(&readfds);
    FD_SET(sockfd, &readfds);

    struct timeval timeout;
    timeout.tv_sec = TIMEOUT_SEC;
    timeout.tv_usec = 0;

    int select_result = select(sockfd + 1, &readfds, NULL, NULL, &timeout);
    if (select_result > 0) {
        uint8_t response[1024];
        int response_size = recv(sockfd, (char*)response, sizeof(response), 0);
        if (response_size == SOCKET_ERROR) {
            printf("接收响应失败: %ld\n", WSAGetLastError());
            return -1;
        }

        parse_response(response, response_size, registers);
        return response_size;
    }
    else if (select_result == 0) {
        printf("接收响应超时\n");
        return -1;
    }
    else {
        printf("select 调用失败: %ld\n", WSAGetLastError());
        return -1;
    }
}

void print_special_registers(uint16_t* special_values) {
    printf("特定寄存器值:\n");
    for (int i = 0; i < sizeof(special_registers) / sizeof(SpecialRegister); i++) {
        uint16_t address = special_registers[i].address;
        const char* description = special_registers[i].description;
        printf("地址 %u (%s): %u\n", address, description, special_values[address - 100]);
    }
}

int main() {
    WSADATA wsaData;
    SOCKET sockfd;
    struct sockaddr_in server_addr;
    uint16_t* all_registers = (uint16_t*)malloc(NUM_REGISTERS * sizeof(uint16_t));
    uint16_t special_values[4] = { 0 };

    if (all_registers == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    printf("正在连接到 Modbus TCP 服务器 %s:%d\n", IP, PORT);
    printf("正在读取 %d 个输入寄存器...\n", NUM_REGISTERS);

    // 初始化 WinSock
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        printf("WinSock 初始化失败: %d\n", WSAGetLastError());
        free(all_registers);
        return 1;
    }

    // 创建套接字
    if ((sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
        printf("套接字创建失败: %ld\n", WSAGetLastError());
        WSACleanup();
        free(all_registers);
        return 1;
    }

    // 设置套接字为非阻塞模式
    u_long mode = 1;
    ioctlsocket(sockfd, FIONBIO, &mode);

    // 配置服务器地址
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    inet_pton(AF_INET, IP, &server_addr.sin_addr);

    // 连接服务器
    if (connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        if (WSAGetLastError() != WSAEWOULDBLOCK) {
            printf("连接服务器失败: %ld\n", WSAGetLastError());
            closesocket(sockfd);
            WSACleanup();
            free(all_registers);
            return 1;
        }

        // 使用 select 等待连接完成
        fd_set writefds;
        FD_ZERO(&writefds);
        FD_SET(sockfd, &writefds);
        struct timeval timeout;
        timeout.tv_sec = TIMEOUT_SEC;
        timeout.tv_usec = 0;

        int select_result = select(sockfd + 1, NULL, &writefds, NULL, &timeout);
        if (select_result <= 0) {
            printf("连接服务器超时或失败\n");
            closesocket(sockfd);
            WSACleanup();
            free(all_registers);
            return 1;
        }
    }

    // 计时开始
    clock_t start_time = clock();

    // 分批读取寄存器
    for (int i = 0; i < NUM_REGISTERS; i += MAX_REGISTERS_PER_REQUEST) {
        int batch_size = (NUM_REGISTERS - i < MAX_REGISTERS_PER_REQUEST) ? NUM_REGISTERS - i : MAX_REGISTERS_PER_REQUEST;
        if (read_input_registers(sockfd, REGISTER_ADDRESS + i, batch_size, all_registers + i) < 0) {
            printf("读取寄存器失败\n");
            closesocket(sockfd);
            WSACleanup();
            free(all_registers);
            return 1;
        }
    }

    // 计算并显示all_registers数组的大小
    size_t array_size_bytes = NUM_REGISTERS * sizeof(uint16_t); // 数组占用的总字节数
    size_t array_size_elements = NUM_REGISTERS; // 数组中的元素数

    printf("all_registers数组的大小: %zu 字节\n", array_size_bytes);
    printf("all_registers数组中的元素数量: %zu\n", array_size_elements);

    // 读取特定寄存器
    if (read_input_registers(sockfd, 100, 4, special_values) < 0) {
        printf("读取特定寄存器失败\n");
        closesocket(sockfd);
        WSACleanup();
        free(all_registers);
        return 1;
    }

    // 计时结束
    clock_t end_time = clock();
    double total_duration = (double)(end_time - start_time) / CLOCKS_PER_SEC;

    // 输出结果
    printf("读取到的寄存器值 (前10个): ");
    for (int i = 0; i < 10 && i < NUM_REGISTERS; i++) {
        printf("%u ", all_registers[i]);
    }

    // 打印特定寄存器值
    print_special_registers(special_values);

    printf("\n总共读取到 %d 个寄存器\n", array_size_elements);
    printf("总耗时: %.4f 秒\n", total_duration);

    // 关闭套接字
    closesocket(sockfd);
    // 清理 WinSock
    WSACleanup();
    // 释放内存
    free(all_registers);

    return 0;
}

输出结果如下：
在这里插入图片描述
要将这个复杂的C++代码封装并优化以便于在Python中调用，可以按照以下步骤进行：

1. 分解功能并创建类封装

首先，将整个功能封装到一个C++类中，使其更加模块化和易于管理。我们将核心的Modbus TCP客户端功能封装在一个类中，并暴露必要的接口供Python调用。

2. 提供Python接口

使用Pybind11将C++类和函数绑定到Python，使其可以直接在Python中调用。

优化后的C++代码

以下是经过优化并封装的C++代码：

#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <stdio.h>
#include <cstdint>
#include <ctime>
#include <vector>
#include <string>
#include <iostream>
#include <stdexcept>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

#pragma comment(lib, "Ws2_32.lib")

#define TIMEOUT_SEC 5  // 超时时间（秒）

class ModbusTCPClient {
public:
    ModbusTCPClient(const std::string& ip, uint16_t port, uint8_t unit_id)
        : ip_(ip), port_(port), unit_id_(unit_id), sockfd_(INVALID_SOCKET) {
        if (WSAStartup(MAKEWORD(2, 2), &wsaData_) != 0) {
            throw std::runtime_error("WinSock 初始化失败");
        }
    }

    ~ModbusTCPClient() {
        if (sockfd_ != INVALID_SOCKET) {
            closesocket(sockfd_);
        }
        WSACleanup();
    }

    void connect_server() {
        sockfd_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sockfd_ == INVALID_SOCKET) {
            throw std::runtime_error("套接字创建失败");
        }

        u_long mode = 1;
        ioctlsocket(sockfd_, FIONBIO, &mode);

        sockaddr_in server_addr{};
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(port_);
        inet_pton(AF_INET, ip_.c_str(), &server_addr.sin_addr);

        if (connect(sockfd_, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
            if (WSAGetLastError() != WSAEWOULDBLOCK) {
                throw std::runtime_error("连接服务器失败");
            }

            fd_set writefds;
            FD_ZERO(&writefds);
            FD_SET(sockfd_, &writefds);
            timeval timeout{TIMEOUT_SEC, 0};

            int select_result = select(sockfd_ + 1, nullptr, &writefds, nullptr, &timeout);
            if (select_result <= 0) {
                throw std::runtime_error("连接服务器超时或失败");
            }
        }
    }

    std::vector<uint16_t> read_input_registers(uint16_t address, uint16_t count) {
        std::vector<uint16_t> registers(count, 0);
        uint8_t request[12];
        create_read_input_registers_request(request, address, count);

        if (send(sockfd_, reinterpret_cast<const char*>(request), 12, 0) == SOCKET_ERROR) {
            throw std::runtime_error("发送请求失败");
        }

        fd_set readfds;
        FD_ZERO(&readfds);
        FD_SET(sockfd_, &readfds);

        timeval timeout{TIMEOUT_SEC, 0};
        int select_result = select(sockfd_ + 1, &readfds, nullptr, nullptr, &timeout);

        if (select_result > 0) {
            uint8_t response[1024];
            int response_size = recv(sockfd_, reinterpret_cast<char*>(response), sizeof(response), 0);
            if (response_size == SOCKET_ERROR) {
                throw std::runtime_error("接收响应失败");
            }
            parse_response(response, response_size, registers.data());
        } else if (select_result == 0) {
            throw std::runtime_error("接收响应超时");
        } else {
            throw std::runtime_error("select 调用失败");
        }

        return registers;
    }

private:
    std::string ip_;
    uint16_t port_;
    uint8_t unit_id_;
    SOCKET sockfd_;
    WSADATA wsaData_;

    void create_read_input_registers_request(uint8_t* request, uint16_t address, uint16_t count) {
        uint16_t transaction_id = htons(1);
        uint16_t protocol_id = htons(0);
        uint16_t length = htons(6);
        uint8_t unit_id = unit_id_;
        uint8_t function_code = 4;
        uint16_t addr = htons(address);
        uint16_t cnt = htons(count);

        memcpy(request, &transaction_id, 2);
        memcpy(request + 2, &protocol_id, 2);
        memcpy(request + 4, &length, 2);
        memcpy(request + 6, &unit_id, 1);
        memcpy(request + 7, &function_code, 1);
        memcpy(request + 8, &addr, 2);
        memcpy(request + 10, &cnt, 2);
    }

    void parse_response(uint8_t* response, int response_size, uint16_t* registers) {
        int data_length = response[8];
        if (response_size < 9 + data_length) {
            throw std::runtime_error("响应数据不完整");
        }

        for (int i = 0; i < data_length / 2; i++) {
            registers[i] = ntohs(*(uint16_t*)&response[9 + i * 2]);
        }
    }
};

// Pybind11模块定义
namespace py = pybind11;

PYBIND11_MODULE(modbus_client, m) {
    py::class_<ModbusTCPClient>(m, "ModbusTCPClient")
        .def(py::init<const std::string&, uint16_t, uint8_t>())
        .def("connect_server", &ModbusTCPClient::connect_server)
        .def("read_input_registers", &ModbusTCPClient::read_input_registers);
}

代码说明

  1. ModbusTCPClient类：封装了Modbus TCP客户端的功能，包括连接服务器和读取寄存器的功能。
  2. connect_server方法：负责连接到Modbus TCP服务器。
  3. read_input_registers方法：读取输入寄存器，返回寄存器值的std::vector。
  4. Pybind11模块：使用Pybind11将ModbusTCPClient类绑定到Python模块modbus_client中，供Python调用。

3. 创建Python构建脚本

创建一个setup.py文件，用于定义构建过程：

from setuptools import setup, Extension
import pybind11

ext_modules = [
    Extension(
        'modbus_client',  # 模块名称
        ['modbus_client.cpp'],  # 源文件
        include_dirs=[pybind11.get_include()],
        libraries=["Ws2_32"],  # 链接Ws2_32.lib库
        language='c++',
    ),
]

setup(
    name='modbus_client',
    ext_modules=ext_modules,
)

4. 编译并测试

  1. 编译模块：在项目目录中，使用命令行运行以下命令进行编译：

    python setup.py build_ext --inplace

  2. 测试Python代码：编写一个Python脚本来测试生成的模块：

import modbus_client

client = modbus_client.ModbusTCPClient("192.168.0.150", 6789, 3)
client.connect_server()

# 读取特定寄存器（示例地址100，读取4个寄存器）
registers = client.read_input_registers(100, 4)
print(f"读取的寄存器值: {registers}")

通过上述流程步骤，结果如下所示：
在这里插入图片描述
在这里插入图片描述

优化测试代码：

如下所示：

import modbus_client

client = modbus_client.ModbusTCPClient("192.168.0.150", 6789, 3)
client.connect_server()

# 读取特定寄存器（示例地址100，读取4个寄存器）
registers = client.read_input_registers(100, 4)
print(f"读取的寄存器值: {registers}")

registers2 = client.read_input_registers(1000, 127)
print(f"读取的寄存器值: {registers2}")
registers3 = client.read_input_registers(1127, 127)
print(f"读取的寄存器值: {registers3}")

运行结果如下：
在这里插入图片描述
我测试最大每次读127，要是多一点就出错，当设置为128时，结果如下：
在这里插入图片描述
我的寄存器地址从1000开始，总共有51200个数值，故要分批读取。
读取特定寄存器和读取51200个寄存器的数据，并将max_registers_per_request设置为125。这个值符合Modbus协议中典型的最大读取寄存器数量限制。
完整代码如下：

import modbus_client

# 初始化Modbus TCP客户端
client = modbus_client.ModbusTCPClient("192.168.0.150", 6789, 3)
client.connect_server()

# 定义读取参数
start_address = 1000
total_registers = 51200
max_registers_per_request = 125  # 设置为125，符合Modbus标准

# 存储结果的列表
result = []

# 分批次读取51200个寄存器数据
for i in range(0, total_registers, max_registers_per_request):
    batch_size = min(max_registers_per_request, total_registers - i)
    current_address = start_address + i
    registers = client.read_input_registers(current_address, batch_size)
    result.extend(registers)

# 读取特定寄存器的值（示例地址100，读取4个寄存器）
special_registers = client.read_input_registers(100, 4)

# 输出结果
print(f"读取到的寄存器总数: {len(result)}")
print(f"后10个寄存器值: {result[:-10]}")
print(f"特定寄存器（地址100-103）的值: {special_registers}")

在现有的代码基础上，我们可以添加计时功能来计算读取寄存器的耗时。我们将使用Python的time模块来测量时间。在读取寄存器之前记录开始时间，完成后记录结束时间，最后计算和输出总耗时。

优化后的代码（带计时功能）

import modbus_client
import time

# 初始化Modbus TCP客户端
client = modbus_client.ModbusTCPClient("192.168.0.150", 6789, 3)
client.connect_server()

# 定义读取参数
start_address = 1000
total_registers = 51200
max_registers_per_request = 125  # 设置为125，符合Modbus标准

# 存储结果的列表
result = []

# 开始计时
start_time = time.time()

# 分批次读取51200个寄存器数据
for i in range(0, total_registers, max_registers_per_request):
    batch_size = min(max_registers_per_request, total_registers - i)
    current_address = start_address + i
    registers = client.read_input_registers(current_address, batch_size)
    result.extend(registers)

# 读取特定寄存器的值（示例地址100，读取4个寄存器）
special_registers = client.read_input_registers(100, 4)
# 结束计时
end_time = time.time()
total_duration = end_time - start_time



# 输出结果
print(f"读取到的寄存器总数: {len(result)}")
print(f"后10个寄存器值: {result[-10:]}")
print(f"特定寄存器（地址100-103）的值: {special_registers}")
print(f"读取 {total_registers} 个寄存器总耗时: {total_duration:.4f} 秒")

输出结果如下：
在这里插入图片描述

代码说明

  1. 导入time模块：我们使用time模块来进行计时。

  2. 开始计时：

    • 在开始读取寄存器之前，调用start_time = time.time()记录当前时间。

  3. 结束计时并计算总耗时：

    • 在所有寄存器读取完毕后，调用end_time = time.time()记录结束时间。
    • total_duration表示总耗时，计算方式为end_time - start_time。

  4. 输出耗时：

    • 通过print(f"读取 {total_registers} 个寄存器总耗时: {total_duration:.4f} 秒")输出读取51200个寄存器的总耗时，结果精确到小数点后四位。

在这里插入图片描述

优化结果

通过添加计时功能，你可以精确地知道读取寄存器操作花费的时间。这对于性能优化和评估系统响应时间非常有用。程序在读取完所有寄存器后，会输出耗时信息，帮助你了解通信的效率。

使用纯python写法读取数据代码如下：

import socket
import struct
import time
import select

# 定义一些常量
IP = "192.168.0.150"
PORT = 6789
UNIT_ID = 3
REGISTER_ADDRESS = 1000
NUM_REGISTERS = 51200
MAX_REGISTERS_PER_REQUEST = 125
TIMEOUT_SEC = 5  # 超时时间（秒）

# 特定寄存器的地址和含义映射
special_registers = [
    (100, "uhf_db"),
    (101, "reserve"),
    (102, "放电次数"),
    (103, "放电相位")
]

def create_read_input_registers_request(address, count):
    transaction_id = 1
    protocol_id = 0
    length = 6
    unit_id = UNIT_ID
    function_code = 4
    request = struct.pack('>HHHBBHH', transaction_id, protocol_id, length, unit_id, function_code, address, count)
    return request

def parse_response(response, count):
    data_length = response[8]
    if len(response) < 9 + data_length:
        raise ValueError("响应数据不完整")

    registers = struct.unpack('>' + 'H' * (data_length // 2), response[9:9 + data_length])
    return registers

def read_input_registers(sock, address, count):
    request = create_read_input_registers_request(address, count)
    sock.sendall(request)

    sock.settimeout(TIMEOUT_SEC)
    response = sock.recv(1024)
    return parse_response(response, count)

def print_special_registers(special_values):
    print("特定寄存器值:")
    for address, description in special_registers:
        print(f"地址 {address} ({description}): {special_values[address - 100]}")

def main():
    all_registers = [0] * NUM_REGISTERS
    special_values = [0] * 4

    print(f"正在连接到 Modbus TCP 服务器 {IP}:{PORT}")
    print(f"正在读取 {NUM_REGISTERS} 个输入寄存器...")

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setblocking(0)

    server_address = (IP, PORT)
    sock.connect_ex(server_address)

    ready_to_write = [sock]
    _, writable, _ = select.select([], ready_to_write, [], TIMEOUT_SEC)

    if not writable:
        print("连接服务器超时或失败")
        sock.close()
        return

    start_time = time.time()

    try:
        for i in range(0, NUM_REGISTERS, MAX_REGISTERS_PER_REQUEST):
            batch_size = min(NUM_REGISTERS - i, MAX_REGISTERS_PER_REQUEST)
            batch_registers = read_input_registers(sock, REGISTER_ADDRESS + i, batch_size)
            all_registers[i:i + batch_size] = batch_registers

        special_values = read_input_registers(sock, 100, 4)
    except Exception as e:
        print(f"读取寄存器失败: {e}")
        sock.close()
        return

    end_time = time.time()
    total_duration = end_time - start_time

    print("读取到的寄存器值 (后10个):", all_registers[-10:])
    print_special_registers(special_values)
    print(f"\n总共读取到 {len(all_registers)} 个寄存器")
    print(f"总耗时: {total_duration:.4f} 秒")

    sock.close()

if __name__ == "__main__":
    main()

结果如下：
在这里插入图片描述
很纳闷，python调用C++代码和纯python读取效率差不多。

总结

通过封装和优化，复杂的C++代码可以更加模块化和易于维护，同时通过Pybind11轻松暴露给Python调用。这使得在高效处理低层次网络通信的同时，可以在高层次应用中利用Python的灵活性。

像风一样自由2020
关注
专栏目录
如何使用pybind11,在Python中调用c++库
zhangzhechun的专栏
06-24 263
要实现将 C++ 类公开给 Python，可以使用 。 是一个轻量级的头文件库，使得在 Python 中调用 C++ 代码变得非常简单，并且自然地映射 C++ 类和函数到 Python 中。以下是如何使用 将一个 C++ 类 公开给 Python 并调用其方法的详细步骤：首先，编写 C++ 代码并使用 创建绑定。 绑定代码 使用 创建绑定代码： 2. 安装 确保你已经安装 ： 3. 编译为共享库 使用 提供的编译器标志编译 C++ 代码为共享库。在 Linux 和 macOS 上，可以使用以下
Python调用C++
whuzhang16的博客
07-19 460
Boost.Python方式转C++为Python可调用
Python调用C++封装
11-13
Python调用C++封装的DEMO，希望能够帮助大家。Python调用C++封装的DEMO，希望能够帮助大家。
在 python 中调用 C/C++
哦豁灬
01-28 5326
Python 是一种很好用的胶水语言，利用Python的简洁和C++的高效，基本可以解决99%的问题了，剩下那 1% 的问题也就不是问题了，毕竟不是所有问题都可解。这里讨论前者，在 python 中调用 C/C++ 代码的方法很多，这里记录三种方法的使用。
Python调用C/C++的种种方法
热门推荐
日知录
12-07 12万+
<br />Python是解释性语言, 底层就是用c实现的, 所以用python调用C是很容易的, 下面就总结一下各种调用的方法, 给出例子, 所有例子都在ubuntu9.10, python2.6下试过.<br /> <br />1. Python 调用 C (base)<br />想在python中调用c函数, 如这儿的fact<br />#include <Python.h><br /><br /> int fact(int n)<br /> {<br />   if (n <= 1)<br /
python 调用c++
花生日记
04-09 5353
在这一步中，我们并不需要去关心它具体是如何工作的，我们只需要知道：当我们在文件中定义了一个函数后，就可以向该函数发出调用请求。当这些操作完成后，我们就可以在文件中看到一个名为 explain （）的文件了，它是一个函数库，其中包含了许多不同类型的函数。函数调用，也叫函数调用，是指在程序中使用一个函数的时候，直接从函数地址出发，向目标函数发出一次操作。另外还有一种方法：如果你使用了` find （）`命令搜索到了“C++”这个函数地址，那么你就可以直接在运行时环境中查看该被调用的“C++”这个函数。
python调用c++之pybind11
m0_64355682的博客
02-15 4056
之前一直从事c++相关算法及代码的相关工作，因公司内部代码管理需要，需将算法封装待python平台使用，根据此需求，对python调用c++代码的方式进行了学习，最终综合考虑封装难度及多代码管理使用pybind11进行了相关功能的实现。 pybind11是一个用于c++与python之间相互调用和数据交互的库 以我自己的算法为例介绍一下pybind11的基本使用，我的调用算法中还包含了其他的c++库，例如opencv，此处还出现了一个我没想到的bug后续会介绍。 Windows系统 Requires
pybind11(python-c++互调demo).zip
08-04
接下来，你需要理解如何在C++代码中使用Pybind11创建Python绑定。一个基本的流程包括： 1. **包含头文件**：在C++源文件中包含`pybind11/pybind11.h`。 2. **定义C++函数**：编写你要在Python中调用的C++函数。 3. ...
pybind11: C++ 工程提供 Python 接口的实例代码
09-07
Pybind11是一个强大的工具，它使得C++代码能够轻松地与Python进行交互，从而将C++的强大性能和Python的易用性结合在一起。本文主要介绍如何使用pybind11来为C++工程构建Python接口。 首先，pybind11是一个header-...
ubuntu中python调用C/C++方法之动态链接库详解
09-15
在Ubuntu系统中，Python调用C或C++的方法通常是通过动态链接库（Dynamic Link Library，简称DLL）来实现的。动态链接库允许Python程序利用C或C++编写的高效功能，而无需将整个C/C++代码编译进Python解释器。这种技术...
python调用C++程序
伪善者的博客
05-13 1191
python调用C++程序 Python / C API CFFI / ctypes
Python与c++互相调用（pybind11）
最新发布
Lastvil的博客
08-14 454
看网上使用pip install pybind11,没有弄明白，因此下载源码编译。
Python调用C/C++程序
weixin_34319999的博客
06-17 124
编程中会遇到调用其他语言到库，这里记录一下Python调用C++。 Python底层是C, 所以调用C还是比较方便。调用C++有些麻烦。 Python提供了ctypes, 方便将Python类型转为C类型，实现传参数、函数返回类型的对应。ctypes网址:https://docs.python.org/2/library/ctypes.html   使用Python调用C/C++主要有三步...
python调用C++方法
gg1314723的博客
11-01 4354
python 通过ctypes包调用c++或者c 的方法提示：以下是本篇文章正文内容，下面案例可供参考主要对python调用c++的方式介绍，并传递指针变量 ， 常规变量 和 对象作为返回值的demo。
Python 调用 C++程序
woodgril的博客
04-28 180
pycallclass.cpp #include <iostream> using namespace std; class TestLib { public: void display(); int display(int a); }; void TestLib::display() { cout<<"First display"<<endl; } int TestLib::d
pybind11 python调用c++
07-08
在Python中调用C++代码可以使用pybind11库。pybind11是一个用于将C++代码绑定到Python的开源项目。它提供了一个简单的接口，使得在Python中调用C++代码变得非常方便。 首先，你需要安装pybind11库。你可以使用pip命令进行安装： ``` pip install pybind11 ``` 接下来，你需要创建一个C++扩展模块。首先，你需要编写包装器代码来将C++函数绑定到Python函数。下面是一个简单的例子： ```cpp #include <pybind11/pybind11.h> int add(int a, int b) { return a + b; } PYBIND11_MODULE(example, m) { m.def("add", &add, "A function which adds two numbers"); } ``` 然后，你需要将上述代码编译为一个共享库。你可以使用CMake或者直接使用命令行进行编译。下面是使用命令行编译的示例： ``` g++ -O3 -Wall -shared -std=c++11 -fPIC `python3 -m pybind11 --includes` example.cpp -o example`python3-config --extension-suffix` ``` 编译成功后，会生成一个名为`example.so`（或者`example.pyd`，取决于你的操作系统）的共享库文件。 最后，在Python中调用C++函数： ```python import example result = example.add(2, 3) print(result) # 输出 5 ``` 这样就完成了在Python中调用C++代码的过程。你可以根据需要添加更多的C++函数，并在Python中进行调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值