洗牌对象列表

random.shuffle应该可以。这是一个示例，其中对象是列表：

from random import shuffle
x = [[i] for i in range(10)]shuffle(x)print(x)
# print(x)  gives  [[9], [2], [7], [0], [4], [5], [3], [1], [8], [6]]

请注意，shuffle工作到位，并返回None。

更一般地说，在Python中，可变对象可以传递给函数，当函数突变这些对象时，标准是返回None（而不是突变对象）。

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

它对我很有效。确保设置随机方法。

#!/usr/bin/python3
import random
s=list(range(5))random.shuffle(s) # << shuffle before print or assignmentprint(s)
# print: [2, 4, 1, 3, 0]

正如您所了解的，就地洗牌是问题所在。我也经常遇到问题，而且似乎经常忘记如何复制列表。使用sample(a, len(a))是解决方案，使用len(a)作为样本大小。有关Python留档，请参阅https://docs.python.org/3.6/library/random.html#random.sample。

这是一个使用random.sample()的简单版本，它将洗牌结果作为新列表返回。

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

'print func（foo）'将在使用'foo'调用时打印'func'的返回值。然而，'Shuffle'的返回类型为无，因为列表将被修改，因此它不打印任何内容。解决方法：

# shuffle the list in placerandom.shuffle(b)
# print itprint(b)

如果您更喜欢函数式编程风格，您可能希望创建以下包装器函数：

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

确保您没有将源文件命名为random.py，并且您的工作目录中没有名为random.pyc.的文件，这可能会导致您的程序尝试导入本地random.py文件而不是pythons随机模块。

你可以这样做：

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

如果你想回到两个列表，你就把这个长列表分成两个。

它工作得很好。我在这里尝试使用函数作为列表对象：

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

输出：fo1 fo2 fo3fo2 fo3 fo1（最后一排的大脚是随机排列的）

random.shuffle的留档声明它将

混洗序列x到位。

不要这样做：

print(random.shuffle(xs))  # WRONG!

相反，做：

random.shuffle(xs)print(xs)

对于numpy（科学和金融应用程序的流行库），请使用np.random.shuffle：

import numpy as npb = np.arange(10)np.random.shuffle(b)print(b)

洗牌过程是“带替换”的，所以每个项目的出现可能会改变！至少当您的列表中的项目也在列表中时。

例如，

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

之后，

random.shuffle(ml)

数字[0]可能是9或8，但不完全是10。

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

此替代方案对于您希望交换排序功能的某些应用程序可能很有用。

可以定义一个名为shuffled的函数（与sort vssorted相同）

def shuffled(x):import randomy = x[:]random.shuffle(y)return y
x = shuffled([1, 2, 3, 4])print x

计划：在不依赖库来完成繁重工作的情况下编写洗牌。示例：从元素0开始浏览列表；为它找到一个新的随机位置，例如6，将0的值放在6中，将6的值放在0中。继续到元素1并重复此过程，依此类推通过列表的其余部分

import randomiteration = random.randint(2, 100)temp_var = 0while 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 valuestemp_var = my_list[i]my_list[i] = my_list[j]my_list[j] = temp_var
iteration -= 1

在某些情况下，当使用numpy数组时，使用random.shuffle在数组中创建重复数据。

另一种选择是使用numpy.random.shuffle。如果您已经在使用numpy，这是优于泛型random.shuffle的首选方法。

numpy.random.shuffle

示例

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

使用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]])

使用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]])

如果您有多个列表，您可能希望首先定义排列（洗牌列表/重新排列列表中项目的方式），然后将其应用于所有列表：

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/西皮

如果您的列表是numpy数组，则更简单：

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

mpu

我创建了具有consistent_shuffle功能的小型实用程序包mpu：

import mpu
# Necessary if you want consistent resultsimport randomrandom.seed(8)
# Define example listslist_one = [1,2,3]list_two = ['a', 'b', 'c']
# Call the functionlist_one, list_two = mpu.consistent_shuffle(list_one, list_two)

请注意，mpu.consistent_shuffle接受任意数量的参数。因此，您还可以使用它洗牌三个或更多列表。

def shuffle(_list):if not _list == []:import randomlist2 = []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

您可以构建一个函数，该函数将列表作为参数并返回列表的洗牌版本：

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] = tempreturn inputlist

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

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已就位，因此不要打印结果，即None，而是列表。

您可以使用Shuffle或Sample。两者都来自随机模块。

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

或

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

import randomclass a:foo = "bar"
a1 = a()a2 = a()b = [a1.foo,a2.foo]random.shuffle(b)

对于单行代码，使用random.sample(list_to_be_shuffled, length_of_the_list)和一个例子：

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

输出：[2,9,7,8,3,0,4,1,6,5]

如果你需要就地洗牌和操纵种子的能力，这个片段会有所帮助：

from random import randint
a = ['hi','world','cat','dog']print(sorted(a, key=lambda _: randint(0, 1)))

请记住，“洗牌”是按随机键排序。

您可以使用random.choices()来洗牌您的列表。

TEAMS = [A,B,C,D,E,F,G,H]random.choices(TEAMS,k = len(TEAMS))

上面的代码将返回一个与您之前的列表相同长度的随机列表。

希望有帮助！！！