Apache spark 如何在Spark中成对合并分区？

我有一组点（每个点都是文本文件中的一行），分布在Spark的分区之间。

我使用mapPartitions操作，它会使我在每个分区中得到一半的点（这与为什么和如何无关）

现在，我想成对合并分区，所以分区#1和#2将是一个合并分区，分区#3和#4将是第二个合并分区，依此类推

我将继续运行mapPartitions，直到只剩下几个分区。 我怎样才能用Spark做到这一点

与Hadoop类似的是，我成对合并输出文件，然后再次运行TAK

我会再次澄清：我有x个分区，在我运行mapPartitions之后，

---

我想成对地合并它们，这样我就有了x/2分区，然后再次运行mapPartitions等等

这个问题相当模糊。 如果我没有弄错，您可以在将数据映射到（键，值）后尝试reduceByKey

（）

希望这有帮助

---

编辑：您应该将mapPartitionsWithIndex（func）与func一起使用，func的类型必须是（Int，Iterator）=>Iterator。

这个问题相当模糊。 如果我没有弄错，您可以在将数据映射到（键，值）后尝试reduceByKey

（）

希望这有帮助

---

编辑：您应该将mapPartitionsWithIndex（func）与func一起使用，func的类型必须是（Int，Iterator）=>Iterator。

这个问题相当模糊。 如果我没有弄错，您可以在将数据映射到（键，值）后尝试reduceByKey

（）

希望这有帮助

---

编辑：您应该将mapPartitionsWithIndex（func）与func一起使用，func的类型必须是（Int，Iterator）=>Iterator。

这个问题相当模糊。 如果我没有弄错，您可以在将数据映射到（键，值）后尝试reduceByKey

（）

希望这有帮助

编辑：您应该将mapPartitionsWithIndex（func）与func一起使用，func的类型必须为（Int，Iterator）=>Iterator。

将类似的东西用作模型应该可以做到：

from math import log

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0
    def mapPartition(i, iter):
        i = i / 2
        for x in iter:
            yield i, x

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .mapPartitionsWithIndex(mapPartition)
            .reduceByKey(f, rdd.getNumPartitions() / 2)
            .values())

    return rdd.first()

如果您更喜欢更明确的方法，则始终保留分区号：

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0

    def initPartition(i, iter):
        for x in iter:
            yield i, x

    rdd = rdd.mapPartitionsWithIndex(initPartition)

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .reduceByKey(f)
            .map(lambda x: (x[0] / 2, x[1]))
            .partitionBy(rdd.getNumPartitions() / 2))

    return rdd.values().reduce(f)

对于Python 3.0+，请确保将

/

替换为

/

使用这样的东西作为模型应该可以做到：

from math import log

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0
    def mapPartition(i, iter):
        i = i / 2
        for x in iter:
            yield i, x

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .mapPartitionsWithIndex(mapPartition)
            .reduceByKey(f, rdd.getNumPartitions() / 2)
            .values())

    return rdd.first()

如果您更喜欢更明确的方法，则始终保留分区号：

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0

    def initPartition(i, iter):
        for x in iter:
            yield i, x

    rdd = rdd.mapPartitionsWithIndex(initPartition)

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .reduceByKey(f)
            .map(lambda x: (x[0] / 2, x[1]))
            .partitionBy(rdd.getNumPartitions() / 2))

    return rdd.values().reduce(f)

对于Python 3.0+，请确保将

/

替换为

/

使用这样的东西作为模型应该可以做到：

from math import log

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0
    def mapPartition(i, iter):
        i = i / 2
        for x in iter:
            yield i, x

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .mapPartitionsWithIndex(mapPartition)
            .reduceByKey(f, rdd.getNumPartitions() / 2)
            .values())

    return rdd.first()

如果您更喜欢更明确的方法，则始终保留分区号：

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0

    def initPartition(i, iter):
        for x in iter:
            yield i, x

    rdd = rdd.mapPartitionsWithIndex(initPartition)

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .reduceByKey(f)
            .map(lambda x: (x[0] / 2, x[1]))
            .partitionBy(rdd.getNumPartitions() / 2))

    return rdd.values().reduce(f)

对于Python 3.0+，请确保将

/

替换为

/

使用这样的东西作为模型应该可以做到：

from math import log

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0
    def mapPartition(i, iter):
        i = i / 2
        for x in iter:
            yield i, x

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .mapPartitionsWithIndex(mapPartition)
            .reduceByKey(f, rdd.getNumPartitions() / 2)
            .values())

    return rdd.first()

如果您更喜欢更明确的方法，则始终保留分区号：

def binaryReduce(rdd, f):
    assert log(rdd.getNumPartitions(), 2) % 1 == 0

    def initPartition(i, iter):
        for x in iter:
            yield i, x

    rdd = rdd.mapPartitionsWithIndex(initPartition)

    while rdd.getNumPartitions() != 1:
        rdd = (rdd
            .reduceByKey(f)
            .map(lambda x: (x[0] / 2, x[1]))
            .partitionBy(rdd.getNumPartitions() / 2))

    return rdd.values().reduce(f)

---

---

对于Python 3.0+，请确保将

/

替换为

/

如果你投反对票，知道为什么很好。如果你投反对票，知道为什么很好。如果你投反对票，知道为什么很好。如果你投反对票，知道为什么很好。很好的建议，但是我如何给分区编号？我想要分区1，2，3。。。我怎样才能做到这一点？我的意思是：我需要以一种有助于reduceByKey的方式给出键，我如何才能得到它？你只需要确保要连接在一起的分区的值具有相同的键。我希望前两个分区具有键1，下两个分区具有键2，依此类推。我怎么知道给每个分区分配什么键呢？它非常接近解决方案，我正在寻找一个AppPartitionSwithindex（func），func的类型必须是（Int，Iterator）=>Iterator。是否使用int/2作为键？因为int是分区号，所以分区号1和2的键为1，3和4的键为2，依此类推。在我将reduceByKey之后，每个键都将被分配到它的分区？我的意思是，我不能让key=4在两个不同的分区之间分割？很好的建议，但是我如何给分区编号？我想要分区1，2，3。。。我怎样才能做到这一点？我的意思是：我需要以一种有助于reduceByKey的方式给出键，我如何才能得到它？你只需要确保要连接在一起的分区的值具有相同的键。我希望前两个分区具有键1，下两个分区具有键2，依此类推。我怎么知道给每个分区分配什么键呢？它非常接近解决方案，我正在寻找一个AppPartitionSwithindex（func），func的类型必须是（Int，Iterator）=>Iterator。是否使用int/2作为键？因为int是分区号，所以分区号1和2的键为1，3和4的键为2，依此类推。在我将reduceByKey之后，每个键都将被分配到它的分区？我的意思是，我不能让key=4在两个不同的分区之间分割？很好的建议，但是我如何给分区编号？我想要分区1，2，3。。。我怎样才能做到这一点？我的意思是：我需要以一种有助于reduceByKey的方式给出键，我如何才能得到它？你只需要确保要连接在一起的分区的值具有相同的键。我希望前两个分区具有键1，下两个分区具有键2，依此类推。我怎么知道给每个分区分配什么键呢？它非常接近解决方案，我正在寻找一个AppPartitionSwithindex（func），func的类型必须是（Int，Iterator）=>Iterator。是否使用int/2作为键？因为int是分区号，所以分区号1和2的键为1，3和4的键为2，依此类推。在我将reduceByKey之后，每个键都将被分配到它的分区？我的意思是，我不能让key=4在两个不同的分区之间分割？很好的建议，但是我如何给分区编号？我想要分区1，2，3。。。我怎样才能做到这一点？我的意思是：我需要以一种有助于reduceByKey的方式给出键，我如何才能得到它？你只需要确保你想要连接在一起的分区中的值具有相同的键