Quelle est la façon la plus simple de mélanger un tableau avec python?
new_array = random.sample( array, len(array) )
.
Quelle est la façon la plus simple de mélanger un tableau avec python?
new_array = random.sample( array, len(array) )
.
Réponses:
import random
random.shuffle(array)
import random
random.shuffle(array)
Autre moyen de le faire en utilisant sklearn
from sklearn.utils import shuffle
X=[1,2,3]
y = ['one', 'two', 'three']
X, y = shuffle(X, y, random_state=0)
print(X)
print(y)
Production:
[2, 1, 3]
['two', 'one', 'three']
Avantage: vous pouvez randomiser plusieurs tableaux simultanément sans perturber le mappage. Et 'random_state' peut contrôler le brassage pour un comportement reproductible.
Les autres réponses sont les plus simples, mais il est un peu ennuyeux que la random.shuffle
méthode ne retourne rien - elle trie simplement la liste donnée. Si vous souhaitez chaîner des appels ou simplement être en mesure de déclarer un tableau mélangé sur une seule ligne, vous pouvez le faire:
import random
def my_shuffle(array):
random.shuffle(array)
return array
Ensuite, vous pouvez faire des lignes comme:
for suit in my_shuffle(['hearts', 'spades', 'clubs', 'diamonds']):
Lorsque vous traitez avec des listes Python régulières, random.shuffle()
fera le travail comme le montrent les réponses précédentes.
Mais quand il s'agit de ndarray
( numpy.array
), random.shuffle
semble casser l'original ndarray
. Voici un exemple:
import random
import numpy as np
import numpy.random
a = np.array([1,2,3,4,5,6])
a.shape = (3,2)
print a
random.shuffle(a) # a will definitely be destroyed
print a
Utilisez simplement: np.random.shuffle(a)
Comme random.shuffle
, np.random.shuffle
mélange le tableau en place.
Au cas où vous voudriez un nouveau tableau, vous pouvez utiliser sample
:
import random
new_array = random.sample( array, len(array) )
Vous pouvez trier votre tableau avec une clé aléatoire
sorted(array, key = lambda x: random.random())
la clé ne doit être lue qu'une seule fois, donc la comparaison de l'élément pendant le tri est toujours efficace.
mais ressembler random.shuffle(array)
sera plus rapide car il est écrit en C
array
je voulais dire l' Random
élément: c'est-à-dire que dans lambda
le random.random()
pourrait générer une nouvelle Random
instance de classe à chaque fois. Je ne suis pas vraiment sûr: java
ce serait la mauvaise façon de le faire: vous devez créer un Random rng = Random()
, puis invoquer le rng.nextGaussian()
. Mais random.random()
Je ne sais pas si je l'ai utilisé, random.shuffle()
mais cela me renvoie `` Aucun '', alors j'ai écrit ceci, cela pourrait être utile à quelqu'un
def shuffle(arr):
for n in range(len(arr) - 1):
rnd = random.randint(0, (len(arr) - 1))
val1 = arr[rnd]
val2 = arr[rnd - 1]
arr[rnd - 1] = val1
arr[rnd] = val2
return arr
Sachez que cela random.shuffle()
ne doit pas être utilisé sur des tableaux multidimensionnels car cela provoque des répétitions.
Imaginez que vous vouliez mélanger un tableau le long de sa première dimension, nous pouvons créer l'exemple de test suivant,
import numpy as np
x = np.zeros((10, 2, 3))
for i in range(10):
x[i, ...] = i*np.ones((2,3))
de sorte que le long du premier axe, le i-ème élément correspond à une matrice 2x3 où tous les éléments sont égaux à i.
Si nous utilisons la fonction de lecture aléatoire correcte pour les tableaux multidimensionnels, c'est np.random.shuffle(x)
-à- dire que le tableau sera mélangé le long du premier axe comme souhaité. Cependant, l'utilisation random.shuffle(x)
entraînera des répétitions. Vous pouvez vérifier cela en exécutant len(np.unique(x))
après la lecture aléatoire, ce qui vous donne 10 (comme prévu) avec np.random.shuffle()
mais seulement environ 5 lors de l'utilisation random.shuffle()
.