IronPython es un interprete de Python para el CLR (Common Language Runtime) de .NET, está creado en C# y permite que cualquier programa en Python pueda ser interpretado con este además de poder acceder a las bibliotecas .NET.

• Para arrancar la consola de IronPython ejecutaremos el programa ipy.exe.
• Para arrancar la consola de IronPython permitiendo el autocompletado con tab haremos: ipy.exe -X:TabCompletion.
• Para salir de la consola haremos ctrl + Z y luego Enter o F6 y luego Enter.
• Para hacer que IronPython se ejecute en background (sin ventana de consola), en vez de usar ipy.exe usaremos ipyw.exe.
• Para lanzar un script ejecutaremos IronPython por consola mediante el comando que queramos seguido de la ruta del script.

• Desde la consola podemos hacer una llamada a dir() lo que nos devolverá las posibilidades del entorno.
• Podemos importar el contenido de un módulo, por ejemplo sys: import sys. Esto dará acceso a dicho módulo el cual podremos consultar ahora con dir(sys).
  • sys.path devolverá la ruta de la ejecución de IronPython.
  • sys.version
  • sys.executable devolverá la dirección del ejecutable de la aplicación.
• Hacer __doc__ trae la documentación de una clase\función, por ejemplo en el módulo first.py importado existe la siguiente función, haciendo first.add.__doc__ nos devolvería el texto que indica lo que esta hace.

def add(a, b):
    "add(a, b) -> returns a + b"
    return a + b

• El comando import también puede ser usado para importar al “por defecto”, por ejemplo (y con acceso a .NET) podremos hacer lo siguiente, esto permitirá llamar a las funciones System.Math.Abs, System.Math.Pow… llamandolas únicamente como Abs, Pow…

from System.Math import *

• Tal vez queramos agregar un directorio para que sus archivos .py sean accesibles y poder hacer import de ellos (un ejemplo sería la librería estándard de Python), para ello en la carpeta Lib de IronPython existe un archivo denominado site.py (y si no se crea!), ese se ejecuta cada vez que se ejecuta un archivo con IronPython por lo que podremos agregar el directorio así (por ejemplo si tenemos la librería estándard de python en c:\python26\lib):

import sys
sys.path.append(r"c:\python26\lib")

Para acceder a un namespace de .NET haremos un import de este, por ejemplo:

import System
dir (System.Environment)
System.Console.WriteLine("hola mundo!")

Para utilizar las clases de .NET primero tendríamos que importarlas y luego, con sintaxis Python, utilizarlas.
En el siguiente ejemplo se recogen las clases de System.Collections y luego se crea un objeto Hashtable, se introducen sus datos y luego se muestran estos:

from System.Collections import *
h = Hashtable()
h["a"] = "IronPython"
h["b"] = "Tutorial"
print h["a"]
for e in h: 
  print e.Key, ":", e.Value

Podemos declarar las listas a partir de arrays python:

l = ArrayList([1,2,3])
s = Stack((1,2,3))

Para declarar una clase genérica en IronPython utilizaremos la declaración como en Python pero antes de los parentesis pondremos entre corchetes el tipo:

from System import *
from System.Collections.Generic import *
l = List[String]()
l.Add("hola")
l.Add("adios")
for e in l:
	print e

IronPython puede importar algunas librerías de .NET (las más usadas), pero para agregar otras estas deben ser referenciadas mediante el módulo clr en el cual podemos encontrar:

• clr.AddReference, que agrega una referencia a un ensamblado .NET.
• clr.AddReferenceToFile agrega una referencia a un ensamblado especificando su nombre de fichero, es necesario que el ensamblado esté en un directorio listado en sys.path.
• clr.AddReferenceToFileAndPath, igual que el AddReferenceToFile pero este acepta la ruta absoluta.
• clr.AddReferenceByName agrega la referencia especificando el nombre completo del ensamblado, por ejemplo: System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089.
• clr.AddReferenceByPartialName agrega la referencia especificando un nombre parcial de ensamblado.

Luego deberemos importar el namespace.

import clr
clr.AddReference("System.Xml")
import System.Xml
d = System.Xml.XmlDocument()
d.Load("file.xml")

O con una librería creada por nosotros:

import clr
clr.AddReferenceToFile("ClassLibrary1.dll")
from ClassLibrary1 import *
c = Class1()
c.Suma(3,5)

Se agregan como en C#, pero en vez de ser métodos de clases son funciones en Python:

from System.IO import *
w = FileSystemWatcher()
w.Path = "."
def handle (*args):print args
w.Created += handle
w.Changed += handle
w.EnableRaisingEvents = True

Podemos indicar los parámetros:

def handle (w, a):print a.ChangeType, a.FullPath

Y para elminarlos:

w.Changed -= handle

Debido a la necesidad de un objeto aplicación y tal durante la ejecución de un programa con GUI en .NET la cosa se complica con IronPython, pero podemos hacerlo más fácil importando el archivo winforms.py que está en la carpeta del tutorial, de esa forma los imports y tal ya los hace este:

import winforms
from System.Windows.Forms import *
 
def prueba (*args):
	MessageBox.Show("hola caracola")
 
form1 = Form()
b = Button()
b.Text = "hola"
b.Click += prueba
form1.Controls.Add(b)
form1.Text = "prueba"
form1.Show()

import System
System.Array[int]((1,2,3))

O…

Array[Array[int]]( ( (1,2), (2,3) ) )

from System import Console
Console.WriteLine.Overloads[object](None)

• Si quisieramos debugar mediante visual studio lo que haríamos sería Archivo –> Abrir proyecto o solución y eligiríamos el archivo ipy.exe de IronPython, luego en las propiedades del proyecto creado indicar el directorio donde trabajamos y como argumentos -D y el nombre del archivo. Algo así:

• En la carpeta Tools/Scripts hay un archivo denominado pyc.py este es un compilador a CLR. Su uso es ipy pyc.py script.py, el script.py ha de estar en UTF-8.

• Binarios, 2.6, compatible con CPython 2.x.