Können Sie die LINQ-Typen und-Erweiterung-Methoden, die in IronPython?

Question

Ist es möglich mit dem LINQ-Typen und-Erweiterung-Methoden, die in IronPython?

Wenn ja, wie?Und auch gibt es oft mehr pythonic, das gleiche zu tun?

Answer 1

Ironpython 2.7 schließlich überbrückt diese Lücke mit dem clr.ImportExtensions Verfahren, das die Erweiterungsmethoden aus einem Namespace zu den Zielart fügt z.

>& 'C:\Program Files\IronPython 2.7\ipy.exe'
IronPython 2.7 (2.7.0.40) on .NET 4.0.30319.225
Type "help", "copyright", "credits" or "license" for more information.
>>> import clr
>>> clr.AddReference("System.Core")
>>> from System.Collections.Generic import List
>>> dir (List)
['Add', 'AddRange', 'AsReadOnly', 'BinarySearch', 'Capacity', 'Clear', 'Contains', 'ConvertAll', 'CopyTo', 'Count', 'Enu
merator', 'Equals', 'Exists', 'Find', 'FindAll', 'FindIndex', 'FindLast', 'FindLastIndex', 'ForEach', 'GetEnumerator', '
GetHashCode', 'GetRange', 'GetType', 'IndexOf', 'Insert', 'InsertRange', 'IsReadOnly', 'IsSynchronized', 'Item', 'LastIn
dexOf', 'MemberwiseClone', 'ReferenceEquals', 'Remove', 'RemoveAll', 'RemoveAt', 'RemoveRange', 'Reverse', 'Sort', 'Sync
Root', 'ToArray', 'ToString', 'TrimExcess', 'TrueForAll', '__add__', '__class__', '__contains__', '__delattr__', '__doc_
_', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__iter__', '__len__', '__new__', '__reduce
__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__']
>>> import System
>>> clr.ImportExtensions(System.Linq)
>>> dir (List)
['Add', 'AddRange', 'Aggregate', 'All', 'Any', 'AsEnumerable', 'AsParallel', 'AsQueryable', 'AsReadOnly', 'Average', 'Bi
narySearch', 'Capacity', 'Cast', 'Clear', 'Concat', 'Contains', 'ConvertAll', 'CopyTo', 'Count', 'DefaultIfEmpty', 'Dist
inct', 'ElementAt', 'ElementAtOrDefault', 'Enumerator', 'Equals', 'Except', 'Exists', 'Find', 'FindAll', 'FindIndex', 'F
indLast', 'FindLastIndex', 'First', 'FirstOrDefault', 'ForEach', 'GetEnumerator', 'GetHashCode', 'GetRange', 'GetType',
'GroupBy', 'GroupJoin', 'IndexOf', 'Insert', 'InsertRange', 'Intersect', 'IsReadOnly', 'IsSynchronized', 'Item', 'Join',
 'Last', 'LastIndexOf', 'LastOrDefault', 'LongCount', 'Max', 'MemberwiseClone', 'Min', 'OfType', 'OrderBy', 'OrderByDesc
ending', 'ReferenceEquals', 'Remove', 'RemoveAll', 'RemoveAt', 'RemoveRange', 'Reverse', 'Select', 'SelectMany', 'Sequen
ceEqual', 'Single', 'SingleOrDefault', 'Skip', 'SkipWhile', 'Sort', 'Sum', 'SyncRoot', 'Take', 'TakeWhile', 'ToArray', '
ToDictionary', 'ToList', 'ToLookup', 'ToString', 'TrimExcess', 'TrueForAll', 'Union', 'Where', 'Zip', '__add__', '__clas
s__', '__contains__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__',
 '__iter__', '__len__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__'
, '__str__', '__subclasshook__']
>>>

, die in Einklang mit IronRuby 1.1 der using_clr_extensions Methode bringt.

Answer 2

Einige der Dinge, die Sie mit LINQ tun würde, kann mit Listenkomprehensionen getan werden:

[myFunc(i) for i in numbers if i > 3]

Oder Sie Karte verwenden können, reduzieren und Filter:

map(myFunc, filter(lambda x: x > 3, numbers))

Aber Listenkomprehensionen sind viel mehr „Pythonic“ als die funktionale Programmierung Konstrukte verwenden. Für Dinge zu reduzieren, sollten Sie "" mit . Beitreten oder Summe . Und Sie können den Wahrheitswert gesamten Iterables überprüfen, indem Sie mit jede und alle

Denken Sie daran, diese Übersetzungen:

Select -> map
Where -> filter
Aggregate -> reduce

Und Sie werden auch auf Ihrem Weg!

Answer 3

Ironpython 2.7.1 Sie clr.ImportExtensions für diesen Anwendungsfall .

import clr
clr.AddReference("System.Core")
import System
clr.ImportExtensions(System.Linq)

# will print 3 and 4 :)
[2, 3, 4].Where(lambda x: x != 2).ToList().ForEach(System.Console.WriteLine)

Ein wenig Hintergrund: Ironpython 2.7 zunächst diese Funktion eingeführt, aber es gab an Ausgabe den gestoppt es von wirklich brauchbar zu sein.

Answer 4

Ich beschrieben wird ein C# - wrapper-Klasse um die LINQ-erweiterungsmethoden zu erreichen eine syntax ähnlich wie C#'s 'angekettet extension method' syntax in IronPython.

Die Idee ist, eine Art von decorator-Klasse um IEnumerable das ruft einfach die Erweiterung Methoden.Wahrscheinlich ist dies die wrapper-Klasse geschrieben werden können, ebenso in IronPython, aber ich bin nicht so fließend in python noch :-)

public class ToLinq<T> : IEnumerable<T>
{
    private readonly IEnumerable<T> _wrapped;

    public ToLinq(IEnumerable<T> wrapped)
    {
       _wrapped = wrapped;
    }

    public ToLinq<T> Where(Func<T, bool> predicate)
    {
        return new ToLinq<T>(_wrapped.Where(predicate));
    }


    // ... similar methods for other operators like Select, Count, Any, ...

}

Dies ermöglicht eine syntax wie die folgende:

johns = ToLinq[Customer](customers)\
          .Where(lambda c: c.Name.StartsWith("John"))\
          .Select(lambda c: c.Name)

Haftungsausschluss:dies ist etwas, was ich versuchte, als lernen-übung, die ich noch nicht verwendet, das in einer real-world-Projekt.