现象

我们发现np.random.permutation要比np.random.shuffle快很多

x = np.random.rand(50000, 2)
# 933 µs 
%timeit x.take(np.random.permutation(x.shape[0]), axis=0)
# 1.41 ms
%timeit x[np.random.permutation(x.shape[0])]
# 1.41 ms
%timeit np.random.permutation(x)
# 46.3 ms
%timeit np.random.shuffle(x)

933 µs ± 2.74 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.41 ms ± 5.87 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
1.41 ms ± 4.22 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
46.3 ms ± 413 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

原因

np.random.shuffle 是原地修改数组，因此需要开辟一个buffer作为交换空间buf = np.empty_like(x[0])，而且需要for循环反复交换

# https://github.com/numpy/numpy/blob/18f2385b29bdd62701a1a82d7bf33fd87430a05e/numpy/random/mtrand/mtrand.pyx#L4841
    # Shuffling and permutations:
    def shuffle(self, object x):
        """
        shuffle(x)
        Modify a sequence in-place by shuffling its contents.
        This function only shuffles the array along the first axis of a
        multi-dimensional array. The order of sub-arrays is changed but
        their contents remains the same.
        """
        # ......
        elif isinstance(x, np.ndarray) and x.ndim > 1 and x.size:
            # Multidimensional ndarrays require a bounce buffer.
            buf = np.empty_like(x[0])
            with self.lock:
                for i in reversed(range(1, n)):
                    j = rk_interval(i, self.internal_state)
                    buf[...] = x[j]
                    x[j] = x[i]
                    x[i] = buf

np.random.permutation 是返回一个新数组，因此只用shuffle idx即可，比较快

# https://github.com/numpy/numpy/blob/18f2385b29bdd62701a1a82d7bf33fd87430a05e/numpy/random/mtrand/mtrand.pyx#L4917
    def permutation(self, object x):
        """
        permutation(x)
        Randomly permute a sequence, or return a permuted range.
        If `x` is a multi-dimensional array, it is only shuffled along its
        first index.
        """
        # ......
        # Shuffle index array, dtype to ensure fast path
        idx = np.arange(arr.shape[0], dtype=np.intp)
        self.shuffle(idx)
        return arr[idx]

参考： https://www.cnblogs.com/keye/p/10794322.html

• 对给定的数组进行重新排列的方式主要有两种：

1. np.random.shuffle(x) ：在原数组上进行，改变自身序列，无返回值。
2. np.random…permutation(x) ：不在原数组上进行，返回新的数组，不改变自身数组。

1. np.random.shuffle(x)

1. 对一维数组重新排序：

import numpy as np

arr = np.arange(10)
print(arr)

np.random.shuffle(arr)
print(arr)

2. 对多维数组重新排序：

arr = np.arange(12).reshape(3,4)
print(arr)

np.random.shuffle(arr)
print(arr)

np.random.shuffle(arr)
print(arr)

通过上述例子可以看出，对于一个多维的输入，只是在第一维上进行了随机排序。例如对这个3×4的矩阵来说，只是对行进行随机排序。

2. np.random.permutation(x)

1. 可直接生成一个随机排列的数组：

np.random.permutation(10)

2. 对一维数组随机排序：

>>> import numpy as np
>>> a=np.random.permutation([0,1,2,3,4,5,6,7,8,9])
>>> print(a)

3. 对多维数组随机排序：

arr = np.arange(9).reshape((3, 3))
print(arr)

arr2 = np.random.permutation(arr)
print(arr)
print(arr2)

通过上述例子可以看出，对于一个多维的输入，只是在第一维上进行了随机排序。例如对这个3×3的矩阵来说，只是对行进行随机排序。

3. np.random.shuffle(x) 与 np.random.permutation(x) 的区别：

• 从代码可以看出，两个函数的功能类似。np.random.shuffle(x)改变自身数组，np.random.permutation(x)不改变自身数组。

  # y = np.transpose(y,(1,0,2))

  # y = np.random.shuffle(y)

  # y = np.transpose(y,(1,0,2))

以上这三行代码会导致ValueError: axes don't match array的错误，
无独有偶，如果使用swapaxis–shuffle–swapaxis也会出现类似的错误。
要避开这一问题。
而要想对某一维度随机排列,可以使用permutation+切片的方案，shuffle仅仅只对axis 0随机。

参考文献

https://www.cnblogs.com/zmbreathing/p/random_shuffle.html