A: This license has not been submitted to OSI, but it allows developers to take full advantage of a dynamic language on the CLR and to have the freedom to distribute their works for the benefit of the community at large. The license is half of a page long and very straight forward. We believe it stands up to what developers demand of an "open" license.
A: The license grants you a copyright license to make unlimited copies of the Software in source or object code form, as well as to create Derivative Works (as that term is defined under US copyright law). This means that in addition to making unlimited copies of the Software, you have a copyright license to modify the Software and to use all or part of the Software to create a Derivative Work.
A: On CodePlex you can file bugs by selecting the "Issue Tracker" tab and clicking on "New Work Item". On the home page you'll see a link to join our mailing list.
A good explanation of the Visual Studio IronPython integration sample is in this blog post.
A: One common error that you may be getting is:
C:\IronPython>ipy.exe IronPython 1.0.2424 on .NET 2.0.50727.42 Copyright (c) Microsoft Corporation. All rights reserved. >>> import System.Windows.Forms as WinForms Traceback (most recent call last): File , line 0, in -toplevel- AttributeError: 'package#' object has no attribute 'Windows'
The cause is that IronPython needs help finding any assemblies that are even a little bit out of the ordinary. The Built-in module clr provides functions to add references to .NET modules (clr.AddReference). For more information, see the Loading .NET Libraries exercise in the IronPython Tutorial (if you're reading the FAQ on the web, the tutorial.htm document is in the tutorial directory where you installed IronPython).
A: Users have to opt in to this functionality. No new keywords have been added, and the existing language semantics are unchanged. A “clr” module is available for import to turn on .NET extensions. See the IronPython Tutorial for good examples (if you're reading the FAQ on the web, the tutorial.htm document is in the tutorial directory where you installed IronPython). Using the “import clr” statement adds methods to built-in types in some cases; for example, dir(int) will show a ToString attribute. Such effects only happen in the context of the module that contains the “import clr” statement.
A: IronPython can directly import only some of the .NET libraries -- the most commonly used ones. To use additional .NET assemblies, they must be explicitly referenced. To add a reference to a .NET assembly, use one of the clr.AddReference* functions. See IronPython Tutorial for good examples and instruction on how to do this (if you're reading the FAQ on the web, the tutorial.htm document is in the tutorial directory where you installed IronPython).
A: To tell IronPython where the Python standard library is, you can add the "lib" directory of CPython to IronPython's path. To do this, put the following code into IronPython's "site.py" file (replace c:\python24\lib with your actual path to the CPython lib directory):
import sys sys.path.append(r"c:\python24\lib")
A: IronPython implements all the commonly used built-in modules. Some modules are not implemented because they are OS-specific (for example, they are only relevant on SGI or the Mac). Some modules aren't present only because we didn't have time to implement them yet. See the IronPython Differences document for details.
A: IronPython 1.0 targeted CPython 2.4.3 for compatibility. See the IronPython Differences document for details.
A: Yes, IronPython implements several 2.5 features: all(), any(), max() with a key argument, min() with a key argument, partition() and rpartition() on strings, the with statement, empty parenthetic expression for the bases classes in a class statement, try-except-finally, and ternary expressions
A: No, IronPython 1.0 targets only the .NET 2.0 Common Language Runtime. The .NET Compact Framework lacks Reflection.Emit and lightweight code generation (dynamic methods), both of which IronPython requires.
A: IronPython does not support building DLLs for a C# style of linking and calling into Python code. You can define interfaces in C#, build those into a DLL, and then implement those interfaces in Python code as well as pass the python objects that implement the interfaces to C# code.
A: IronPython does not support using PYDs built for CPython since they leverage implementation details of CPython. You can get a similar effect for new "PYD"s you would like to implement by writing them in C# or VB and building a DLL for .NET.
A: IronPython does not cache binary products for .py files, nor write fast loading version of .py files. IronPython will likely support this kind of optimization in the future.
A: .NET methods may have an Overloads attribute which can be indexed by a tuple of types to choose between overloads of a .NET method. For example, the following chooses the WriteLine method that takes an object and passes None for it:
from System import Console
Console.WriteLine.Overloads[object](None)
A: Consider the following C# class which defines methods with ref, out, and params parameters. Following the C# code are examples in the Python interpreter of calling these methods.
File a.cs (compiled with "csc.exe /t:library a.cs"):
public class C {
public static int MethodRef(ref int i) { i = 1; return 2; }
public static int MethodOut(out int i) { i = 1; return 2; }
public static int MethodParams(params object[] values) { return values.Length; }
}
Loading the class C:
>>> import clr
>>> clr.AddReference("a.dll")
>>> import C
Calling the method with ref parameters: if you pass the value (3) directly, the output value will become part of the returned tuple.
>>> C.MethodRef(3)
(2, 1)
Alternatively, you can create an instance of clr.Reference<T> and initialize it with the value that you want to pass into the method. When the call returns, the value will have been updated.
>>> import clr
>>> x = clr.Reference[int](3)
>>> x.Value
3
>>> C.MethodRef(x)
2
>>> x.Value
1
Calling the method with an out parameter is very similar, except there is no need to provide the input value. The values of the out parameters will become part of the returned tuple:
>>> C.MethodOut()
(2, 1)
You can also provide an instance of clr.Reference<T> to capture the value of the out parameter. The initial value in this case does not matter.
>>> x = clr.Reference[int]()
>>> x.Value # The Value is initialized to 0
0
>>> C.MethodOut(x)
2
>>> x.Value # Value was modified by the MethodOut method.
1
>>> x.Value = 10
>>> C.MethodOut(x)
2
>>> x.Value
1
IronPython handles methods with params arguments in a natural way. The parameters can be passed as a parameter list:
>>> C.MethodParams(1,2,3)
3
>>> C.MethodParams(1,2,3,4,5,6,)
6
A: Here is an example that shows how to create a .NET array: “System.Array[int]((1,2,3))”.
import System
System.Array[int]((1,2,3))
A: IronPython supports an indexing-like syntax for identifying concrete realizations of generic types and methods, for example:
import System
q = System.Collections.Generic.Queue[str]()
This is similar to creating a .NET array.
A: The following is a simple example of setting and getting the value of a property "Text" on a windows form. The syntax is the same as any attribute access.
>>> import System
>>> clr.AddReference("System.Windows.Forms")
>>> from System.Windows.Forms import Form
>>> f = Form()
>>> f.Text = "Hello" # Set the property
>>> f.Text # Get the property value
'Hello'
>>>
To call indexers, use Python's indexing syntax:
>>> import System
>>> h = System.Collections.Hashtable()
>>> h['a'] = 10
>>> h['a']
10
A: IronPython runs on the .NET Framework which provides more primitive types than Python. If you use normal Python code with IronPython, you will only encounter the standard Python types (int, long, float, str, ...). When calling .NET methods, IronPython will try to convert the argument values to the appropriate .NET types. See below for an example with integer numbers.
File a.cs (compiled with "csc.exe /t:library a.cs"):
public class C {
public static void MethodUShort(ushort p) { }
}
The following Python code calls the "MethodUShort" on class C with different argument values:
>>> import clr
>>> clr.AddReference("a.dll")
>>> import C
>>> C.MethodUShort(1) # conversion will succeed
>>> C.MethodUShort(65536) # 65536 won't fit into System.UInt16
Traceback (most recent call last):
File , line 0, in <stdin>##20
File , line 0, in MethodUShort##19
OverflowError: Arithmetic operation resulted in an overflow.
>>> C.MethodUShort(-1) # neither will -1
Traceback (most recent call last):
File , line 0, in <stdin>##21
File , line 0, in MethodUShort##19
OverflowError: Arithmetic operation resulted in an overflow.
A: In IronPython, all strings of length 1 will be automatically coerced into System.Char type when System.Char type is expected. If a method returns System.Char type, the actual return value will be an instance of System.Char type, but the value can be easily converted to string:
>>> x = System.Char.Parse('a')
>>> x
<System.Char object at 0x000000000000002C [a]>
>>> str(x)
'a'
A: All instances of value types are always boxed within the IronPython runtime. For more details, refer to the document on CodePlex.
A: In IronPython, the import mechanism provides access to the namespaces in .NET assemblies. Once the assembly is referenced by the IronPython runtime, it is possible to import the namespaces contained within the assembly. Once a namespace is imported, all nested namespaces are also accessible. For more information, see the Loading .NET Libraries exercise in the IronPython Tutorial (if you're reading the FAQ on the web, the tutorial.htm document is in the tutorial directory where you installed IronPython).
>>> import System
>>> clr.AddReference("System.Windows.Forms")
>>> import System.Windows
>>> form = System.Windows.Forms.Form()