python - वस्तुओं की एक सूची shuffling





list random shuffle (17)


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

यह विकल्प कुछ अनुप्रयोगों के लिए उपयोगी हो सकता है जहां आप ऑर्डरिंग फ़ंक्शन को स्वैप करना चाहते हैं।

मेरे पास पाइथन में ऑब्जेक्ट्स की एक सूची है और मैं उन्हें शफल करना चाहता हूं। मैंने सोचा कि मैं random.shuffle विधि का उपयोग कर सकता हूं, लेकिन सूची विफल होने पर यह असफल प्रतीत होता है। क्या ऑब्जेक्ट को घुमाने या इस के आसपास किसी अन्य तरीके के लिए कोई तरीका है?

import random

class a:
    foo = "bar"

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

print random.shuffle(b)

यह असफल हो जाएगा।




मुझे यह भी लेने में कुछ समय लगा। लेकिन शफल के लिए प्रलेखन बहुत स्पष्ट है:

जगह में शफल सूची एक्स; वापस कोई नहीं।

तो आपको print random.shuffle(b) नहीं करना चाहिए। print random.shuffle(b) । इसके बजाए random.shuffle(b) करें। random.shuffle(b) और फिर 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]



सुनिश्चित करें कि आप अपनी स्रोत फ़ाइल random.py नामकरण नहीं कर रहे हैं, और यह कि आपकी वर्किंग निर्देशिका में random.pyc नामक कोई फ़ाइल नहीं है .. या तो आपके प्रोग्राम को पाइथन यादृच्छिक मॉड्यूल के बजाय अपनी स्थानीय random.py फ़ाइल को आज़माने और आयात करने का कारण बन सकता है ।




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

यह मेरे लिए ठीक काम करता है। यादृच्छिक विधि सेट करना सुनिश्चित करें।




शफल प्रक्रिया "प्रतिस्थापन के साथ" है , इसलिए प्रत्येक आइटम की घटना बदल सकती है! कम से कम जब आपकी सूची में आइटम भी सूचीबद्ध होते हैं।

उदाहरण के लिए,

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

बाद,

random.shuffle(ml)

[0] की संख्या 9 या 8 हो सकती है, लेकिन बिल्कुल 10 नहीं।




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



कोई shuffled नामक एक फ़ंक्शन को परिभाषित कर सकता है ( sort बनाम sorted समान अर्थ में)

def shuffled(x):
    import random
    y = x[:]
    random.shuffle(y)
    return y

x = shuffled([1, 2, 3, 4])
print x



यदि आप पहले से ही numpy (वैज्ञानिक और वित्तीय अनुप्रयोगों के लिए बहुत लोकप्रिय) का उपयोग कर रहे हैं तो आप स्वयं को एक आयात बचा सकते हैं।

import numpy as np    
np.random.shuffle(b)
print(b)

http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.shuffle.html




""" 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



कुछ मामलों में, numpy arrays का उपयोग करते हुए, 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]])



आप इसके लिए जा सकते हैं:

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

यदि आप दो सूचियों पर वापस जाना चाहते हैं, तो आप इस लंबी सूची को दो में विभाजित करें।




जैसा कि आपने सीखा था कि जगह में शफल समस्या थी। मुझे अक्सर समस्या भी होती है, और अक्सर यह भी भूल जाती है कि सूची को कैसे कॉपी किया जाए। sample(a, len(a)) का उपयोग sample(a, len(a)) नमूना आकार के रूप में len(a) का उपयोग कर समाधान है। पायथन दस्तावेज़ के लिए https://docs.python.org/3.6/library/random.html#random.sample देखें।

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



'foo' के साथ बुलाए जाने पर 'प्रिंट func (foo)' 'func' के वापसी मान को प्रिंट करेगा। 'shuffle' हालांकि इसके वापसी प्रकार के रूप में कोई नहीं है, क्योंकि सूची जगह में संशोधित किया जाएगा, इसलिए यह कुछ भी प्रिंट नहीं करता है। युक्ति:

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

# print it
print(b)

यदि आप कार्यात्मक प्रोग्रामिंग शैली में अधिक हैं तो आप निम्न रैपर फ़ंक्शन बनाना चाहेंगे:

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



यह बढ़िया काम करता है। मैं सूची वस्तुओं के रूप में कार्यों के साथ यहां कोशिश कर रहा हूं:

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

यह प्रिंट करता है: foo1 foo2 foo3 foo2 foo3 foo1 (अंतिम पंक्ति में foos एक यादृच्छिक क्रम है)




योजना: भारी उठाने के लिए लाइब्रेरी पर भरोसा किए बिना शफल लिखें। उदाहरण: तत्व 0 से शुरू होने वाली शुरुआत से सूची के माध्यम से जाएं; इसके लिए एक नई यादृच्छिक स्थिति पाएं, 6 कहें, 0 के मान को 6 और 6 के मान में 0 में रखें। तत्व 1 पर जाएं और इस प्रक्रिया को दोहराएं, और बाकी सूची के माध्यम से

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



extend() का उपयोग एक पुनरावर्तक तर्क के साथ किया जा सकता है। यहाँ एक उदाहरण है। आप इस तरह सूचियों की सूची से एक सूची बनाना चाहते हैं:

से

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

तुम्हें चाहिए

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

ऐसा करने के लिए आप itertools.chain.from_iterable() का उपयोग कर सकते हैं। इस विधि का आउटपुट एक इटरेटर है। इसका कार्यान्वयन बराबर है

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

हमारे उदाहरण पर वापस, हम कर सकते हैं

import itertools
list2d = [[1,2,3],[4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

और वांछित सूची प्राप्त करें।

यहां एक समेकित तर्क के साथ समान रूप से extend() का उपयोग किया जा सकता है:

merged = []
merged.extend(itertools.chain.from_iterable(list2d))
print(merged)
>>>
[1, 2, 3, 4, 5, 6, 7, 8, 9]




python list random shuffle