python和go相互调用的两种方法

前言

Python 和 Go 语言是两种不同的编程语言，它们分别有自己的优势和适用场景。在一些项目中，由于团队内已有的技术栈或者某一部分业务的需求，可能需要 Python 和 Go 相互调用,以此来提升效率和性能。

• 性能优势

  Go 通常比 Python 更高效，尤其是在并发和并行处理方面。因此，可以使用 Go 编写高性能的底层组件或服务，并通过 Python 调用这些组件来提高整体性能。

• 并发和并行处理

  Go 是为并发设计的语言，具有轻量级线程（goroutines）和通道（channels）等特性。在需要处理大量并发任务的情况下，Go 的并发性能可能优于 Python。通过将 Go 组件嵌入到 Python 代码中，可以利用 Go 的并发处理能力。

• 易用性和灵活性

  Python 具有简洁、易读、易学的语法，适用于快速开发和原型设计。将 Python 用于高层逻辑和算法，而使用 Go 来编写性能敏感的底层组件，可以在性能和开发速度之间找到平衡。

方案简介

1.动态库调用

一、调用步骤：

将go代码编译成so库 -> python中通过ctypes引用so库并指定需要调用的函数（同时可指定传入参数类型和返回值类型） -> 指定后按python使用函数方式调用。

需要注意的是：python和go之间参数传递是需要经过C的数据类型转换的，因此需要了解python中ctypes数据类型和python数据类型以及C的数据类型对应关系

三种数据类型使用场景：

1. ctypes数据类型为指定调用函数时的传入参数和返回值的数据类型
2. python数据类型为调用函数时传入的参数的数据类型
3. C的数据类型为go代码中定义的函数所需的参数和返回值数据类型

二、示例

假设我们就有这么一个函数，需要在 Python 中调用这个函数

func add(a int, b int) int {
    
    
    return a + b
}

第一步:对此函数进行改造
如下：

// main.go
package main
​
import "C"
​
func main() {
    
    }
​
//export add
func add(a int, b int) int {
    
    
    return a + b
}

1.import “C” 这个必须要加载 Go 源文件前，这一点必须做，应该就是告诉编译器我要即将编译的软件需要做为 C 的库而不直接是二进制。这个包也提供一些功能让 Go 去直接操作 C 的数据结构等等。
2.main() main 函数一定不能少，即使没有任何一行代码也没事；
3.//export add 在函数定义之前添加上注释来告诉编译器哪些定义可以被 C 引用，注意 // 和 export 之前不能有空格，否则会导出失败的

第二步: 将 Go 编译成 C 可以调用的库

执行命令

go build --buildmode=c-shared -o library.so main.go

编译完后在当前目录下回有一个 library.so 和 library.h 的文件

第三步:python调用

编写python调用函数main.py

import ctypes

lib = ctypes.cdll.LoadLibrary("library.so")

print(lib.add(1, 2))

由于Python和Go是两种不同的语言，其参数的类型也有所不同。所以在调用时需要进一步转换成C语言类型来进行转换。

import ctypes

lib = ctypes.cdll.LoadLibrary("library.so")

GoInt64 = ctypes.c_int64
GoInt = GoInt64

add = lib.add

add.argtypes = [GoInt64, GoInt64]
add.restype = GoInt64

res = add(GoInt(1), GoInt(2))

print(res)

使用 ctypes.cdll.LoadLibrary 来加载这个动态库，然后就可以直接调用了。

其对应参数类型如下：

例如：当python传入的参数需是string时，ctypes中指定的传参参数类型需为c_wchar_p，go中需要指定接收的参数数据类型为 *C.wchar_t。

其他类型请参考文档链接https://docs.python.org/3.5/library/ctypes.html

2.grpc调用

grpc已经在之前文章https://blog.csdn.net/qq_45066628/article/details/118602349介绍过了，就不重复赘述了。

调用流程

Python gRPC

1. 环境安装

   grpcio 是启动 gRPC 服务的项目依赖

   pip install grpcio

   grpcio 是启动 gRPC 服务的项目依赖

   pip install grpcio-tools

2. 定义 proto 文件

   syntax = "proto3";
   
   import "google/protobuf/empty.proto";
   
   
   // service 关键字定义提供的服务
   service MyService {
         
         
     // 定义一个探活方法
     rpc Health (.google.protobuf.Empty) returns (.google.protobuf.Empty){
         
         
     }
     // 定义一个批量查询 user 的方法
     rpc User (UserReq) returns (UserReply){
         
         
     }
   
   }
   
   // message 关键字定义交互的数据结构
   message UserReq {
         
         
     repeated int32 userIDs= 1;
   }
   
   message UserReply {
         
         
     string message = 1;
     // repeated 定义一个数组
     repeated User data = 2;
   }
   
   message User {
         
         
     string name = 1;
     int32 age = 2;
     string email = 3;
   }
   
   

3. 编译生成代码

   使用 protoc 和相应的插件可以编译生成对应语言的代码
   -I 指定 import 路径，可以指定多个 -I 参数，编译时按顺序查找，不指定默认当前目录

   python -m grpc_tools.protoc -I ./ --python_out=. --grpc_python_out=. ./api.proto

   经过上述步骤，我们生成了这样两个文件api_pb2.py 此文件包含每个 message 生成一个含有静态描述符的模块，，该模块与一个元类（metaclass）在运行时（runtime）被用来创建所需的Python数据访问类api_pb2_grpc.py 此文件包含生成的 客户端(MyServiceStub)和服务端 (MyServiceServicer)的类。

4. 实现python服务端

   #!/usr/bin/env python3
   # -*- coding: utf-8 -*-
   import logging
   from concurrent import futures
   
   import grpc
   from api import api_pb2_grpc, api_pb2
   from api.api_pb2_grpc import MyServiceServicer
   from service import get_users
   
   
   class Service(MyServiceServicer):
       def Health(self, request, context):
           return
   
       def User(self, request, context):
           print('start to process request...')
           res = get_users(request.userIDs)
           users = []
           for u in res:
               users.append(api_pb2.User(name=u['name'], age=u['age'], email=u['email']))
           return api_pb2.UserReply(message='success', data=users)
   
   
   def serve():
       print('start grpc server====>')
       server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
       api_pb2_grpc.add_MyServiceServicer_to_server(Service(), server)
       server.add_insecure_port('[::]:50051')
       server.start()
       server.wait_for_termination()
   
   
   if __name__ == '__main__':
       logging.basicConfig()
       serve()
   
   

Go gRPC

Go 服务作为客户端调用 Python 服务，同样需要根据 proto 文件生成代码，进而创建客户端发起 RPC。

1. 环境搭建
   安装 ptotobuf, 推荐使用 brew

   brew install protobuf

   protoc go 插件安装

   go get -u github.com/golang/protobuf/protoc-gen-go

   这里安装在 GOPATH 下的 bin 目录，所以保证这个目录在 $PATH 中

   export PATH=“$PATH:$(go env GOPATH)/bin”

   代码 gprc 依赖安装

   go get -u google.golang.org/grpc

2. 生成 Go pb 代码

   protoc -I ./ --go_out=plugins=grpc:./ api.proto

3. Go客户端调用

   package main
   
   import (
   	"context"
   	"fmt"
   	"log"
   	"time"
   
   	"ginDemo/api"
   	"google.golang.org/grpc"
   )
   
   const (
   	address     = "localhost:50051"
   	defaultName = "world"
   )
   
   func main() {
         
         
   	conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithBlock())
   	if err != nil {
         
         
   		log.Fatalf("did not connect: %v", err)
   	}
   	defer conn.Close()
   	c := api.NewMyServiceClient(conn)
   
   	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
   	defer cancel()
   	r, err := c.User(ctx, &api.UserReq{
         
         UserIDs: []int32{
         
         1, 2}})
   	if err != nil {
         
         
   		log.Fatalf("could not greet: %v", err)
   	}
   	fmt.Printf("gprc result: %+v", r.Data)
   }