[PYTHON] 두 개의 관련 목록을 섞는 더 좋은 방법

두 개의 관련 목록을 섞는 더 좋은 방법

다른 목록에서 해당 서신을 깨지 않고 두 개의 관련 목록을 임의로 셔플하는 더 좋은 방법이 있습니까? numpy.array와 c #에서 관련 질문을 찾았지만 정확하지는 않습니다.

첫 번째 시도로서 간단한 zip 트릭이 수행합니다.

import random
a = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
b = [2, 4, 6, 8, 10]
c = zip(a, b)
random.shuffle(c)
a = [e[0] for e in c]
b = [e[1] for e in c]
print a
print b

그것은 출력을 얻을 것이다 :

[[1, 2], [7, 8], [3, 4], [5, 6], [9, 10]]
[2, 8, 4, 6, 10]

그냥 좀 어색한 찾으십시오. 또한 추가 목록도 필요합니다.

해결법

1. ==============================

   1.질문에서 보여준 관계를 감안할 때 목록의 길이가 같고 list1 [i]가 list2 [i]에 해당한다고 가정 할 것입니다. 그 가정하에, 목록을 뒤섞기는 것은 색인을 뒤섞기 만하면됩니다.

   질문에서 보여준 관계를 감안할 때 목록의 길이가 같고 list1 [i]가 list2 [i]에 해당한다고 가정 할 것입니다. 그 가정하에, 목록을 뒤섞기는 것은 색인을 뒤섞기 만하면됩니다.

   from random import shuffle
   # Given list1 and list2
   list1_shuf = []
   list2_shuf = []
   index_shuf = range(len(list1))
   shuffle(index_shuf)
   for i in index_shuf:
       list1_shuf.append(list1[i])
       list2_shuf.append(list2[i])
   

2. ==============================

   2.패키지를 몇 개 더 설치하려면 다음을 수행하십시오.

   패키지를 몇 개 더 설치하려면 다음을 수행하십시오.

   요구 사항 : NumPy (> = 1.6.1), SciPy (> = 0.9).

   pip 설치 -U scikit-learn

   from sklearn.utils import shuffle
   list_1, list_2 = shuffle(list_1, list_2)
   

3. ==============================

   3.이 작업을 자주 수행해야하는 경우 인덱스 목록을 셔플 링하여 한 단계의 간접 참조를 추가하는 것을 고려할 수 있습니다.

   이 작업을 자주 수행해야하는 경우 인덱스 목록을 셔플 링하여 한 단계의 간접 참조를 추가하는 것을 고려할 수 있습니다.

   Python 2.6.6 (r266:84297, Aug 24 2010, 18:13:38) [MSC v.1500 64 bit (AMD64)] on
   win32
   Type "help", "copyright", "credits" or "license" for more information.
   >>> import random
   >>> a = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
   >>> b = [2, 4, 6, 8, 10]
   >>> indexes = range(len(a))
   >>> indexes
   [0, 1, 2, 3, 4]
   >>> random.shuffle(indexes)
   >>> indexes
   [4, 1, 2, 0, 3]
   >>> for index in indexes:
   ...     print a[index], b[index]
   ...
   [9, 10] 10
   [3, 4] 4
   [5, 6] 6
   [1, 2] 2
   [7, 8] 8
   

4. ==============================

   4.numpy를 사용하는 빠른 대답은 다음을 참조하십시오. 당신이 사용할 수있는

   numpy를 사용하는 빠른 대답은 다음을 참조하십시오. 당신이 사용할 수있는

   p = numpy.random.permutation(len(a))
   

   두 목록에 대한 색인의 새 목록을 작성하고이를 사용하여 목록의 순서를 변경하십시오.

   시나리오에서 :

   In [61]: a = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
   In [62]: b = [2, 4, 6, 8, 10]
   In [63]: import numpy as np
   In [64]: a_ar, b_ar = np.array(a), np.array(b)
   In [65]: p = np.random.permutation(len(a))
   In [66]: a, b = a_ar[p].tolist(), b_ar[p].tolist()
   In [68]: a
   Out[68]: [[3, 4], [7, 8], [5, 6], [1, 2], [9, 10]]
   In [69]: b
   Out[69]: [4, 8, 6, 2, 10]
   

5. ==============================

   5.지금까지 모든 솔루션은 문제를 해결하기 위해 새로운 목록을 만들었습니다. 목록 a와 b가 매우 길면 해당 위치에서 임의로 섞을 수 있습니다. 이를 위해 다음과 같은 함수가 필요합니다.

   지금까지 모든 솔루션은 문제를 해결하기 위해 새로운 목록을 만들었습니다. 목록 a와 b가 매우 길면 해당 위치에서 임의로 섞을 수 있습니다. 이를 위해 다음과 같은 함수가 필요합니다.

   import random
   
   def shuffle(a,b):
       assert len(a) == len(b)
       start_state = random.getstate()
       random.shuffle(a)
       random.setstate(start_state)
       random.shuffle(b)
   
   a = [1,2,3,4,5,6,7,8,9]
   b = [10,11,12,13,14,15,16,17,18,19]
   shuffle(a,b)
   print(a) # [9, 7, 3, 1, 2, 5, 4, 8, 6]
   print(b) # [19, 17, 13, 11, 12, 15, 14, 18, 16]
   

6. ==============================

   6.나는 여기서 뭔가를 놓치고 있는지 잘 모르겠다. 그러나 목록의 1 개를 섞은 것 같고 다른 하나는 첫 번째 목록의 순서와 일치하도록 재 배열되어있는 것처럼 보인다. 그래서 당신이 가지고있는 것은 그것을 더 복잡하게하지 않고 이것을 행하는 가장 좋은 방법입니다. 복잡한 경로를 가고 싶다면 1 개의 목록을 임의로 뒤섞고 셔플 링 된 목록에서 조회를 수행하고 그런 식으로 재정렬 할 수 있습니다. 결국 당신은 당신이 시작한 것과 같은 결과로 끝납니다. 세 번째 목록을 만드는 것이 왜 문제가됩니까? 정말로 목록을 재활용하고 싶다면 단순히 목록 b를 목록 c에 사용하는 것으로 교체 한 다음 나중에 다시 a와 b로 구분할 수 있습니다.

   나는 여기서 뭔가를 놓치고 있는지 잘 모르겠다. 그러나 목록의 1 개를 섞은 것 같고 다른 하나는 첫 번째 목록의 순서와 일치하도록 재 배열되어있는 것처럼 보인다. 그래서 당신이 가지고있는 것은 그것을 더 복잡하게하지 않고 이것을 행하는 가장 좋은 방법입니다. 복잡한 경로를 가고 싶다면 1 개의 목록을 임의로 뒤섞고 셔플 링 된 목록에서 조회를 수행하고 그런 식으로 재정렬 할 수 있습니다. 결국 당신은 당신이 시작한 것과 같은 결과로 끝납니다. 세 번째 목록을 만드는 것이 왜 문제가됩니까? 정말로 목록을 재활용하고 싶다면 단순히 목록 b를 목록 c에 사용하는 것으로 교체 한 다음 나중에 다시 a와 b로 구분할 수 있습니다.

from https://stackoverflow.com/questions/11765061/better-way-to-shuffle-two-related-lists by cc-by-sa and MIT license