Listen in einer bestimmten Reihenfolge zusammenführen

Question

Ich habe eine Liste von Listen, und ich möchte die Listen mit einer bestimmten Reihenfolge zusammenführen. Siehe Beispiel:

id list 0   1   2 
     [[0], [2, 6, 1, 4], [3, 7, 5]] 

    Order   Resulting List 
[1, 0, 2] = [2, 6, 1, 4, 0, 3, 7, 5] 
[0, 2, 1] = [0, 3, 7, 5, 2, 6, 1, 4] 
[2, 1, 0] = [3, 7, 5, 2, 6, 1, 4, 0] 

Jemand kann einen eleganteren Algorithmus vorschlagen, der unten vorgeschlagen wird?

groups = [[0], [2, 6, 1, 4], [3, 7, 5]] 
    orders = [[1, 0, 2], [0, 2, 1], [2, 1, 0]] 

    for order in orders: 
     LC = [] 
     for i in order: 
      LC += groups[i] 
    return LC 

Lassen Sie mich ein bisschen besser erklären, was ich brauche:

groups = [[0], [2, 6, 1, 4], [3, 7, 5]] 
orders = [[0, 2, 1], [1, 0, 2], [2, 1, 0]] # Order of each group in LC 
solutions = [] # I want to put the created LC here 
for order in orders: 
    LC = [] # I need this because a want LCs individualy and not one with all 
    for i in order: # for each order I pick de index (i) of the group 
     LC += grupos[i] # and merge then according with index of group 
     solutions.append([LC]) 
    print(solutions) 

Ich möchte diese (ein LC für jede Bestellung):

[[0, 3, 7, 5, 2, 6, 1, 4], [2, 6, 1, 4, 0, 3, 7, 5], [3, 7, 5, 2, 6, 1, 4, 0]] 

und das nicht:

[0, 3, 7, 5, 2, 6, 1, 4, 2, 6, 1, 4, 0, 3, 7, 5, 3, 7, 5, 2, 6, 1, 4, 0] 

Der obige Algorithmus funktioniert, aber ein Bedarf an einem Andere sind eleganter und effizienter.

Einige Beispiele für Ausgabe:

groups = [[0], [2, 1], [3, 7, 5], [4], [6]] 

Order = [1, 0, 2, 3, 4] 
LC = [2, 1, 0, 3, 7, 5, 4, 6] 

    [2, 1, 0, 3, 4] 
    [3, 7, 5, 2, 1, 0, 4, 6] 

    [3, 1, 2, 0, 4] 
    [4, 2, 1, 3, 7, 5, 0, 6] 

    [4, 1, 2, 3, 0] 
    [6, 2, 1, 3, 7, 5, 4, 0] 

    [0, 2, 1, 3, 4] 
    [0, 3, 7, 5, 2, 1, 4, 6] 

    [0, 3, 2, 1, 4] 
    [0, 4, 3, 7, 5, 2, 1, 6] 

    [0, 4, 2, 3, 1] 
    [0, 6, 3, 7, 5, 4, 2, 1] 

    [0, 1, 3, 2, 4] 
    [0, 2, 1, 4, 3, 7, 5, 6] 

    [0, 1, 4, 3, 2] 
    [0, 2, 1, 6, 4, 3, 7, 5] 

    [0, 1, 2, 4, 3] 
    [0, 2, 1, 3, 7, 5, 6, 4] 

Answer 1

Diese Lösung ist im Grunde identisch mit dem Sie vorgeschlagen, aber mehr Python-artiger, eine Liste Verständnis mit.

>>> def merge_lists(desired_order): 
...  merged_list = [element for i in desired_order for element in parts[i]] 
...  return merged_list 
... 
>>> desired_order = orders[0] 
>>> merge_lists(desired_order) 
[2, 6, 1, 4, 0, 3, 7, 5] 

Answer 2

Sie könnten eine andere Technik wie ein Verständnis verwenden. Im Folgenden wird eine flache Liste zurück:

return [part for order in orders for i in order for part in parts[i]] 

und die folgenden wird eine 2D-Liste zurück:

return [[part for i in order for part in parts[i]] for order in orders] 

Answer 3

Rufen Sie einfach auf die Indizes itertools.chain und verbinden sich mit mit operator.itemgetter:

frIn [9]: groups = [[0], [2, 6, 1, 4], [3, 7, 5]] 

In [10]: orders = [[0, 2, 1], [1, 0, 2], [2, 1, 0]] # Ord 

In [11]: from itertools import chain 

In [12]: from operator import itemgetter 


In [13]: [list(chain(*itemgetter(*o)(groups))) for o in orders] 
    [[0, 3, 7, 5, 2, 6, 1, 4], [2, 6, 1, 4, 0, 3, 7, 5], [3, 7, 5, 2, 6, 1, 4, 0]] 

In Ihrem Code besitzen, geben Sie nur die letzte LC, so dass es nicht korrekt funktionieren könnte:

for order in orders: 
    LC = [] # overwritten each iteration so you only get the last sublists. 
    for i in order: 
     LC += parts[i] 
return LC 

Answer 4

inputs = [[1,2,3], [4,5,6], [7]] 
orders = [[0,1,2], [2,1,0]] 

result = [input_element for order in orders for order_element in order for input_element in inputs[order_element]] 
print(result)