2009-07-19 12 views
15

मुझे पता चला कि मुझे पायथन में एक स्वैप करना है और मैं ऐसा कुछ लिखता हूं।पाइथोनिक स्वैप?

arr[first], arr[second] = arr[second], arr[first] 

मुझे लगता है कि यह इतना पाइथनिक नहीं है। क्या किसी को पता है कि पाइथन में एक स्वैप कैसे अधिक सुन्दर है?

संपादित करें: मुझे लगता है कि एक और उदाहरण मेरी संदेह

self.memberlist[someindexA], self.memberlist[someindexB] = self.memberlist[someindexB], self.memberlist[someindexA] 

इस अजगर में अदला-बदली के लिए ही उपलब्ध समाधान है दिखाई देगा? मैं एक बहुत खोजा गया था, लेकिन एक अच्छा जवाब नहीं मिला ...

+0

आप क्या पसंद नहीं करते? इसके साथ गलत क्या है? आपको क्या पसंद आएगा जो संभवतः छोटा हो सकता है? क्या आप छद्म कोड प्रदान कर सकते हैं जो आपको लगता है कि बेहतर होगा? –

+2

यह प्रत्येक अभिव्यक्ति को दोहराने के लिए एक स्वैप लिखने का एक भयानक तरीका है, लेकिन यह सबसे अच्छा पायथन कर सकता है। सी ++ के स्वैप (क, ख) स्वच्छ, स्वैप करने का गैर दोहराए तरीका है, लेकिन अजगर अविवेक के उस स्तर का समर्थन नहीं करता, तो यह ऐसा नहीं कर सकते। बस रहने के लिए कुछ; प्रत्येक भाषा की इसकी सीमाएं होती हैं, और यह एक मामूली है। –

उत्तर

14

एक बात मैं अपने उदाहरण कोड में बदल सकता है: आप इस तरह के self.memberlist से अधिक के रूप में कुछ लंबे नाम का उपयोग करने जा रहे हैं एक बार फिर, यह अक्सर छोटे नाम के लिए उपनाम ("असाइन") के लिए अधिक पठनीय है। इतने लंबे समय, मुश्किल से पढ़ा के बजाय उदाहरण के लिए:

self.memberlist[someindexA], self.memberlist[someindexB] = self.memberlist[someindexB], self.memberlist[someindexA] 

आप कोड किए जा सकेंगे:

L = self.memberlist 
L[someindexA], L[someindexB] = L[someindexB], L[someindexA] 

कि अजगर द्वारा-संदर्भ काम करता है याद रखें तो एल self.memberlist के रूप में बिल्कुल एक ही वस्तु को संदर्भित करता है, एक प्रति नहीं (उसी टोकन द्वारा, असाइनमेंट बेहद तेज़ है चाहे कोई भी सूची कितनी देर तक हो, क्योंकि यह किसी भी तरह की प्रतिलिपि नहीं है - यह केवल एक और संदर्भ है)।

मुझे नहीं लगता कि किसी भी आगे की जटिलता न्यायसंगत न हो, हालांकि निश्चित रूप से कुछ फैंसी लोगों को आसानी से, इस तरह के रूप में कल्पना की जा सकता है (एक के लिए, ख "सामान्य" सूचकांक >=0):

def slicer(a, b): 
    return slice(a, b+cmp(b,a), b-a), slice(b, a+cmp(a,b), a-b) 

back, forth = slicer(someindexA, someindexB) 
self.memberlist[back] = self.memberlist[forth] 

मैं लगाना लगता है "उन्नत" के इन प्रकार के बाहर का उपयोग करता है एक अच्छा दंभ, उपयोगी मानसिक व्यायाम, और अच्छा मज़ा है - मेरा सुझाव है कि रुचि पाठकों, एक बार सामान्य विचार स्पष्ट है, उन +cmp की भूमिका पर ध्यान केंद्रित करने और अपने काम में कैसे वे चीजों को बनाने के तीन संभावनाएं (एक> ख, एक < ख, एक == ख) [[नहीं नकारात्मक सूचकांक के लिए, यद्यपि - क्यों नहीं, और कैसे स्लाइसर हैं बदलने के लिए इसे ठीक करने] की जरूरत है?]। लेकिन उत्पादन कोड में इस तरह के एक फैंसी दृष्टिकोण का उपयोग आमतौर पर अधिक कठिन और काफी अनचाहे होगा, जिससे चीजों को सरल और सीधा दृष्टिकोण से बनाए रखने के लिए कठिन और कठिन बना दिया जाता है।

याद रखें, simple is better than complex!

मैं - [1 ::]

myarr [:: 2] = myarr [2]

16
a, b = b, a 

Is a perfectly Pythonic idiom. यह छोटी और पठनीय है, जब तक आपके चर नाम काफी कम हैं।

+0

http://www.google.co.il/search?q=python+swap&ie=utf-8&oe=utf-8&aq=t&rls=com.ubuntu:en-US:unofficial&client=firefox-a –

1

कल्पना करना मुश्किल है कि इसे और अधिक सुरुचिपूर्ण कैसे बनाया जा सकता है: एक काल्पनिक अंतर्निहित फ़ंक्शन का उपयोग करके ... swap_sequence_elements(arr, first, second) सुरुचिपूर्ण? हो सकता है, लेकिन यह यागजी क्षेत्र में है - आपको इसे प्राप्त नहीं किया जा रहा है ;-) - और फंक्शन कॉल ओवरहेड आपको इसे लागू करने से रोक देगा।

क्या आपके पास ज्यादा विकल्प में लाइन तरीका की तुलना में अधिक सुंदर है: (! बोनस)

temp = arr[first] 
arr[first] = arr[second] 
arr[second] = temp 

और तेजी से भी (अनुचित नहीं इस धारणा पर है कि एक बाईटकोड ROT_TWO की तुलना में तेजी है एक LOAD_FAST प्लस एक STORE_FAST)।

1

a, b = b, a, के रूप में कम के रूप में आप मिल जाएगा के बारे में है यह (चर नाम को छोड़ कर) केवल तीन पात्रों है .. यह लगभग Python'y के रूप में के रूप में आप मिल जाएगा

एक वैकल्पिक सामान्य use- है एक-अस्थायी-चर:

self.memberlist[someindexA], self.memberlist[someindexB] = self.memberlist[someindexB], self.memberlist[someindexA] 

..becomes ..

temp = self.memberlist[someindexB] 
self.memberlist[someindexB] = self.memberlist[someindexA] 
self.memberlist[someindexA] = temp 

..which मुझे लगता है कि मेसियर और कम "स्पष्ट"

है

एक और तरीका है, जो शायद थोड़ा लंबा चर नाम के साथ और अधिक पठनीय है:

a, b = self.memberlist[someindexA], self.memberlist[someindexB] 
self.memberlist[someindexA], self.memberlist[someindexB] = b, a 
-1

मैं तुम्हें टुकड़ा अंकन के कदम तर्क का लाभ लेने के इस तरह कुछ करने के लिए कर सकता है लगता है यकीन है कि यह स्पष्ट या अधिक pythonic यह है नहीं हूँ ...

संबंधित मुद्दे