Lecture aléatoire d'une liste d'objets

J'ai une liste d'objets et je veux les mélanger. Je pensais pouvoir utiliser la random.shuffleméthode, mais cela semble échouer lorsque la liste est constituée d'objets. Existe-t-il une méthode pour mélanger les objets ou une autre solution?

import random

class A:
    foo = "bar"

a1 = a()
a2 = a()
b = [a1, a2]

print(random.shuffle(b))

Cela échouera.

random.shuffledevrait marcher. Voici un exemple, où les objets sont des listes:

from random import shuffle
x = [[i] for i in range(10)]
shuffle(x)

# print(x)  gives  [[9], [2], [7], [0], [4], [5], [3], [1], [8], [6]]
# of course your results will vary

Notez que la lecture aléatoire fonctionne en place et renvoie Aucun.

Comme vous l'avez appris, le brassage sur place était le problème. J'ai aussi souvent des problèmes et j'ai souvent l'impression d'oublier comment copier une liste. Utiliser sample(a, len(a))est la solution, utiliser len(a)comme taille d'échantillon. Voir https://docs.python.org/3.6/library/random.html#random.sample pour la documentation Python.

Voici une version simple utilisant random.sample()qui renvoie le résultat mélangé dans une nouvelle liste.

import random

a = range(5)
b = random.sample(a, len(a))
print a, b, "two list same:", a == b
# print: [0, 1, 2, 3, 4] [2, 1, 3, 4, 0] two list same: False

# The function sample allows no duplicates.
# Result can be smaller but not larger than the input.
a = range(555)
b = random.sample(a, len(a))
print "no duplicates:", a == list(set(b))

try:
    random.sample(a, len(a) + 1)
except ValueError as e:
    print "Nope!", e

# print: no duplicates: True
# print: Nope! sample larger than population

Il m'a fallu un certain temps pour l'obtenir aussi. Mais la documentation de shuffle est très claire:

mélanger la liste x en place ; aucun retour.

Vous ne devriez donc pas print(random.shuffle(b)). Faites plutôt random.shuffle(b)et ensuite print(b).

#!/usr/bin/python3

import random

s=list(range(5))
random.shuffle(s) # << shuffle before print or assignment
print(s)

# print: [2, 4, 1, 3, 0]

Si vous utilisez déjà numpy (très populaire pour les applications scientifiques et financières), vous pouvez vous enregistrer une importation.

import numpy as np    
np.random.shuffle(b)
print(b)

http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.shuffle.html

>>> import random
>>> a = ['hi','world','cat','dog']
>>> random.shuffle(a,random.random)
>>> a
['hi', 'cat', 'dog', 'world']

Ça fonctionne bien pour moi. Assurez-vous de définir la méthode aléatoire.

Si vous avez plusieurs listes, vous souhaiterez peut-être d'abord définir la permutation (la façon dont vous mélangez la liste / réorganisez les éléments de la liste), puis l'appliquez à toutes les listes:

import random

perm = list(range(len(list_one)))
random.shuffle(perm)
list_one = [list_one[index] for index in perm]
list_two = [list_two[index] for index in perm]

Numpy / Scipy

Si vos listes sont des tableaux numpy, c'est plus simple:

import numpy as np

perm = np.random.permutation(len(list_one))
list_one = list_one[perm]
list_two = list_two[perm]

mpu

J'ai créé le petit paquet utilitaire mpuqui a la consistent_shufflefonction:

import mpu

# Necessary if you want consistent results
import random
random.seed(8)

# Define example lists
list_one = [1,2,3]
list_two = ['a', 'b', 'c']

# Call the function
list_one, list_two = mpu.consistent_shuffle(list_one, list_two)

Notez que cela mpu.consistent_shuffleprend un nombre arbitraire d'arguments. Vous pouvez donc également mélanger trois listes ou plus avec.

from random import random
my_list = range(10)
shuffled_list = sorted(my_list, key=lambda x: random())

Cette alternative peut être utile pour certaines applications où vous souhaitez échanger la fonction de commande.

Dans certains cas, lors de l'utilisation de tableaux numpy, à l'aide de random.shuffledonnées en double créées dans le tableau.

Une alternative est d'utiliser numpy.random.shuffle. Si vous travaillez déjà avec numpy, c'est la méthode préférée par rapport au générique random.shuffle.

numpy.random.shuffle

Exemple

>>> import numpy as np
>>> import random

En utilisant random.shuffle:

>>> foo = np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> foo

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])


>>> random.shuffle(foo)
>>> foo

array([[1, 2, 3],
       [1, 2, 3],
       [4, 5, 6]])

En utilisant numpy.random.shuffle:

>>> foo = np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> foo

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])


>>> np.random.shuffle(foo)
>>> foo

array([[1, 2, 3],
       [7, 8, 9],
       [4, 5, 6]])

Pour les monolignes, utilisez random.sample(list_to_be_shuffled, length_of_the_list)avec un exemple:

import random
random.sample(list(range(10)), 10)

sorties: [2, 9, 7, 8, 3, 0, 4, 1, 6, 5]

'print func (foo)' affichera la valeur de retour de 'func' lorsqu'il est appelé avec 'foo'. 'shuffle' a cependant None comme type de retour, car la liste sera modifiée sur place, donc elle n'imprime rien. Solution de contournement:

# shuffle the list in place 
random.shuffle(b)

# print it
print(b)

Si vous êtes plus dans le style de programmation fonctionnel, vous voudrez peut-être faire la fonction wrapper suivante:

def myshuffle(ls):
    random.shuffle(ls)
    return ls

On peut définir une fonction appelée shuffled(dans le même sens de sortvs sorted)

def shuffled(x):
    import random
    y = x[:]
    random.shuffle(y)
    return y

x = shuffled([1, 2, 3, 4])
print x

import random

class a:
    foo = "bar"

a1 = a()
a2 = a()
a3 = a()
a4 = a()
b = [a1,a2,a3,a4]

random.shuffle(b)
print(b)

shuffle est en place, donc n'imprimez pas le résultat, ce qui est le cas None, mais la liste.

Vous pouvez y aller:

>>> A = ['r','a','n','d','o','m']
>>> B = [1,2,3,4,5,6]
>>> import random
>>> random.sample(A+B, len(A+B))
[3, 'r', 4, 'n', 6, 5, 'm', 2, 1, 'a', 'o', 'd']

si vous souhaitez revenir à deux listes, vous divisez ensuite cette longue liste en deux.

vous pouvez créer une fonction qui prend une liste en paramètre et renvoie une version mélangée de la liste:

from random import *

def listshuffler(inputlist):
    for i in range(len(inputlist)):
        swap = randint(0,len(inputlist)-1)
        temp = inputlist[swap]
        inputlist[swap] = inputlist[i]
        inputlist[i] = temp
    return inputlist

""" to shuffle random, set random= True """

def shuffle(x,random=False):
     shuffled = []
     ma = x
     if random == True:
         rando = [ma[i] for i in np.random.randint(0,len(ma),len(ma))]
         return rando
     if random == False:
          for i in range(len(ma)):
          ave = len(ma)//3
          if i < ave:
             shuffled.append(ma[i+ave])
          else:
             shuffled.append(ma[i-ave])    
     return shuffled

vous pouvez soit utiliser shuffle ou sample. les deux proviennent d'un module aléatoire.

import random
def shuffle(arr1):
    n=len(arr1)
    b=random.sample(arr1,n)
    return b

OU

import random
def shuffle(arr1):
    random.shuffle(arr1)
    return arr1

Assurez-vous que vous ne nommez pas votre fichier source random.py et qu'il n'y a pas de fichier dans votre répertoire de travail appelé random.pyc. .

def shuffle(_list):
    if not _list == []:
        import random
        list2 = []
        while _list != []:
            card = random.choice(_list)
            _list.remove(card)
            list2.append(card)
        while list2 != []:
            card1 = list2[0]
            list2.remove(card1)
            _list.append(card1)
        return _list

import random
class a:
    foo = "bar"

a1 = a()
a2 = a()
b = [a1.foo,a2.foo]
random.shuffle(b)

Le processus de mélange est "avec remplacement" , donc l'occurrence de chaque élément peut changer! Au moins lorsque les éléments de votre liste sont également listés.

Par exemple,

ml = [[0], [1]] * 10

Après,

random.shuffle(ml)

Le nombre de [0] peut être 9 ou 8, mais pas exactement 10.

Plan: Écrivez le mélange sans compter sur une bibliothèque pour faire le gros du travail. Exemple: Parcourez la liste depuis le début en commençant par l'élément 0; trouver une nouvelle position aléatoire pour lui, disons 6, mettre la valeur 0 dans 6 et la valeur 6 dans 0. Passez à l'élément 1 et répétez ce processus, et ainsi de suite dans le reste de la liste

import random
iteration = random.randint(2, 100)
temp_var = 0
while iteration > 0:

    for i in range(1, len(my_list)): # have to use range with len()
        for j in range(1, len(my_list) - i):
            # Using temp_var as my place holder so I don't lose values
            temp_var = my_list[i]
            my_list[i] = my_list[j]
            my_list[j] = temp_var

        iteration -= 1

Ça fonctionne bien. Je l'essaye ici avec des fonctions comme objets de liste:

    from random import shuffle

    def foo1():
        print "foo1",

    def foo2():
        print "foo2",

    def foo3():
        print "foo3",

    A=[foo1,foo2,foo3]

    for x in A:
        x()

    print "\r"

    shuffle(A)
    for y in A:
        y()

Il affiche: foo1 foo2 foo3 foo2 foo3 foo1 (les foos de la dernière ligne ont un ordre aléatoire)