Mescolando un elenco di oggetti

Ho un elenco di oggetti e voglio mescolarli. Pensavo di poter usare il random.shufflemetodo, ma questo sembra fallire quando l'elenco è di oggetti. C'è un metodo per mescolare oggetti o un altro modo per aggirare questo?

import random

class A:
    foo = "bar"

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

print(random.shuffle(b))

Questo fallirà.

random.shuffledovrebbe funzionare. Ecco un esempio, in cui gli oggetti sono elenchi:

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

Nota che shuffle funziona sul posto e restituisce None.

Come hai appreso, il problema era il mescolamento sul posto. Anch'io ho problemi di frequente e spesso sembra dimenticare anche come copiare un elenco. L'utilizzo sample(a, len(a))è la soluzione, utilizzando len(a)come dimensione del campione. Vedi https://docs.python.org/3.6/library/random.html#random.sample per la documentazione di Python.

Ecco una versione semplice usando random.sample() che che restituisce il risultato mischiato come un nuovo elenco.

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

Mi ci è voluto del tempo anche per ottenerlo. Ma la documentazione per la riproduzione casuale è molto chiara:

shuffle list x in posizione ; restituisce Nessuno.

Quindi non dovresti print(random.shuffle(b)). Invece fai random.shuffle(b)e poi 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]

Se ti capita di usare già intorpidimento (molto popolare per applicazioni scientifiche e finanziarie) puoi risparmiarti un'importazione.

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

Funziona bene per me. Assicurati di impostare il metodo casuale.

Se hai più elenchi, potresti voler definire la permutazione (il modo in cui mescoli l'elenco / riordini gli elementi nell'elenco) e poi applicalo a tutti gli elenchi:

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

Se i tuoi elenchi sono array intorpiditi, è più semplice:

import numpy as np

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

MPU

Ho creato il piccolo pacchetto di utilità mpuche ha la consistent_shufflefunzione:

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)

Si noti che mpu.consistent_shuffleaccetta un numero arbitrario di argomenti. Quindi puoi anche mescolare tre o più elenchi con esso.

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

Questa alternativa può essere utile per alcune applicazioni in cui si desidera scambiare la funzione di ordinazione.

In alcuni casi quando si utilizzano array intorpiditi, utilizzare random.shuffle i dati duplicati creati nell'array.

Un'alternativa è usare numpy.random.shuffle. Se stai già lavorando con numpy, questo è il metodo preferito rispetto al generico random.shuffle.

numpy.random.shuffle

Esempio

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

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

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

Per una linea, utilizzare random.sample(list_to_be_shuffled, length_of_the_list)con un esempio:

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

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

'print func (foo)' stamperà il valore di ritorno di 'func' quando viene chiamato con 'foo'. 'shuffle' ha comunque None come tipo di ritorno, poiché l'elenco verrà modificato, quindi non stampa nulla. Soluzione:

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

# print it
print(b)

Se ti piace di più lo stile di programmazione funzionale, potresti voler utilizzare la seguente funzione wrapper:

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

Si può definire una funzione chiamata shuffled(nello stesso senso di 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 è a posto, quindi non stampare il risultato, che è None, ma l'elenco.

Puoi andare per questo:

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

se vuoi tornare a due liste, allora dividi questa lunga lista in due.

è possibile creare una funzione che accetta un elenco come parametro e restituisce una versione casuale dell'elenco:

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

puoi usare shuffle o sample. entrambi provengono da un modulo casuale.

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

Assicurati di non dare un nome al tuo file sorgente random.py e che non ci sia un file nella tua directory di lavoro chiamato random.pyc .. entrambi potrebbero causare al programma di provare a importare il tuo file random.py locale invece del modulo random di Pythons .

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)

Il processo di shuffle è "con sostituzione" , quindi il verificarsi di ogni articolo può cambiare! Almeno quando anche gli elementi nell'elenco sono presenti nell'elenco.

Per esempio,

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

Dopo,

random.shuffle(ml)

Il numero di [0] può essere 9 o 8, ma non esattamente 10.

Piano: Scrivi il riordino senza fare affidamento su una libreria per eseguire il sollevamento pesante. Esempio: scorrere l'elenco dall'inizio iniziando con l'elemento 0; trova una nuova posizione casuale, diciamo 6, metti il ​​valore 0 in 6 e il valore 6 in 0. Passa all'elemento 1 e ripeti questo processo, e così via per il resto dell'elenco

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

Funziona bene Lo sto provando qui con funzioni come oggetti elenco:

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

Stampa: foo1 foo2 foo3 foo2 foo3 foo1 (i foo nell'ultima riga hanno un ordine casuale)