मैं किसी सूची को कैसे पुनः व्यवस्थित कर सकता हूं? [बन्द है]

Question

अगर मेरे पास सूची है तो [a,b,c,d,e]मैं वस्तुओं को अनियंत्रित तरीके से कैसे पुन: व्यवस्थित कर सकता हूं [d,c,a,b,e]?

संपादित करें: मैं उन्हें फेरबदल नहीं करना चाहता। मैं उन्हें पूर्वनिर्धारित तरीके से फिर से आदेश देना चाहता हूं। (उदाहरण के लिए, मुझे पता है कि पुरानी सूची में तीसरा तत्व नई सूची में पहला तत्व बनना चाहिए)

Comments

शायद stackoverflow.com/questions/976882/… के

— kincnakakis

यह निर्दिष्ट किए बिना कि आप आइटम को कैसे जवाब देना चाहते हैं। क्या आप उन्हें छांटना चाहते हैं? उन्हें शफ़ल करें? उनमें से कुछ निकालें?

— मिजिपजोर

@tvanfosson: इस मामले में, मनमानी का अर्थ यह भी हो सकता है: एक मनमाना (लेकिन अच्छी तरह से परिभाषित) सॉर्ट फ़ंक्शन लें।

— फेलिक्स क्लिंग

@mizipzor मैं उन्हें पूर्वनिर्धारित तरीके से फिर से आदेश देना चाहता हूं। (इसे स्पष्ट करने के लिए प्रश्न का संपादन किया)

— नियाज

@SilentGhost में इसका नया सूचकांक होगा। 4. हो सकता है कि बिंदु यह है कि मैं वस्तुओं के नए क्रम को जानता हूं।

— नियाज

Answer 1

आप इसे इस तरह से कर सकते हैं

mylist = ['a', 'b', 'c', 'd', 'e']
myorder = [3, 2, 0, 1, 4]
mylist = [mylist[i] for i in myorder]
print(mylist)         # prints: ['d', 'c', 'a', 'b', 'e']

Comments

यह एक नया चर बनाता है। सूची में जगह फिर से कैसे ऑर्डर करें? धन्यवाद

— चकित

@Confounded बस अंतिम पंक्ति को बदलकर:mylist[:] = [mylist[i] for i in myorder]

— एडम

Answer 2

>>> a = [1, 2, 3]
>>> a[0], a[2] = a[2], a[0]
>>> a
[3, 2, 1]

Comments

मैं सिंटैक्स को तब तक नहीं समझ सका जब तक मुझे एहसास नहीं हुआ कि यह एक जोड़ीदार एक साथ काम है । ´ :-)

— love.by.Jesus

Answer 3

>>> import random
>>> x = [1,2,3,4,5]
>>> random.shuffle(x)
>>> x
[5, 2, 4, 3, 1]

Comments

@ wenlibin02, बस इसे 2.7.5 के तहत चलाया और यह अभी भी ठीक काम करता है। क्या आपको किसी प्रकार की त्रुटि मिलती है?

— मार्क

कोई त्रुटि नहीं, मैं सिर्फ टाइप करता हूं: 1) यादृच्छिक आयात करें; x = [1, 2, 3]; (x) random.shuffle; # कोई नहीं लौटाता; और 2) मैंने np.random.shuffle की कोशिश की। परिणाम एक ही हैं।

— लीबिन वेन जूल

मुझे माफ करें! मुझे महसूस नहीं हुआ कि मैं सीधे एक्स के मूल्य को बदल देता हूं। इसने कोई नहीं लौटाया। और यह काम करता है। धन्यवाद।

— लीबिन वेन

Answer 4

अंतिम आदेश को सूचकांकों की सूची द्वारा परिभाषित किया गया है?

>>> items = [1, None, "chicken", int]
>>> order = [3, 0, 1, 2]

>>> ordered_list = [items[i] for i in order]
>>> ordered_list
[<type 'int'>, 1, None, 'chicken']

संपादित करें: meh। एजे तेज था ... मैं अजगर में एक सूची को कैसे पुनः व्यवस्थित कर सकता हूं?

Answer 5

>>> a=["a","b","c","d","e"]
>>> a[0],a[3] = a[3],a[0]
>>> a
['d', 'b', 'c', 'a', 'e']

Answer 6

आप अपना स्वयं का प्रकार प्रदान कर सकते हैं list.sort():

तुलना को नियंत्रित करने के लिए सॉर्ट () विधि वैकल्पिक तर्क लेती है।

• सीएमपी दो तर्कों (सूची आइटम) के एक कस्टम तुलनात्मक फ़ंक्शन को निर्दिष्ट करता है जो एक नकारात्मक, शून्य या सकारात्मक संख्या पर निर्भर करता है, जो इस बात पर निर्भर करता है कि क्या पहले तर्क को दूसरे तर्क की तुलना में छोटा, बराबर या बड़ा माना जाता है cmp=lambda x,y: cmp(x.lower(), y.lower()):। डिफ़ॉल्ट मान है None।

• कुंजी एक तर्क का एक फ़ंक्शन निर्दिष्ट करती है जिसका उपयोग प्रत्येक सूची तत्व से तुलना कुंजी निकालने के लिए किया जाता है key=str.lower:। डिफ़ॉल्ट मान है None।

• रिवर्स एक बूलियन मूल्य है। यदि इसे True पर सेट किया जाता है, तो सूची तत्वों को क्रमबद्ध किया जाता है जैसे कि प्रत्येक तुलना को उलट दिया गया हो।

सामान्य तौर पर, समान cmp फ़ंक्शन को निर्दिष्ट करने की तुलना में कुंजी और रिवर्स रूपांतरण प्रक्रियाएं बहुत तेज होती हैं। ऐसा इसलिए है क्योंकि प्रत्येक सूची तत्व के लिए cmp को कई बार कहा जाता है जबकि कुंजी और रिवर्स प्रत्येक तत्व को केवल एक बार स्पर्श करते हैं।

Comments

और वास्तव में आप इसे कैसे लागू करेंगे?

— साइलेंटगॉस्ट

@SilentGhost: यह एक सामान्य उत्तर के रूप में है। ओपी मामले में आपका उत्तर अधिक उपयुक्त है। फिर भी मुझे लगता है कि यह जानना महत्वपूर्ण है कि एक सामान्य समाधान मौजूद है।

— फेलिक्स क्लिंग

Answer 7

यदि आप सुन्न का उपयोग करते हैं तो ऐसा करने का एक साफ तरीका है:

items = np.array(["a","b","c","d"])
indices = np.arange(items.shape[0])
np.random.shuffle(indices)
print(indices)
print(items[indices])

यह कोड रिटर्न:

[1 3 2 0]
['b' 'd' 'c' 'a']

Comments

ओपी एक विशिष्ट फेरबदल की तलाश में है, न कि सामान्य फेरबदल की।

— तेइपेमम

Answer 8

यदि आप दक्षता के बारे में इतना परवाह नहीं करते हैं, तो आप इसे सुरुचिपूर्ण बनाने के लिए संख्यात्मक खस्ता अनुक्रमण पर भरोसा कर सकते हैं:

a = ['123', 'abc', 456]
order = [2, 0, 1]
a2 = list( np.array(a, dtype=object)[order] )

Answer 9

आपके प्रश्न के बारे में मुझे जो समझ में आता है, उससे यह प्रतीत होता है कि आप एक क्रमपरिवर्तन को लागू करना चाहते हैं जिसे आप एक पर निर्दिष्ट करते हैं list। यह दूसरे को निर्दिष्ट करने list(इसे कॉल करने देता है p) द्वारा किया जाता है जो मूल के तत्वों के सूचकांकों को रखता listहै जो अनुमत में प्रकट होना चाहिए list। आप तब प्रत्येक स्थिति में उस तत्व को प्रतिस्थापित करके pएक नया बनाने के लिए उपयोग करते हैं list, जिसका सूचकांक उस स्थिति में है p।

def apply_permutation(lst, p):
    return [lst[x] for x in p]

arr=list("abcde")
new_order=[3,2,0,1,4]

print apply_permutation(arr,new_order)

यह प्रिंट करता है ['d', 'c', 'a', 'b', 'e'] ।

यह वास्तव में एक नया बनाता है list, लेकिन इसे मूल रूप से "जगह" में अनुमति देने के लिए तुच्छ रूप से संशोधित किया जा सकता है।

Answer 10

एक और बात जिस पर विचार किया जा सकता है, वह दूसरी व्याख्या है जैसा कि अंधेरे से बताया गया है

पायथन में कोड 2.7

में मुख्य:

1. मान द्वारा फिर से - पहले से ही ऊपर एजे द्वारा हल किया गया

2. सूचकांक द्वारा फिर से

   mylist = ['a', 'b', 'c', 'd', 'e']
   myorder = [3, 2, 0, 1, 4]
   
   mylist = sorted(zip(mylist, myorder), key=lambda x: x[1])
   print [item[0] for item in mylist]

यह ['c', 'd', 'b', 'a', 'e'] प्रिंट करेगा

Answer 11

newList = [oldList[3]]
newList.extend(oldList[:3])
newList.extend(oldList[4:])

Answer 12

जब मैंने इस समस्या पर ठोकर खाई तो यही मैंने इस्तेमाल किया।

def order(list_item, i): # reorder at index i
    order_at = list_item.index(i)
    ordered_list = list_item[order_at:] + list_item[:order_at]
    return ordered_list

EX: निचले अक्षरों के लिए

order(string.ascii_lowercase, 'h'):
>>> 'hijklmnopqrstuvwxyzabcdefg'

यह केवल सूची को एक निर्दिष्ट सूचकांक में स्थानांतरित करता है