Wie kann ich eine Liste nachbestellen? [geschlossen]

Wenn ich eine Liste habe, [a,b,c,d,e]wie kann ich die Artikel auf beliebige Weise neu anordnen [d,c,a,b,e]?

Edit: Ich möchte sie nicht mischen. Ich möchte sie in einer vordefinierten Weise nachbestellen. (Ich weiß zum Beispiel, dass das dritte Element in der alten Liste das erste Element in der neuen Liste werden sollte.)

Sie können es so machen

mylist = ['a', 'b', 'c', 'd', 'e']
myorder = [3, 2, 0, 1, 4]
mylist = [mylist[i] for i in myorder]
print(mylist)         # prints: ['d', 'c', 'a', 'b', 'e']

>>> a = [1, 2, 3]
>>> a[0], a[2] = a[2], a[0]
>>> a
[3, 2, 1]

>>> import random
>>> x = [1,2,3,4,5]
>>> random.shuffle(x)
>>> x
[5, 2, 4, 3, 1]

Wird die endgültige Reihenfolge durch eine Liste von Indizes definiert?

>>> items = [1, None, "chicken", int]
>>> order = [3, 0, 1, 2]

>>> ordered_list = [items[i] for i in order]
>>> ordered_list
[<type 'int'>, 1, None, 'chicken']

bearbeiten: meh. AJ war schneller ... Wie kann ich eine Liste in Python neu anordnen?

>>> a=["a","b","c","d","e"]
>>> a[0],a[3] = a[3],a[0]
>>> a
['d', 'b', 'c', 'a', 'e']

Sie können Ihre eigene Sortierfunktion bereitstellen, um list.sort():

Die sort () -Methode verwendet optionale Argumente zur Steuerung der Vergleiche.

• cmp gibt eine benutzerdefinierte Vergleichsfunktion von zwei Argumenten (Listenelementen) an, die eine negative, null oder positive Zahl zurückgeben soll, je nachdem, ob das erste Argument als kleiner, gleich oder größer als das zweite Argument angesehen wird : cmp=lambda x,y: cmp(x.lower(), y.lower()). Der Standardwert ist None.

• Schlüssel gibt eine Funktion eines Arguments an, mit der ein Vergleichsschlüssel aus jedem Listenelement extrahiert wird : key=str.lower. Der Standardwert ist None.

• reverse ist ein boolescher Wert. Wenn True festgelegt ist, werden die Listenelemente so sortiert, als ob jeder Vergleich umgekehrt wäre.

Im Allgemeinen sind die Schlüssel- und Rückwärtskonvertierungsprozesse viel schneller als die Angabe einer äquivalenten cmp-Funktion. Dies liegt daran, dass cmp für jedes Listenelement mehrmals aufgerufen wird, während Taste und Rückwärts jedes Element nur einmal berühren.

Wenn Sie Numpy verwenden, gibt es eine gute Möglichkeit, dies zu tun:

items = np.array(["a","b","c","d"])
indices = np.arange(items.shape[0])
np.random.shuffle(indices)
print(indices)
print(items[indices])

Dieser Code gibt Folgendes zurück:

[1 3 2 0]
['b' 'd' 'c' 'a']

Wenn Ihnen die Effizienz nicht so wichtig ist, können Sie sich auf die Array-Indizierung von numpy verlassen, um sie elegant zu gestalten:

a = ['123', 'abc', 456]
order = [2, 0, 1]
a2 = list( np.array(a, dtype=object)[order] )

Nach meinem Verständnis Ihrer Frage möchten Sie anscheinend eine Permutation anwenden, die Sie auf a angeben list. Dies erfolgt durch Angabe eines anderen list(nennen wir es p), der die Indizes der Elemente des Originals enthält list, die im permutierten erscheinen sollen list. Anschließend perstellen Sie ein neues listElement, indem Sie einfach das Element an jeder Position durch das Element ersetzen, dessen Index sich an dieser Position in befindet p.

def apply_permutation(lst, p):
    return [lst[x] for x in p]

arr=list("abcde")
new_order=[3,2,0,1,4]

print apply_permutation(arr,new_order)

Dies wird gedruckt ['d', 'c', 'a', 'b', 'e'].

Dies schafft tatsächlich ein neues list, kann aber trivial modifiziert werden, um das Original "an Ort und Stelle" zu permutieren.

Eine weitere Sache, die berücksichtigt werden kann, ist die andere Interpretation, auf die Darkless hinweist

Code in Python 2.7

Hauptsächlich:

1. Nach Wert neu ordnen - Bereits von AJ oben gelöst

2. Nach Index neu ordnen

   mylist = ['a', 'b', 'c', 'd', 'e']
   myorder = [3, 2, 0, 1, 4]
   
   mylist = sorted(zip(mylist, myorder), key=lambda x: x[1])
   print [item[0] for item in mylist]

Dies druckt ['c', 'd', 'b', 'a', 'e']

newList = [oldList[3]]
newList.extend(oldList[:3])
newList.extend(oldList[4:])

Dies habe ich verwendet, als ich auf dieses Problem gestoßen bin.

def order(list_item, i): # reorder at index i
    order_at = list_item.index(i)
    ordered_list = list_item[order_at:] + list_item[:order_at]
    return ordered_list

EX: für die Kleinbuchstaben

order(string.ascii_lowercase, 'h'):
>>> 'hijklmnopqrstuvwxyzabcdefg'

Die Liste wird einfach auf einen bestimmten Index verschoben