Can not extract the results when using cgo call and run numpy matrix dot operation of python3.7

I dont know the type of resut, thus I dont know how to extact the values in result and export it to the go array. Below is the code, which can be compiled and run.

package main
/*
#cgo LDFLAGS: -lm
#cgo pkg-config: python3
#include <Python.h>
*/
import "C"
import (
"fmt"
"github.com/DataDog/go-python3"
)
func main() {
python3.Py_Initialize()
numpy := python3.PyImport_ImportModule("numpy")
dotFunc := numpy.GetAttrString("dot")
array1 := python3.PyList_New(2)
python3.PyList_SetItem(array1, 0, python3.PyList_New(2))
python3.PyList_SetItem(array1, 1, python3.PyList_New(2))
python3.PyList_SetItem(python3.PyList_GetItem(array1, 0), 0, python3.PyFloat_FromDouble(1.0))
python3.PyList_SetItem(python3.PyList_GetItem(array1, 0), 1, python3.PyFloat_FromDouble(2.0))
python3.PyList_SetItem(python3.PyList_GetItem(array1, 1), 0, python3.PyFloat_FromDouble(3.0))
python3.PyList_SetItem(python3.PyList_GetItem(array1, 1), 1, python3.PyFloat_FromDouble(4.0))
array2 := python3.PyList_New(2)
python3.PyList_SetItem(array2, 0, python3.PyList_New(2))
python3.PyList_SetItem(array2, 1, python3.PyList_New(2))
python3.PyList_SetItem(python3.PyList_GetItem(array2, 0), 0, python3.PyFloat_FromDouble(5.0))
python3.PyList_SetItem(python3.PyList_GetItem(array2, 0), 1, python3.PyFloat_FromDouble(6.0))
python3.PyList_SetItem(python3.PyList_GetItem(array2, 1), 0, python3.PyFloat_FromDouble(7.0))
python3.PyList_SetItem(python3.PyList_GetItem(array2, 1), 1, python3.PyFloat_FromDouble(8.0))
result := dotFunc.CallFunctionObjArgs(array1, array2)
fmt.Println(array1)
fmt.Println(array2)
fmt.Println(result)
fmt.Println(python3.PyList_Size(array1))       //return 2
fmt.Println(python3.PyList_Size(array2))       //retunr 2
fmt.Println(python3.PyType_CheckExact(result)) //return false, does not know its type
}

Updated based on the first answer (also I clean up the codes to avoid importing go-python3), I should convert numpy array to c array:

package main
/*
#cgo CFLAGS: -I/anaconda3/include/python3.7m -I/lib/python3.7/site-packages/numpy/core/include
#cgo LDFLAGS: -lm -L/anaconda3/lib -lpython3.7m
#include <Python.h>
#include <numpy/arrayobject.h>
*/
import "C"
import (
"fmt"
)
func main() {
// Initialize the Python interpreter
C.Py_Initialize()
numpyModule := C.PyImport_ImportModule(C.CString("numpy"))
dotFunc := C.PyObject_GetAttrString(numpyModule, C.CString("dot"))
array1 := C.PyList_New(2)
C.PyList_SetItem(array1, 0, C.PyList_New(2))
C.PyList_SetItem(array1, 1, C.PyList_New(2))
C.PyList_SetItem(C.PyList_GetItem(array1, 0), 0, C.PyFloat_FromDouble(1.0))
C.PyList_SetItem(C.PyList_GetItem(array1, 0), 1, C.PyFloat_FromDouble(2.0))
C.PyList_SetItem(C.PyList_GetItem(array1, 1), 0, C.PyFloat_FromDouble(3.0))
C.PyList_SetItem(C.PyList_GetItem(array1, 1), 1, C.PyFloat_FromDouble(4.0))
array2 := C.PyList_New(2)
C.PyList_SetItem(array2, 0, C.PyList_New(2))
C.PyList_SetItem(array2, 1, C.PyList_New(2))
C.PyList_SetItem(C.PyList_GetItem(array2, 0), 0, C.PyFloat_FromDouble(5.0))
C.PyList_SetItem(C.PyList_GetItem(array2, 0), 1, C.PyFloat_FromDouble(6.0))
C.PyList_SetItem(C.PyList_GetItem(array2, 1), 0, C.PyFloat_FromDouble(7.0))
C.PyList_SetItem(C.PyList_GetItem(array2, 1), 1, C.PyFloat_FromDouble(8.0))
args := C.PyTuple_New(2)
C.PyTuple_SetItem(args, 0, array1)
C.PyTuple_SetItem(args, 1, array2)
result := C.PyObject_CallObject(dotFunc, args) // return np.array
result = (*C.double)(C.PyArray_DATA(result)) // np.array to c array
fmt.Println(result)
C.Py_Finalize()
}

The only problem now is: go build return error could not determine kind of name for C.PyArray_DATA. So I missing something in CFLAGS, LDFLAGS or other place?

I, for one, cannot be of much help as the package providing the Python3 bridge in your example does not work with Python ≥ 3.7, its blessed fork does not, either, and even my Debian system already has 3.11, so the packages simply do not build on my system. Still, I'll try to offer a possible path forward.

If you load up numpy in a python3 session and see the docs on numpy.dot –

>>> import numpy
>>> help(numpy.dot)

…you will notice it's documented to return a value of a custom type, provided by numpy–a numpy.ndarray, and all custom types in Python are inherently classes. You can read up on that type using help(numpy.ndarray).

Given this information, we can simply approach the value returned by the call of interest using the "stock" Python's protocol of working with objects (instances of classes): you can query any object about its type, the attributes it supports, call methods on it and so on, and the package you're using implements the necessary support, which you can see in action in one of the package's examples called "list".

A couple of assorted notes follows.

• Your example does not appear to actually use cgo, so I'm not sure it's needed–unless that's some remnant from the real code you're dealing with.

• Quite possibly you don't actually want to produce a Go's array, but rather a slice. If you do not know the distinction, start here, and continue there before continuing with your endaevor.

• As you should see from the numpy.ndarray documentation, this type is quite a complicated thing as it ostensibly supports arrays of arbitrary dimensions.

  Looks like a way forward is creating a helper function which would take an *python3.PyObject, verify it has the expected type, verify it has the expected dimensions and then extract the data–supposedly using the __index__() method of the object protocol.

• If you really just want to multiply matrices in Go, and are not actually tasked with interfacing some big existing well-tested Python code which makes heavy use of numpy, I would recommend to instead use a Go-native solution such as gonum which supports dot product in its package mat.
  This package provides implementations written in assembly for amd64, so the performance on comparable datasets should at least be on par with Python code using numpy and the end result will be much easier to support and ship.