Comment puis-je réorganiser une liste? [fermé]

Si j'ai une liste, [a,b,c,d,e]comment puis-je réorganiser les articles de manière arbitraire comme [d,c,a,b,e]?

Edit: je ne veux pas les mélanger. Je souhaite les réorganiser de manière prédéfinie. (par exemple, je sais que le 3ème élément de l'ancienne liste devrait devenir le premier élément de la nouvelle liste)

Tu peux le faire comme ça

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]

L'ordre final est-il défini par une liste d'indices?

>>> 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']

modifier: meh. AJ était plus rapide ... Comment puis-je réorganiser une liste en python?

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

Vous pouvez fournir votre propre fonction de tri pour list.sort():

La méthode sort () prend des arguments optionnels pour contrôler les comparaisons.

• cmp spécifie une fonction de comparaison personnalisée de deux arguments (éléments de la liste) qui doit retourner un négatif, zéro ou nombre positif selon que le premier argument est plus petit que, égal ou supérieur au deuxième argument: cmp=lambda x,y: cmp(x.lower(), y.lower()). La valeur par défaut est None.

• clés spécifie une fonction d'un argument qui est utilisé pour extraire une clé de comparaison de chaque élément de la liste: key=str.lower. La valeur par défaut est None.

• reverse est une valeur booléenne. Si la valeur est True, les éléments de la liste sont triés comme si chaque comparaison était inversée.

En général, les processus de conversion de clé et inverse sont beaucoup plus rapides que la spécification d'une fonction cmp équivalente. C'est parce que cmp est appelé plusieurs fois pour chaque élément de la liste tandis que la touche et la marche arrière ne touchent chaque élément qu'une seule fois.

Si vous utilisez numpy, il existe une manière intéressante de le faire:

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

Ce code renvoie:

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

Si vous ne vous souciez pas tellement de l'efficacité, vous pouvez vous fier à l'indexation des tableaux de numpy pour le rendre élégant:

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

D'après ce que je comprends de votre question, il semble que vous souhaitiez appliquer une permutation que vous spécifiez sur un list. Cela se fait en spécifiant un autre list(appelons-le p) qui contient les indices des éléments de l'original listqui devraient apparaître dans le permuté list. Vous utilisez ensuite ppour en faire un nouveau listen remplaçant simplement l'élément à chaque position par celui dont l'index est à cette position 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)

Cela imprime ['d', 'c', 'a', 'b', 'e'].

Cela crée en fait un nouveau list, mais il peut être modifié de manière triviale pour permuter l'original "en place".

Une autre chose qui peut être considérée est l'autre interprétation comme le souligne

Code en Python 2.7

Principalement:

1. Réorganiser par valeur - Déjà résolu par AJ ci-dessus

2. Réorganiser par index

   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]

Cela affichera ['c', 'd', 'b', 'a', 'e']

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

C'est ce que j'ai utilisé lorsque je suis tombé sur ce problème.

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: pour les lettres minuscules

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

Il déplace simplement la liste vers un index spécifié