Nesnelerin bir listesini karıştırma

Bir nesneler listem var ve onları karıştırmak istiyorum. Ben random.shuffleyöntemi kullanabileceğini düşündüm , ama liste nesneler olduğunda bu başarısız gibi görünüyor. Nesneleri karıştırmak için bir yöntem var mı veya bunun başka bir yolu var mı?

import random

class A:
    foo = "bar"

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

print(random.shuffle(b))

Bu başarısız olur.

random.shuffleçalışmalı. İşte nesnelerin listelendiği bir örnek:

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

Karıştırmanın yerinde çalıştığını ve Yok değerini döndürdüğünü unutmayın.

Bildiğiniz gibi yerinde karıştırma sorun oldu. Ayrıca sık sık sorun yaşıyorum ve çoğu zaman bir listeyi nasıl kopyalayacağımı da unutuyor gibi görünüyor. Kullanma sample(a, len(a))kullanılarak çözüm len(a)numune büyüklüğü. Python belgeleri için https://docs.python.org/3.6/library/random.html#random.sample sayfasına bakın .

İşte random.sample()karıştırılmış sonucu yeni bir liste olarak döndüren basit bir sürüm .

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

Bunu da almam biraz zaman aldı. Ancak shuffle için belgeler çok açık:

Liste x karıştırmak yerine ; dönüş Yok.

Yani yapmamalısın print(random.shuffle(b)). Bunun yerine yap random.shuffle(b)ve sonra 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]

Zaten numpy kullanıyorsanız (bilimsel ve finansal uygulamalar için çok popüler) kendinize bir ithalat kaydedebilirsiniz.

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

Benim için iyi çalışıyor. Rastgele yöntemi ayarladığınızdan emin olun.

Birden fazla listeniz varsa, önce permütasyonu (listeyi karıştırma / listedeki öğeleri yeniden düzenleme yönteminiz) tanımlayıp tüm listelere uygulamak isteyebilirsiniz:

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

Listeleriniz numpy dizilerse daha basittir:

import numpy as np

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

mpu

Ben işlevi mpuolan küçük yarar paketi oluşturduk 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)

mpu.consistent_shuffleRastgele sayıda argüman alan unutmayın . Böylece üç veya daha fazla listeyi de karıştırabilirsiniz.

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

Bu alternatif, sipariş işlevini değiştirmek istediğiniz bazı uygulamalar için yararlı olabilir.

Bazı durumlarda numpy dizileri kullanılırken, dizide random.shuffleoluşturulan yinelenen veriler kullanılır .

Bir alternatif kullanmaktır numpy.random.shuffle. Zaten numpy ile çalışıyorsanız, bu genel üzerinde tercih edilen yöntemdir random.shuffle.

numpy.random.shuffle

Misal

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

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

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

Tek gömlekler random.sample(list_to_be_shuffled, length_of_the_list)için bir örnekle kullanın :

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

çıkışlar: [2, 9, 7, 8, 3, 0, 4, 1, 6, 5]

'print func (foo)', 'foo' ile çağrıldığında 'func' dönüş değerini yazdıracaktır. Ancak 'shuffle', dönüş tipi olarak None'a sahiptir, çünkü liste yerinde değiştirileceğinden hiçbir şey yazdırmaz. Çözüm:

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

# print it
print(b)

İşlevsel programlama stiline daha fazla iseniz, aşağıdaki sarmalayıcı işlevini yapmak isteyebilirsiniz:

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

Kişi denilen bir işlevi tanımlayabilir shuffled(aynı anlamda 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 yerinde, bu nedenle sonucu yazdırmayın, yani Noneliste.

Bunun için gidebilirsiniz:

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

iki listeye geri dönmek isterseniz, bu uzun listeyi ikiye böldünüz.

listeyi parametre olarak alan ve listenin karışık sürümünü döndüren bir işlev oluşturabilirsiniz:

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

shuffle veya sample kullanabilirsiniz. ikisi de rastgele bir modülden geliyor.

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

VEYA

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

Kaynak dosyanızı random.py olarak adlandırmadığınızdan ve çalışma dizininizde random.pyc adlı bir dosya bulunmadığından emin olun. .

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)

Karıştırma işlemi "değiştirilerek" yapılır , bu nedenle her öğenin oluşumu değişebilir! En azından listenizdeki öğeler de listelendiğinde.

Örneğin,

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

Sonra,

random.shuffle(ml)

[0] sayısı 9 veya 8 olabilir, ancak tam olarak 10 olamaz.

Plan: Ağır kaldırmayı yapmak için bir kütüphaneye güvenmeden karıştırmayı yazın. Örnek: 0 öğesinden başlayarak listeden baştan başlayın; bunun için yeni bir rastgele konum bulun, örneğin 6, 0'ın değerini 6 ve 6'nın 0 değerine yerleştirin. Eleman 1'e geçin ve bu işlemi tekrarlayın, vb.

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

İyi çalışıyor. Burada liste nesneleri olarak fonksiyonları ile deniyorum:

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

Yazdırır: foo1 foo2 foo3 foo2 foo3 foo1 (son satırdaki foos rastgele bir sıraya sahiptir)