Golang中命令参数的实现与使用

Golang中命令参数的实现与使用 早上好，

我的Go程序允许您创建此命令来调用另一个Python程序。

该Python程序生成随机数据并启动一个机器学习聚类算法（kmeans）。

我的问题是如何在此命令中传递我随机生成的输入数据（数据集）：

exec.Command("ipython", "-c", "import kmeans; model=kmeans.KMeans(K=5, max_iters=100, plot_steps=False);model.predict(data=data)")

此致。

2 回复

exec.Command 会正确地引用参数。以下代码有效：

package main

import (
    "bytes"
    "fmt"
    "log"
    "os/exec"
)

func main() {
    cmd := exec.Command("python3.7", "-c", "print(\"foo\"); print(1 + 2)")
    var out bytes.Buffer
    cmd.Stdout = &out
    err := cmd.Run()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%q\n", out.String())
}

输出：

"foo\n3\n"

更多关于Golang中命令参数的实现与使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


在Go中通过exec.Command传递数据给Python程序，可以通过标准输入(stdin)或命令行参数实现。以下是两种方法的示例：

方法1：通过标准输入传递数据（推荐）

package main

import (
    "bytes"
    "fmt"
    "os/exec"
)

func main() {
    // 准备要传递的数据
    data := `[[1.2, 2.3, 3.4], [4.5, 5.6, 6.7], [7.8, 8.9, 9.0]]`
    
    // 创建命令
    cmd := exec.Command("ipython", "-c", `
import sys
import json
import kmeans

# 从标准输入读取数据
input_data = sys.stdin.read()
data = json.loads(input_data)

# 创建模型并进行预测
model = kmeans.KMeans(K=5, max_iters=100, plot_steps=False)
result = model.predict(data=data)
print(result)
`)
    
    // 将数据写入命令的标准输入
    cmd.Stdin = bytes.NewBufferString(data)
    
    // 捕获输出
    var out bytes.Buffer
    cmd.Stdout = &out
    
    // 执行命令
    err := cmd.Run()
    if err != nil {
        fmt.Printf("执行错误: %v\n", err)
        return
    }
    
    fmt.Printf("预测结果: %s\n", out.String())
}

方法2：通过命令行参数传递数据

package main

import (
    "encoding/json"
    "fmt"
    "os/exec"
    "strings"
)

func main() {
    // 准备数据
    data := [][]float64{
        {1.2, 2.3, 3.4},
        {4.5, 5.6, 6.7},
        {7.8, 8.9, 9.0},
    }
    
    // 将数据转换为JSON字符串
    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Printf("JSON编码错误: %v\n", err)
        return
    }
    
    // 转义引号，避免命令行解析问题
    escapedData := strings.ReplaceAll(string(jsonData), `"`, `\"`)
    
    // 创建命令，通过命令行参数传递数据
    cmd := exec.Command("ipython", "-c", fmt.Sprintf(`
import json
import kmeans

# 从命令行参数获取数据
import sys
if len(sys.argv) > 1:
    data_str = sys.argv[1]
else:
    data_str = sys.argv[0]

data = json.loads(data_str)

# 创建模型并进行预测
model = kmeans.KMeans(K=5, max_iters=100, plot_steps=False)
result = model.predict(data=data)
print(json.dumps(result))
`, escapedData))
    
    // 捕获输出
    var out bytes.Buffer
    cmd.Stdout = &out
    
    // 执行命令
    err = cmd.Run()
    if err != nil {
        fmt.Printf("执行错误: %v\n", err)
        return
    }
    
    fmt.Printf("预测结果: %s\n", out.String())
}

方法3：通过环境变量传递数据

package main

import (
    "encoding/json"
    "fmt"
    "os/exec"
)

func main() {
    // 准备数据
    data := map[string]interface{}{
        "features": [][]float64{
            {1.2, 2.3, 3.4},
            {4.5, 5.6, 6.7},
        },
        "samples": 2,
    }
    
    // 将数据转换为JSON
    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Printf("JSON编码错误: %v\n", err)
        return
    }
    
    // 创建命令
    cmd := exec.Command("ipython", "-c", `
import os
import json
import kmeans

# 从环境变量获取数据
data_str = os.environ.get("ML_DATA", "[]")
data = json.loads(data_str)

# 创建模型并进行预测
model = kmeans.KMeans(K=5, max_iters=100, plot_steps=False)
result = model.predict(data=data["features"])
print(json.dumps({"predictions": result, "samples": data["samples"]}))
`)
    
    // 设置环境变量
    cmd.Env = append(os.Environ(), "ML_DATA="+string(jsonData))
    
    // 捕获输出
    var out bytes.Buffer
    cmd.Stdout = &out
    
    // 执行命令
    err = cmd.Run()
    if err != nil {
        fmt.Printf("执行错误: %v\n", err)
        return
    }
    
    fmt.Printf("预测结果: %s\n", out.String())
}

方法4：通过临时文件传递数据（适合大数据集）

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "os"
    "os/exec"
    "path/filepath"
)

func main() {
    // 准备大数据集
    data := make([][]float64, 1000)
    for i := range data {
        data[i] = []float64{float64(i), float64(i * 2), float64(i * 3)}
    }
    
    // 创建临时文件
    tmpfile, err := ioutil.TempFile("", "ml_data_*.json")
    if err != nil {
        fmt.Printf("创建临时文件错误: %v\n", err)
        return
    }
    defer os.Remove(tmpfile.Name())
    
    // 写入数据到临时文件
    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Printf("JSON编码错误: %v\n", err)
        return
    }
    
    if _, err := tmpfile.Write(jsonData); err != nil {
        fmt.Printf("写入文件错误: %v\n", err)
        return
    }
    tmpfile.Close()
    
    // 创建命令，传递文件路径
    cmd := exec.Command("ipython", "-c", fmt.Sprintf(`
import json
import kmeans
import os

# 从文件读取数据
file_path = r"%s"
with open(file_path, 'r') as f:
    data = json.load(f)

# 创建模型并进行预测
model = kmeans.KMeans(K=5, max_iters=100, plot_steps=False)
result = model.predict(data=data)

# 清理临时文件
os.remove(file_path)

print(json.dumps({"predictions": result, "samples": len(data)}))
`, tmpfile.Name()))
    
    // 捕获输出
    var out bytes.Buffer
    cmd.Stdout = &out
    
    // 执行命令
    err = cmd.Run()
    if err != nil {
        fmt.Printf("执行错误: %v\n", err)
        return
    }
    
    fmt.Printf("预测结果: %s\n", out.String())
}

选择哪种方法取决于数据大小和具体需求：

  • 小数据：使用方法1（标准输入）或方法2（命令行参数）
  • 敏感数据：使用方法1（标准输入），避免在进程列表中可见
  • 大数据：使用方法4（临时文件）
  • 结构化数据：使用方法3（环境变量）适合配置信息
回到顶部