做实验室的项目，使用socket在python和unity之间传输json数据，遇到了不少坑。
 
python程序之间以及C#程序之间的socket通信
 
先讲讲两个python之间的socket通信，不得不赞叹python写代码简直舒服，估计以后写代码会经常拿python先试试水比较思路，有大致模型后再考虑转其他语言编码
 
比较需要注意的是，在不同语言的程序之间进行socket通信，编码需要同时设置为UTF-8或者其他，否者将会出现乱码
 
python程序和C#程序的socket传输json
 
先码上
 
import socket
 
import threading
 
import json
 
sendData = {
 
"infolist":
 
[
 
{
 
"name": "fefa",
 
"age": "34"
 
},
 
{
 
"name": "hrg",
 
"age": "21
 
}
 
]
 
}
 
# 当新的客户端连入时会调用这个方法
 
def on_new_connection(client_executor, addr):
 
print('Accept new connection from %s:%s...' % addr)
 
# 发送一个信息
 
#while(True):
 
client_executor.send(bytes(repr(json.dumps(sendData)).encode('utf-8'))) #发送json信息
 
client_executor.close()
 
print('Connection from %s:%s closed.' % addr)
 
# 构建Socket实例、设置端口号 和监听队列大小
 
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
listener.bind(('127.0.0.1', 10086))
 
listener.listen(5)
 
print('Waiting for connect...')
 
# 进入死循环，等待新的客户端连入。一旦有客户端连入，就分配一个线程去做专门处理。然后自己继续等待。
 
while True:
 
client_executor, addr = listener.accept()
 
t = threading.Thread(target=on_new_connection, args=(client_executor, addr))
 
t.start()
 
通过python发送json信息，首先需要使用json.dumps将dict格式转化为str格式，但socket仅支持发送byte序列，因而还需要将str序列化，也就是repr()函数，再一个编码完成即可
 
而对应于unity端的C# socket接收，使用Unity工具集的jsonUtility进行json解析
 
using Assets.Scripts;
 
using System;
 
using System.Collections.Generic;
 
using System.IO;
 
using System.Linq;
 
using System.Net;
 
using System.Net.Sockets;
 
using System.Runtime.Serialization;
 
using System.Text;
 
using System.Threading;
 
using UnityEngine;
 
public class getSocket : MonoBehaviour
 
{
 
private TextMesh text;
 
private string message;
 
private Socket client;
 
private string host = "127.0.0.1";
 
private int port = 10086;
 
private byte[] messTmp;
 
// Use this for initialization
 
void Start()
 
{
 
text = GameObject.FindGameObjectWithTag("text").GetComponent();
 
messTmp = new byte[1024];
 
// 构建一个Socket实例，并连接指定的服务端。这里需要使用IPEndPoint类(ip和端口号的封装)
 
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
try
 
{
 
client.Connect(new IPEndPoint(IPAddress.Parse(host), port));
 
}
 
catch (Exception e)
 
{
 
Console.WriteLine(e.Message);
 
return;
 
}
 
//client.Close();
 
}
 
Data ReadToObject(string json)
 
{
 
Data deserializedUser = new Data();
 
deserializedUser = (Data)JsonUtility.FromJson(json, deserializedUser.GetType());
 
return deserializedUser;
 
}
 
void GetMessage()
 
{
 
var count = client.Receive(messTmp);
 
if (count != 0)
 
{
 
Data frame = ReadToObject(Encoding.UTF8.GetString(messTmp, 1, count - 2));
 
message = frame.ToString();
 
Array.Clear(messTmp, 0, count);
 
}
 
}
 
void FixedUpdate()
 
{
 
GetMessage();
 
text.text = message;
 
}
 
}
 
Data.cs
 
[Serializable]
 
class Data
 
{
 
public List infolist;
 
public override string ToString()
 
{
 
string tmp = "";
 
foreach(Frame one in infolist)
 
{
 
tmp += one+"\n";
 
}
 
return tmp;
 
}
 
}
 
Frame.cs
 
[Serializable]
 
class Frame
 
{
 
public string name;
 
public string age;
 
public override string ToString()
 
{
 
return "name: " + name + " age: " + age;
 
}
 
}
 
unity端需要注意几点：
 
1.jsonUtility存在一些局限性(这是个大坑)。
 
好比如以上代码，如果python传输过来的数据直接是
 
{
 
"name": "fefa",
 
"age": "34"
 
}
 
或者
 
[
 
{
 
"name": "fefa",
 
"age": "34"
 
},
 
{
 
"name": "hrg",
 
"age": "21"
 
}
 
]
 
并直接进行解析赋予对象，将导致解析失败
 
2.对于被序列化的对象，必须加上[Serializable]
 
3.经过python的json.dumps过来后的数据不可以直接在C#进行解析！如下图
 

 
3.JPG
 
注意蓝色一行，(测试用)，从socket刚刚接收过来的数据，解析为str后，也就是字符串haha，里面竟然有“‘”，这里没办法解析，需要去除，否则报错，所以在传入ReadToObjec()函数里面的string是去除了“’”的字符串
 
稍触皮毛，有深入会改进
 
参考：
 
http://blog.csdn.net/yy763496668/article/details/77875195
 
https://www.jianshu.com/p/269826e9e06e

我想用IronPython作为Unity的外部语言脚本。IronPython执行加载所需的DLL放在Assets\Plugins。然而，当我运行脚本的时候出现了如下错误：
PythonImportErrorException: No module named UnityEngine
IronPython.Modules.Builtin.__import__ (IronPython.Runtime.Calls.ICallerContext,string,object,object,object) 
(wrapper dynamic-method) object.__import__##5 (IronPython.Runtime.Calls.ICallerContext,object,object,object,object) 
IronPython.Runtime.Calls.FastCallableWithContextAny.Call (IronPython.Runtime.Calls.ICallerContext,object,object,object,object) 
IronPython.Runtime.Calls.BuiltinFunction.Call (IronPython.Runtime.Calls.ICallerContext,object,object,object,object) 
IronPython.Runtime.Operations.Ops.CallWithContext (IronPython.Runtime.Calls.ICallerContext,object,object,object,object,object) 
IronPython.Runtime.Importer.Import (IronPython.Runtime.PythonModule,string,IronPython.Runtime.List) 
IronPython.Runtime.Operations.Ops.Import (IronPython.Runtime.PythonModule,string) 
(wrapper dynamic-method) object.##1 (IronPython.Runtime.ModuleScope) 
脚本和UnityEngine.dll是在同一个文件夹里的。这个是脚本。
import clr
clr.LoadAssemblyFromFile("UnityEngine.dll")
import UnityEngine
from UnityEngine import *
Debug.Log("Hello World from Python!")

 
 
 
Unity 基础 之 Unity 简单调用 Python （传递多个参数并接收返回值）
 
 
 
目录
 
Unity 基础 之 Unity 简单调用 Python （传递多个参数并接收返回值）
 
一、简单介绍
 
二、实现原理
 
三、注意事项
 
四、效果预览
 
五、实现步骤
 
六、关键代码
 

 
 
一、简单介绍
 
Unity中的一些基础知识点。
 
本节介绍，在Unity 应用的时候，可能遗忘了安装 VS，或者想安装其他版本的VS供Unity使用；这里演示，单独安装 Visual Studio 工具，然后配置给 Unity 使用的方法；不过建议还是在 Unity 安装的使用一起安装。
 
 
 
二、实现原理
 
1、Process 配置 Python 路径、参数等，实现调用 python 脚本的功能
 
2、Process.StartInfo.Arguments 的值是 路径+参数组合设置，可以没有参数
 
3、Python 返回结果在 Process.OutputDataReceived 添加委托获取
 
本质：在窗口执行 python 脚本一样，其实就是调用窗口执行 python
 
 
 
Python 脚本的参数传递
 
 
1、调用python脚本直接使用shell或bat命令可以:
 
 
python xxx/xxx/xxx/test.python
 
 
2、需要传递参数就变为:
 
 
python xxx/xxx/xxx/test.python param1 param2
 
 
3、只需要在python文件路径后面加上参数即可，用空格分割。
 
 
在python脚本中接收参数需要用：
 
 
import sys
 
 
param1 = sys.argv[1]
 
 
param2 = sys.argv[2]
 
 
sys.argv 是将shell命令中除去‘python’后以空格分割的数组，index=0是python脚本的路径，index=1之后的是对应为的参数。
 
 
 
 
三、注意事项
 
1、由于是执行 python 脚本，得到返回值，所以对应的函数结果一定要在 python 打印出来，Unity 从打印中得到结果
 
2、python 脚本调用函数的脚本，尽量在同一个文件夹，以避免出现不必要的问题哈
 
 
 
四、效果预览
 
 
 
 
五、实现步骤
 
1、打开 Pycharm （可以是其他的编辑器），新建脚本，实现代码功能
 
 
 
 
2、打开Unity，新建空工程
 
 
 
 
3、工程中新建脚本，实现调用 Python 的代码逻辑
 
 
 
 
4、把脚本挂载到 场景中
 
 
 
 
5、运行场景，调用Python成功，效果如上
 
 
 
 
六、关键代码
 
1、UnityCallPython.cs
 


using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using UnityEngine;

/// <summary>
/// 简单的Unity 直接调用 Python 的方法
/// </summary>
public class UnityCallPython : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        string basePath = @"D:\MySoftware\Projects\PycharmProjects\HelloWorld\";

        //CallPythonHW(basePath+ "HelloWorld.py");
        CallPythonAddHW(basePath+ "AddHelloWorld.py",3.6f,5.9f);
    }

    void CallPythonHW(string pyScriptPath) {
        CallPythonBase(pyScriptPath);
    }

    void CallPythonAddHW(string pyScriptPath,float a,float b)
    {
        CallPythonBase(pyScriptPath,a.ToString(),b.ToString());
    }

    /// <summary>
    /// Unity 调用 Python
    /// </summary>
    /// <param name="pyScriptPath">python 脚本路径</param>
    /// <param name="argvs">python 函数参数</param>
    public void CallPythonBase(string pyScriptPath, params string[] argvs) {
        Process process = new Process();

        // ptython 的解释器位置 python.exe
        process.StartInfo.FileName = @"D:\MySoftware\Anaconda3\envs\UnityPython_3p6\python.exe";

        // 判断是否有参数（也可不用添加这个判断）
        if (argvs != null)
        {
            // 添加参数 （组合成：python xxx/xxx/xxx/test.python param1 param2）
            foreach (string item in argvs)
            {
                pyScriptPath += " " + item;
            }
        }
        UnityEngine.Debug.Log(pyScriptPath);

        process.StartInfo.UseShellExecute = false;
        process.StartInfo.Arguments = pyScriptPath;     // 路径+参数
        process.StartInfo.RedirectStandardError = true;
        process.StartInfo.RedirectStandardInput = true;
        process.StartInfo.RedirectStandardOutput = true;
        process.StartInfo.CreateNoWindow = true;        // 不显示执行窗口

        // 开始执行，获取执行输出，添加结果输出委托
        process.Start();
        process.BeginOutputReadLine();
        process.OutputDataReceived += new DataReceivedEventHandler(GetData);
        process.WaitForExit();
    }

    /// <summary>
    /// 输出结果委托
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void GetData(object sender, DataReceivedEventArgs e){        

        // 结果不为空才打印（后期可以自己添加类型不同的处理委托）
        if (string.IsNullOrEmpty(e.Data)==false)
        {
            UnityEngine.Debug.Log(e.Data);
        }
    }
}
 
 
 
2、HelloWorld.py
 
def hw():
    print('Hello World')


if __name__ == '__main__':
    hw()
 
 
 
3、AddHelloWorld.py
 
import HelloWorld
import sys


def add(a, b):
    return float(a) + float(b)


if __name__ == '__main__':
    print(add(sys.argv[1], sys.argv[2]))
    HelloWorld.hw()
 
 
 

 

 
I'm making a Q-Learning bot for a Unity game, the bot is in Python and the game is in c#, how can I make the two programs exchange data of any kind (i.e integers string arrays etc)?
 
Any way to make Python and c# for Unity communicate will solve my problem,
 
I have no problem with integrating anything to my code.
 
Edit: The other question is like mine, but the answer doesn't explain what to do from the Python side.
 
My Python version is 3.6.
 
解决方案
 
This is what I use for communication between unity and python. A mix from different sources/tutorials.
 
(It works for me, but a known problem is that Unity freezes when there is an error in python. I already wrote a try/catch method that returns an empty bytearray, but that doesn't seem to work.)
 
C# script
 
using UnityEngine;
 
//using System.Net;
 
using System.Net.Sockets;
 
using System;
 
public class SocketFloat : MonoBehaviour
 
{
 
public string ip = "127.0.0.1";
 
public int port = 60000;
 
private Socket client;
 
[SerializeField]
 
private float[] dataOut, dataIn; //debugging
 
/// 
 
/// Helper function for sending and receiving.
 
/// 
 
/// Data to send
 
/// 
 
protected float[] ServerRequest(float[] dataOut)
 
{
 
//print("request");
 
this.dataOut = dataOut; //debugging
 
this.dataIn = SendAndReceive(dataOut); //debugging
 
return this.dataIn;
 
}
 
/// 
 
/// Send data to port, receive data from port.
 
/// 
 
/// Data to send
 
/// 
 
private float[] SendAndReceive(float[] dataOut)
 
{
 
//initialize socket
 
float[] floatsReceived;
 
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
client.Connect(ip, port);
 
if (!client.Connected) {
 
Debug.LogError("Connection Failed");
 
return null;
 
}
 
//convert floats to bytes, send to port
 
var byteArray = new byte[dataOut.Length * 4];
 
Buffer.BlockCopy(dataOut, 0, byteArray, 0, byteArray.Length);
 
client.Send(byteArray);
 
//allocate and receive bytes
 
byte[] bytes = new byte[4000];
 
int idxUsedBytes = client.Receive(bytes);
 
//print(idxUsedBytes + " new bytes received.");
 
//convert bytes to floats
 
floatsReceived = new float[idxUsedBytes/4];
 
Buffer.BlockCopy(bytes, 0, floatsReceived, 0, idxUsedBytes);
 
client.Close();
 
return floatsReceived;
 
}
 
}
 
Python code
 
import socket
 
import struct
 
import traceback
 
import logging
 
import time
 
def sending_and_reciveing():
 
s = socket.socket()
 
socket.setdefaulttimeout(None)
 
print('socket created ')
 
port = 60000
 
s.bind(('127.0.0.1', port)) #local host
 
s.listen(30) #listening for connection for 30 sec?
 
print('socket listensing ... ')
 
while True:
 
try:
 
c, addr = s.accept() #when port connected
 
bytes_received = c.recv(4000) #received bytes
 
array_received = np.frombuffer(bytes_received, dtype=np.float32) #converting into float array
 
nn_output = return_prediction(array_received) #NN prediction (e.g. model.predict())
 
bytes_to_send = struct.pack('%sf' % len(nn_output), *nn_output) #converting float to byte
 
c.sendall(bytes_to_send) #sending back
 
c.close()
 
except Exception as e:
 
logging.error(traceback.format_exc())
 
print("error")
 
c.sendall(bytearray([]))
 
c.close()
 
break
 
sending_and_reciveing()
 
If you want to make a request, let your Unity script (the one you are working with) derive from SocketFloat:
 
public class Turing : SocketFloat
 
Calling ServerRequest returns a predictions from Python.
 
float[] prediction = ServerRequest(myArray)