如何在 C# 中进行 Python 的 zip 操作？

Question

Python 的 zip 函数执行以下操作

a = [1, 2, 3]
b = [6, 7, 8]
zipped = zip(a, b)

：

[[1, 6], [2, 7], [3, 8]]

Answer 1

怎么样 这个？

C# 4.0 LINQ 的新 Zip 运算符

public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
        this IEnumerable<TFirst> first,
        IEnumerable<TSecond> second,
        Func<TFirst, TSecond, TResult> func);

Answer 2

解决方案2：与C# 4.0 Zip类似，但可以在C# 3.0中使用它

    public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
        this IEnumerable<TFirst> first,
        IEnumerable<TSecond> second,
        Func<TFirst, TSecond, TResult> func)
    {
        using(var enumeratorA = first.GetEnumerator())
        using(var enumeratorB = second.GetEnumerator())
        {
            while (enumeratorA.MoveNext())
            {
                enumeratorB.MoveNext();
                yield return func(enumeratorA.Current, enumeratorB.Current);
            }
        }
    }

Answer 3

这是 Python zip 的更现代的版本：

public static IEnumerable<(T1, T2)> Zip<T1, T2>(this IEnumerable<T1> t1, IEnumerable<T2> t2)
{
    using var t1e = t1.GetEnumerator();
    using var t2e = t2.GetEnumerator();
    while (t1e.MoveNext() && t2e.MoveNext())
        yield return (t1e.Current, t2e.Current);
}

public static IEnumerable<(T1, T2, T3)> Zip<T1, T2, T3>(this IEnumerable<T1> t1, IEnumerable<T2> t2, IEnumerable<T3> t3)
{
    using var t1e = t1.GetEnumerator();
    using var t2e = t2.GetEnumerator();
    using var t3e = t3.GetEnumerator();
    while (t1e.MoveNext() && t2e.MoveNext() && t3e.MoveNext())
        yield return (t1e.Current, t2e.Current, t3e.Current);
}

很容易制作更多扩展来同时处理更多 IEnumerable ，为了简洁起见，我将其保留为 2 和 3 版本。

Answer 4

解决方案一：

IEnumerable<KeyValuePair<T1, T2>> Zip<T1, T2>(
    IEnumerable<T1> a, IEnumerable<T2> b)
{
    var enumeratorA = a.GetEnumerator();
    var enumeratorB = b.GetEnumerator();
    while (enumeratorA.MoveNext())
    {
        enumeratorB.MoveNext();
        yield return new KeyValuePair<T1, T2>
        (
            enumeratorA.Current,
            enumeratorB.Current
        );
    }
}

Answer 5

另请查看 Cadenza，它具有各种漂亮的实用方法。

具体查看 Cadenza.Collections.EnumerableCoda< /a>.

Answer 6

我刚刚遇到了同样的问题。 .NET库没有提供解决方案，所以我自己做了。这是我的解决方案。

Pivot 方法作为 IEnumerable> 的扩展。
它要求所有序列的元素具有相同的类型T。

public static class LinqUtil
{
    /// <summary>
    /// From a number of input sequences makes a result sequence of sequences of elements
    /// taken from the same position of each input sequence.
    /// Example: ((1,2,3,4,5), (6,7,8,9,10), (11,12,13,14,15)) --> ((1,6,11), (2,7,12), (3,8,13), (4,9,14), (5,10,15))
    /// </summary>
    /// <typeparam name="T">Type of sequence elements</typeparam>
    /// <param name="source">source seq of seqs</param>
    /// <param name="fillDefault">
    /// Defines how to handle situation when input sequences are of different length.
    ///     false -- throw InvalidOperationException
    ///     true  -- fill missing values by the default values for the type T.
    /// </param>
    /// <returns>Pivoted sequence</returns>
    public static IEnumerable<IEnumerable<T>> Pivot<T>(this IEnumerable<IEnumerable<T>> source, bool fillDefault = false)
    {
        IList<IEnumerator<T>> heads = new List<IEnumerator<T>>();

        foreach (IEnumerable<T> sourceSeq in source)
        {
            heads.Add(sourceSeq.GetEnumerator());
        }

        while (MoveAllHeads(heads, fillDefault))
        {
            yield return ReadHeads(heads);
        }
    }

    private static IEnumerable<T> ReadHeads<T>(IEnumerable<IEnumerator<T>> heads)
    {
        foreach (IEnumerator<T> head in heads)
        {
            if (head == null)
                yield return default(T);
            else
                yield return head.Current;
        }
    }

    private static bool MoveAllHeads<T>(IList<IEnumerator<T>> heads, bool fillDefault)
    {
        bool any = false;
        bool all = true;

        for (int i = 0; i < heads.Count; ++i)
        {
            bool hasNext = false;

            if(heads[i] != null) hasNext = heads[i].MoveNext();

            if (!hasNext) heads[i] = null;

            any |= hasNext;
            all &= hasNext;
        }

        if (any && !all && !fillDefault)
            throw new InvalidOperationException("Input sequences are of different length");

        return any;
    }
}