¿Cómo ejecuto un script de Python desde C #?

Este tipo de preguntas se han hecho anteriormente en diversos grados, pero siento que no se ha respondido de manera concisa y, por lo tanto, vuelvo a preguntar.

Quiero ejecutar un script en Python. Digamos que es esto:

if __name__ == '__main__':
    with open(sys.argv[1], 'r') as f:
        s = f.read()
    print s

Que obtiene una ubicación de archivo, la lee y luego imprime su contenido. No tan complicado

Bien, entonces, ¿cómo ejecuto esto en C #?

Esto es lo que tengo ahora:

    private void run_cmd(string cmd, string args)
    {
        ProcessStartInfo start = new ProcessStartInfo();
        start.FileName = cmd;
        start.Arguments = args;
        start.UseShellExecute = false;
        start.RedirectStandardOutput = true;
        using (Process process = Process.Start(start))
        {
            using (StreamReader reader = process.StandardOutput)
            {
                string result = reader.ReadToEnd();
                Console.Write(result);
            }
        }
    }

Cuando paso la code.pyubicación como cmdy la filenameubicación ya argsque no funciona. Me dijeron que debía pasar python.execomo el cmd, y luego code.py filenamecomo el args.

He estado buscando durante un tiempo y solo puedo encontrar personas que sugieran usar IronPython o algo así. Pero debe haber una manera de llamar a un script de Python desde C #.

Alguna aclaración:

Necesito ejecutarlo desde C #, necesito capturar la salida y no puedo usar IronPython ni nada más. Cualquier truco que tengas estará bien.

PD: El código de Python real que estoy ejecutando es mucho más complejo que esto, y devuelve el resultado que necesito en C #, y el código de C # llamará constantemente al código de Python.

Finge que este es mi código:

    private void get_vals()
    {
        for (int i = 0; i < 100; i++)
        {
            run_cmd("code.py", i);
        }
    }

La razón por la que no funciona es porque tú sí UseShellExecute = false.

Si no usa el shell, tendrá que proporcionar la ruta completa al ejecutable de Python como FileName, y construir la Argumentscadena para proporcionar tanto su script como el archivo que desea leer.

También tenga en cuenta que no puede a RedirectStandardOutputmenos que UseShellExecute = false.

No estoy muy seguro de cómo se debe formatear la cadena de argumento para Python, pero necesitará algo como esto:

private void run_cmd(string cmd, string args)
{
     ProcessStartInfo start = new ProcessStartInfo();
     start.FileName = "my/full/path/to/python.exe";
     start.Arguments = string.Format("{0} {1}", cmd, args);
     start.UseShellExecute = false;
     start.RedirectStandardOutput = true;
     using(Process process = Process.Start(start))
     {
         using(StreamReader reader = process.StandardOutput)
         {
             string result = reader.ReadToEnd();
             Console.Write(result);
         }
     }
}

Si está dispuesto a usar IronPython, puede ejecutar scripts directamente en C #:

using IronPython.Hosting;
using Microsoft.Scripting.Hosting;

private static void doPython()
{
    ScriptEngine engine = Python.CreateEngine();
    engine.ExecuteFile(@"test.py");
}

Obtén IronPython aquí.

Ejecutar script Python desde C

Cree un proyecto C # y escriba el siguiente código.

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            run_cmd();
        }

        private void run_cmd()
        {

            string fileName = @"C:\sample_script.py";

            Process p = new Process();
            p.StartInfo = new ProcessStartInfo(@"C:\Python27\python.exe", fileName)
            {
                RedirectStandardOutput = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };
            p.Start();

            string output = p.StandardOutput.ReadToEnd();
            p.WaitForExit();

            Console.WriteLine(output);

            Console.ReadLine();

        }
    }
}

Python sample_script

imprimir "Prueba de Python C #"

Verá la 'Prueba de Python C #' en la consola de C #.

Me encontré con el mismo problema y la respuesta de Master Morality no lo hizo por mí. Lo siguiente, que se basa en la respuesta anterior, funcionó:

private void run_cmd(string cmd, string args)
{
 ProcessStartInfo start = new ProcessStartInfo();
 start.FileName = cmd;//cmd is full path to python.exe
 start.Arguments = args;//args is path to .py file and any cmd line args
 start.UseShellExecute = false;
 start.RedirectStandardOutput = true;
 using(Process process = Process.Start(start))
 {
     using(StreamReader reader = process.StandardOutput)
     {
         string result = reader.ReadToEnd();
         Console.Write(result);
     }
 }
}

Como ejemplo, cmd sería @C:/Python26/python.exey args sería C://Python26//test.py 100si desea ejecutar test.py con el argumento de línea cmd 100. Tenga en cuenta que la ruta del archivo .py no tiene el símbolo @.

Solo para llamar su atención sobre esto:

https://code.msdn.microsoft.com/windowsdesktop/C-and-Python-interprocess-171378ee

Funciona muy bien

Establezca WorkingDirectory o especifique la ruta completa de la secuencia de comandos de Python en el argumento

ProcessStartInfo start = new ProcessStartInfo();
start.FileName = "C:\\Python27\\python.exe";
//start.WorkingDirectory = @"D:\script";
start.Arguments = string.Format("D:\\script\\test.py -a {0} -b {1} ", "some param", "some other param");
start.UseShellExecute = false;
start.RedirectStandardOutput = true;
using (Process process = Process.Start(start))
{
    using (StreamReader reader = process.StandardOutput)
    {
        string result = reader.ReadToEnd();
        Console.Write(result);
    }
}

En realidad, es bastante fácil hacer la integración entre Csharp (VS) y Python con IronPython. No es tan complejo ... Como Chris Dunaway ya dijo en la sección de respuestas, comencé a construir esta integración para mi propio proyecto. N es bastante simple. Simplemente siga estos pasos y obtendrá sus resultados.

Paso 1: Abra VS y cree un nuevo proyecto vacío de ConsoleApp.

Paso 2: Vaya a Herramientas -> Administrador de paquetes NuGet -> Consola Administrador de paquetes.

Paso 3: después de esto, abre este enlace en tu navegador y copia el comando NuGet. Enlace: https://www.nuget.org/packages/IronPython/2.7.9

Paso 4: Después de abrir el enlace anterior, copie el comando PM> Install-Package IronPython -Version 2.7.9 y péguelo en NuGet Console en VS. Instalará los paquetes de apoyo.

Paso 5: Este es mi código que he usado para ejecutar un archivo .py almacenado en mi directorio Python.exe.

using IronPython.Hosting;//for DLHE
using Microsoft.Scripting.Hosting;//provides scripting abilities comparable to batch files
using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Sockets;
class Hi
{
private static void Main(string []args)
{
Process process = new Process(); //to make a process call
ScriptEngine engine = Python.CreateEngine(); //For Engine to initiate the script
engine.ExecuteFile(@"C:\Users\daulmalik\AppData\Local\Programs\Python\Python37\p1.py");//Path of my .py file that I would like to see running in console after running my .cs file from VS.//process.StandardInput.Flush();
process.StandardInput.Close();//to close
process.WaitForExit();//to hold the process i.e. cmd screen as output
}
} 

Paso 6: guarda y ejecuta el código

Estoy teniendo problemas con stdin/stout : cuando el tamaño de la carga útil supera varios kilobytes, se cuelga. Necesito llamar a las funciones de Python no solo con algunos argumentos cortos, sino con una carga útil personalizada que podría ser grande.

Hace un tiempo, escribí una biblioteca virtual de actores que permite distribuir tareas en diferentes máquinas a través de Redis. Para llamar al código de Python, agregué funcionalidad para escuchar los mensajes de Python, procesarlos y devolver los resultados a .NET. Aquí hay una breve descripción de cómo funciona .

También funciona en una sola máquina, pero requiere una instancia de Redis. Redis agrega algunas garantías de confiabilidad: la carga útil se almacena hasta que un trabajo confirma la finalización. Si un trabajador muere, la carga útil se devuelve a una cola de trabajo y luego es reprocesada por otro trabajador.