Java, Python - 如何将Java FlatMap转换为Python LinkedList

Question

我正在通过线性规划制定运输问题。我主要是在网上搜索它并找到了 code which is written in Java。但是，我必须在 Python 中写完整的东西。我正在将其转换为 Python。我不声称自己擅长 Java 不擅长 Python。我试着转换了一下。一切都很好，但我不知道如何转换下面的代码片段，它处理 Java.

的 LinkedLists 和 Stream 函数

static LinkedList<Shipment> matrixToList() {
    return stream(matrix)
            .flatMap(row -> stream(row))
            .filter(s -> s != null)
            .collect(toCollection(LinkedList::new));
}

如果您有兴趣查看我如何转换上面链接的 Java 代码，您可以在这里看到 Shipment class 下面是我的（不完整）Python代码：

import sys

class TransportationProblem:

    demand = list()
    supply = list()
    costs = list(list())
    matrix = list(list())

    def __init__(self):
        pass

    class Shipment:
        costPerUnit = 0.0
        quantity = 0.0
        r = 0
        c = 0

        def __init__(self, quantity, costPerUnit, r, c):
            self.quantity = quantity
            self.costPerUnit = costPerUnit
            self.r = r
            self.c = c

    def init(self, f_name= ""):
        try:
            with open(f_name) as f:
                val = [int(x) for x in f.readline().strip().split(' ')]
                numSources, numDestinations = val[0], val[1]
                src = list()
                dst = list()

                val = [int(x) for x in f.readline().strip().split(' ')]
                for i in range(0,numSources):
                    src.append(val[i])

                val = [int(x) for x in f.readline().strip().split(' ')]
                for i in range(0, numDestinations):
                    dst.append(val[i])

                totalSrc = sum(src)
                totalDst = sum(dst)

                if totalSrc > totalDst:
                    dst.append(totalSrc - totalDst)
                elif totalDst > totalSrc:
                    src.append(totalDst - totalSrc)

                self.supply = src
                self.demand = dst

                self.costs = [[0 for j in range(len(dst))] for i in range(len(src))]
                self.matrix = [[self.Shipment() for j in range(len(dst))] for i in range(len(src))]

                for i in range(0,len(src)):
                    val = [int(x) for x in f.readline().strip().split(' ')]
                    for j in range(0, len(dst)):
                        self.costs[i][j] = val[j]

                print self.costs
        except IOError:
            print "Error: can\'t find file or read data"

    def northWestCornerRule(self):
        northwest = 0
        for r in range(0, len(self.supply)):
            for c in range(northwest, len(self.demand)):
                quantity = min(self.supply[r], self.demand[c])
                if quantity > 0:
                    self.matrix[r][c] = self.Shipment(quantity=quantity, costPerUnit=self.costs[r][c], r=r, c=c)
                    self.supply[r] = self.supply[r] - quantity
                    self.demand[c] = self.demand[c] - quantity
                    if self.supply[r] == 0:
                        northwest = c
                        break

    def steppingStone(self):
        maxReduction = 0
        move = []
        leaving = self.Shipment()

        self.fixDegenerateCase()
        for r in range(0,len(self.supply)):
            for c in range(0,len(self.demand)):
                if self.matrix[r][c] != None:
                    pass

                trail = self.Shipment(quantity=0, costPerUnit=self.costs[r][c], r=r, c=c)
                path = self.geClosedPath(trail)

                reduction = 0
                lowestQuantity = sys.maxint
                leavingCandidate = None

                plus = True
                for s in path:
                    if plus == True:
                        reduction = reduction + s.costPerUnit
                    else:
                        reduction = reduction - s.costPerUnit
                        if s.quantity < lowestQuantity:
                            leavingCandidate = s
                            lowestQuantity = s.quantity
                    plus = not plus
                if reduction < maxReduction:
                    move = path
                    leaving = leavingCandidate
                    maxReduction = reduction

        if move != None:
            q = leaving.quantity
            plus = True
            for s in move:
                s.quantity = s.quantity + q if plus else s.quantity - q
                self.matrix[s.r][s.c] = None if s.quantity == 0 else s
                plus = not plus
            self.steppingStone()

    def fixDegenerateCase(self):
        pass

    def getClosedPath(self):
        pass

    def matrixToList(self):
        pass

Answer 1

我们可以将其分解为多个步骤。您从一个 matrix 变量开始，它是一些包含 Shipment.

类型的可迭代对象的可迭代对象

流式传输对象意味着您对流的每个元素执行操作。

流上的 map 意味着您获取每个对象，比如 A 类型，并将其转换为某种类型 B。 flatMap 是一种特殊情况，当 map 会产生 Stream<B> 时使用。 flatMap 让您可以将这些流连接成一个流。

假设每个 A 映射到 3 个对象的流 {A1, A2} -> {{B11, B12, B13}, {B21, B22, B23}}

flatMap 将成为这一流 {A1, A2} -> {B11, B12, B13, B21, B22, B23}

在这种情况下，matrix 会生成一个 row 对象流。每个 row 被映射到 Shipment 的流中， flatMap 用于连接它们。

最后使用filter去除空运（即值为null），调用collect方法将Shipment的流转为List .

在没有流的情况下重新创建它可能如下所示：

static LinkedList<Shipment> matrixToList() {
    LinkedList<Shipment> result = new LinkedList<>();
    for (List<Shipment> row : matrix) {
        for (Shipment shipment : row) {
            if (shipment != null) {
                result.add(shipment );
            }
        }
    }
    return result;
}

Java, Python - 如何将Java FlatMap转换为Python LinkedList

Java, Python - How to convert Java FlatMap into Python LinkedList

java

linked-list

code-conversion

python-2.7

flatmap