Giải pháp "đáng sợ" của bạn không có vẻ đáng sợ đối với tôi. Gọi
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
0 cho hai chuỗi có cùng độ dài kết quả trong cùng một số cuộc gọi đến trình tạo số ngẫu nhiên và đây là các phần tử "ngẫu nhiên" duy nhất trong thuật toán shuffle. Bằng cách đặt lại trạng thái, bạn đảm bảo rằng các cuộc gọi đến trình tạo số ngẫu nhiên sẽ đưa ra kết quả tương tự trong cuộc gọi thứ hai tới ____10, do đó toàn bộ thuật toán sẽ tạo ra cùng một hoán vị.Nếu bạn không thích điều này, một giải pháp khác sẽ là lưu trữ dữ liệu của bạn trong một mảng thay vì hai ngay từ đầu và tạo hai lượt xem vào mảng duy nhất này mô phỏng hai mảng bạn có bây giờ. Bạn có thể sử dụng một mảng duy nhất để xáo trộn và các chế độ xem cho tất cả các mục đích khác.
Ví dụ: Giả sử các mảng
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
2 và c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
3 trông như thế này:a = numpy.array[[[[ 0., 1., 2.],
[ 3., 4., 5.]],
[[ 6., 7., 8.],
[ 9., 10., 11.]],
[[ 12., 13., 14.],
[ 15., 16., 17.]]]]
b = numpy.array[[[ 0., 1.],
[ 2., 3.],
[ 4., 5.]]]
Bây giờ chúng ta có thể xây dựng một mảng duy nhất chứa tất cả dữ liệu:
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
Bây giờ chúng tôi tạo các chế độ xem mô phỏng bản gốc
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
2 và c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
3: a2 = c[:, :a.size//len[a]].reshape[a.shape]
b2 = c[:, a.size//len[a]:].reshape[b.shape]
Dữ liệu của
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
6 và c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
7 được chia sẻ với c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
8. Để xáo trộn cả hai mảng đồng thời, hãy sử dụng c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
9.Trong mã sản xuất, tất nhiên bạn sẽ cố gắng tránh tạo bản gốc
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
2 và c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
3 và ngay lập tức tạo ra c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
8, c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
6 và c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
7.Giải pháp này có thể được điều chỉnh với trường hợp
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
2 và c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
3 có các DTYPE khác nhau. Một trong những cách dễ nhất để xáo trộn một khung dữ liệu gấu trúc là sử dụng phương pháp mẫu Pandas. DF. Phương pháp mẫu cho phép bạn lấy mẫu một số hàng trong khung dữ liệu gấu trúc theo thứ tự ngẫu nhiên. Bởi vì điều này, chúng tôi chỉ cần chỉ định rằng chúng tôi muốn trả về toàn bộ DataFrame của Pandas, theo thứ tự ngẫu nhiên.
Làm thế nào để bạn xáo trộn một mảng numpy trong Python?
Với sự trợ giúp của phương thức numpy.random.shuffle [], chúng ta có thể nhận được định vị ngẫu nhiên của các giá trị số nguyên khác nhau trong mảng numpy hoặc chúng ta có thể nói rằng tất cả các giá trị trong một mảng sẽ bị xáo trộn ngẫu nhiên. Trả lại: Trả lại mảng numpy được cải tổ.
Một trong những cách dễ nhất để xáo trộn một khung dữ liệu gấu trúc là sử dụng phương pháp mẫu Pandas. DF. Phương pháp mẫu cho phép bạn lấy mẫu một số hàng trong khung dữ liệu gấu trúc theo thứ tự ngẫu nhiên. Bởi vì điều này, chúng tôi chỉ cần chỉ định rằng chúng tôi muốn trả về toàn bộ DataFrame của Pandas, theo thứ tự ngẫu nhiên.
Làm thế nào để bạn xáo trộn một mảng numpy trong Python?
Lưu bài viết
Đôi khi, trong khi làm việc với danh sách Python, chúng ta có thể gặp vấn đề trong đó chúng ta cần thực hiện hoạt động Shuffle trong danh sách. Nhiệm vụ này rất dễ dàng và có các chức năng đơn giản có sẵn trong Python để thực hiện điều này. Nhưng đôi khi, chúng ta cần phải xáo trộn hai danh sách để các đơn đặt hàng xáo trộn của họ phù hợp. Hãy để thảo luận về một cách mà nhiệm vụ này có thể được thực hiện. Thứ nhất, các danh sách được nén lại với nhau bằng zip []. Bước tiếp theo là thực hiện shuffle bằng cách sử dụng inbuilt Shuffle [] và bước cuối cùng là giải nén các danh sách để tách danh sách bằng cách sử dụng toán tử * & nbsp; & nbsp;
Method : Using zip[] + shuffle[] + * operator
In this method, this task is performed in three steps. Firstly, the lists are zipped together using zip[]. Next step is to perform shuffle using inbuilt shuffle[] and last step is to unzip the lists to
separate lists using * operator.
Python3
a2 = c[:, :a.size//len[a]].reshape[a.shape]
b2 = c[:, a.size//len[a]:].reshape[b.shape]
7 a2 = c[:, :a.size//len[a]].reshape[a.shape]
b2 = c[:, a.size//len[a]:].reshape[b.shape]
8a2 = c[:, :a.size//len[a]].reshape[a.shape]
b2 = c[:, a.size//len[a]:].reshape[b.shape]
9The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]0
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]1
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]2
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]4
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]6
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]8
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
0import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
1import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
2The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]0
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]1
import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
5The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
7The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
9The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]4
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]3
[[0 0]
[2 2]
[1 1]]
[0 2 1]
3____41[[0 0]
[2 2]
[1 1]]
[0 2 1]
5[[0 0]
[2 2]
[1 1]]
[0 2 1]
6[[0 0]
[2 2]
[1 1]]
[0 2 1]
7[[0 0]
[2 2]
[1 1]]
[0 2 1]
8[[0 0]
[2 2]
[1 1]]
[0 2 1]
5[[0 0]
[2 2]
[1 1]]
[0 2 1]
6import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
1[[0 0]
[2 2]
[1 1]]
[0 2 1]
8import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
3The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]0
import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
5import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
6import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
7import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
8import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
9
[[2 2]
[0 0]
[1 1]]
[2 0 1]
0The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]0
import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
7import numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
6[[2 2]
[0 0]
[1 1]]
[2 0 1]
4__‘
[[0 0]
[2 2]
[1 1]]
[0 2 1]
5[[0 0]
[2 2]
[1 1]]
[0 2 1]
6import numpy as np
def shuffle[x, y]:
p = np.random.permutation[len[y]]
return x[p], y[p]
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = shuffle[array1, array2]
print[array1]
print[array2]
4[[0 0]
[2 2]
[1 1]]
[0 2 1]
8[[0 0]
[2 2]
[1 1]]
[0 2 1]
5[[0 0]
[2 2]
[1 1]]
[0 2 1]
6import numpy as np
def shuffle[x, y]:
p = np.random.permutation[len[y]]
return x[p], y[p]
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = shuffle[array1, array2]
print[array1]
print[array2]
8[[0 0]
[2 2]
[1 1]]
[0 2 1]
8Đầu ra: & nbsp;
The original list 1 : [6, 4, 8, 9, 10] The original list 2 : [1, 2, 3, 4, 5] List 1 after shuffle : [6, 10, 4, 8, 9] List 2 after shuffle : [1, 5, 2, 3, 4]
Đã tạo: tháng 5-08, 2021 Hướng dẫn này sẽ giới thiệu cách xáo trộn hai mảng numpy trong Python. Numpy Shuffle hai mảng với hàm
0 trong Python[[0 0]
[2 2]
[1 1]]
[0 2 1]
1[[0 0]
[2 2]
[1 1]]
[0 2 1]
2 trong Python[[0 0]
[2 2]
[1 1]]
[0 2 1]
Numpy Shuffle Hai mảng với chức năng
0 trong Python[[0 0]
[2 2]
[1 1]]
[0 2 1]
1[[0 0]
[2 2]
[1 1]]
[0 2 1]
import numpy as np
from sklearn import utils
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = utils.shuffle[array1, array2]
print[array1]
print[array2]
Output:
[[0 0]
[2 2]
[1 1]]
[0 2 1]
Numpy Shuffle Hai mảng tương ứng với hàm
[[0 0]
[2 2]
[1 1]]
[0 2 1]
2 trong PythonNumpy Shuffle hai mảng với hàm [[0 0]
[2 2]
[1 1]]
[0 2 1]
1
[[0 0]
[2 2]
[1 1]]
[0 2 1]
Numpy Shuffle Hai mảng tương ứng với hàm
[[0 0]
[2 2]
[1 1]]
[0 2 1]
2 trong Pythonimport numpy as np
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
randomize = np.arange[len[array2]]
np.random.shuffle[randomize]
array1 = array1[randomize]
array2 = array2[randomize]
print[array1]
print[array2]
Output:
[[2 2]
[0 0]
[1 1]]
[2 0 1]
Hướng dẫn này sẽ giới thiệu cách xáo trộn hai mảng numpy trong Python.
Numpy Shuffle Hai mảng tương ứng với hàm [[0 0]
[2 2]
[1 1]]
[0 2 1]
2 trong Python
[[0 0]
[2 2]
[1 1]]
[0 2 1]
Hướng dẫn này sẽ giới thiệu cách xáo trộn hai mảng numpy trong Python.
import numpy as np
def shuffle[x, y]:
p = np.random.permutation[len[y]]
return x[p], y[p]
array1 = np.array[[[0,0], [1,1], [2,2]]]
array2 = np.array[[0,1,2]]
array1, array2 = shuffle[array1, array2]
print[array1]
print[array2]
Output:
[[0 0]
[2 2]
[1 1]]
[0 2 1]
Giả sử chúng ta có hai mảng có cùng chiều dài hoặc cùng kích thước hàng đầu và chúng ta muốn xáo trộn cả hai theo cách mà các phần tử tương ứng trong cả hai mảng vẫn tương ứng. Trong trường hợp đó, chúng ta có thể sử dụng hàm
c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
0 bên trong thư viện [[0 0]
[2 2]
[1 1]]
[0 2 1]
5 trong Python. Hàm c = numpy.c_[a.reshape[len[a], -1], b.reshape[len[b], -1]]
# array[[[ 0., 1., 2., 3., 4., 5., 0., 1.],
# [ 6., 7., 8., 9., 10., 11., 2., 3.],
# [ 12., 13., 14., 15., 16., 17., 4., 5.]]]
0 này lấy các mảng làm tham số đầu vào, xáo trộn chúng một cách nhất quán và trả về một bản sao xáo trộn của mỗi mảng. Xem ví dụ mã sau.