array - shuffle() python




Barajando una lista de objetos (16)

'print func (foo)' imprimirá el valor de retorno de 'func' cuando se llame con 'foo'. Sin embargo, 'shuffle' tiene None como su tipo de retorno, ya que la lista se modificará en su lugar, por lo que no imprime nada. Solución:

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

# print it
print(b)

Si está más interesado en el estilo de programación funcional, es posible que desee realizar la siguiente función de envoltorio:

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

Tengo una lista de objetos en Python y quiero barajarlos. Pensé que podría usar el método random.shuffle , pero esto parece fallar cuando la lista es de objetos. ¿Hay un método para barajar objetos u otra forma de evitar esto?

import random

class a:
    foo = "bar"

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

print random.shuffle(b)

Esto va a fallar.


Asegúrese de que no está asignando un nombre al archivo de origen random.py, y que no hay un archivo en su directorio de trabajo llamado random.pyc. Esto podría hacer que su programa intente importar su archivo random.py local en lugar de un módulo aleatorio de pythons .


En algunos casos, al usar matrices numpy, el uso de random.shuffle creó datos duplicados en la matriz.

Una alternativa es usar numpy.random.shuffle . Si ya está trabajando con numpy, este es el método preferido en lugar de random.shuffle genérico.

numpy.random.shuffle

Ejemplo

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

Usando 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]])

Utilizando 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]])

Funciona bien. Lo estoy probando aquí con funciones como objetos de lista:

    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()

Se imprime: foo1 foo2 foo3 foo2 foo3 foo1 (los foos en la última fila tienen un orden aleatorio)


Para las de una sola línea, use random.sample(list_to_be_shuffled, length_of_the_list) con un ejemplo:

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

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


Plan: escriba el orden aleatorio sin depender de una biblioteca para hacer el trabajo pesado. Ejemplo: recorra la lista desde el principio comenzando con el elemento 0; encuentre una nueva posición aleatoria para él, digamos 6, ponga el valor de 0 en 6 y el valor de 6 en 0. Vaya al elemento 1 y repita este proceso, y así sucesivamente hasta el resto de la lista

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

Puedes usar shuffle o sample. ambos de los cuales provienen de módulo aleatorio.

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

O

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

Si tiene varias listas, es posible que desee definir la permutación (la forma en que baraja la lista / reorganizar los elementos de la lista) primero y luego aplicarla a todas las listas:

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 sus listas son arrays numpy, es más simple:

import numpy as np

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

mpu

He creado el pequeño paquete de utilidades mpu que tiene la función consistent_shuffle :

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)

Tenga en cuenta que mpu.consistent_shuffle toma un número arbitrario de argumentos. Así que también puedes barajar tres o más listas con él.


Uno puede definir una función llamada shuffled (en el mismo sentido de sort frente a sorted )

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

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

podría crear una función que tome una lista como parámetro y devuelva una versión aleatoria de la lista:

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

El proceso de barajado es "con reemplazo" , por lo que la aparición de cada elemento puede cambiar. Al menos cuando los elementos de tu lista también están en la lista.

P.ej,

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

Después,

random.shuffle(ml)

El número de [0] puede ser 9 u 8, pero no exactamente 10.


""" 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

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

Funciona bien para mí. Asegúrese de establecer el método aleatorio.


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()
a3 = a()
a4 = a()
b = [a1,a2,a3,a4]

random.shuffle(b)
print(b)

shuffle está en su lugar, por lo que no imprima el resultado, que es None , pero la lista.


import random
class a:
    foo = "bar"

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




shuffle