python - पायथोनिक सूची के अंदर एक पुनरावृत्त को अनपैक करने का तरीका




python-3.x list (4)

अगर मुझे किसी सूची को शब्दकोश में बदलने या लूप या सूची बोध में कुंजी-मूल्य जोड़ी के रूप में उपयोग करने की आवश्यकता है, तो मैं ज़िप का उपयोग करता हूं।

हालांकि, अगर यह केवल इटरेटर बनाने के लिए चित्रण के लिए है। मैं स्पष्टता के लिए # 3 वोट जरूर दूंगा।

मैं यह पता लगाने की कोशिश कर रहा हूं कि सूची के अंदर एक pythonic को pythonic लिए pythonic तरीका क्या है।

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

my_iterator = zip([1, 2, 3, 4], [1, 2, 3, 4])

मैं सूची के अंदर अपने पुनरावृत्ति को हटाने के लिए निम्नलिखित तरीके लेकर आया हूं:

1)

my_list = [*my_iterator]

2)

my_list = [e for e in my_iterator]

3)

my_list = list(my_iterator)

नहीं 1) यह मेरा पसंदीदा तरीका है क्योंकि यह कम कोड है, लेकिन मैं सोच रहा हूं कि क्या यह भी पाइथोनिक तरीका है। या शायद उन 3 के अलावा इसे प्राप्त करने का एक और तरीका है जो कि पायथोनिक तरीका है?


अधिक विषय की खोज के बाद मैं कुछ निष्कर्षों के साथ आया हूं।

वहाँ एक होना चाहिए - और अधिमानतः इसे करने के लिए केवल एक ही - स्पष्ट तरीका

( pythonic )

"पाइथोनिक" कौन सा विकल्प है यह तय करना कुछ मानदंडों को ध्यान में रखना चाहिए:

  • कितना स्पष्ट है,
  • सरल,
  • और पठनीय है।

और सभी मानदंडों में जीतने वाला स्पष्ट "पायथोनिक" विकल्प नंबर 3 है):

सूची = सूची (my_iterator)

यहाँ क्यों "स्पष्ट" है कि कोई 3) पायथोनिक एक है:

  • विकल्प 3) प्राकृतिक भाषा के करीब है जो आपको 'तुरन्त' लगता है कि आउटपुट क्या है।
  • विकल्प 2) (सूची समझ का उपयोग करके) यदि आप पहली बार देखते हैं कि कोड की लाइन आपको थोड़ा और अधिक पढ़ने और थोड़ा और ध्यान देने के लिए ले जाएगी। उदाहरण के लिए, मैं सूची बोध का उपयोग करता हूं, जब मैं कुछ अतिरिक्त चरणों को जोड़ना चाहता हूं (पुनरावृत्त तत्वों के साथ एक फ़ंक्शन को कॉल करना या कुछ स्टेटमेंट का उपयोग करके जांच करना), इसलिए जब मुझे सूची समझ दिखाई देती है, तो मैं किसी भी संभावित फ़ंक्शन कॉल के लिए या किसी अन्य के लिए जांच करता हूं अगर क़ानून है।
  • विकल्प 1) (* का उपयोग न करना)) तारांकन ऑपरेटर थोड़ा भ्रमित हो सकता है यदि आप इसे नियमित रूप से उपयोग नहीं करते हैं, तो पायथन में तारांकन का उपयोग करने के लिए 4 मामले हैं:

    1. गुणन और शक्ति संचालन के लिए।
    2. सूची-प्रकार के कंटेनरों को बार-बार विस्तारित करने के लिए।
    3. वैरेडिक तर्कों का उपयोग करने के लिए। (तथाकथित "पैकिंग")
    4. कंटेनरों को अनपैक करने के लिए।

एक और अच्छा तर्क है खुद अजगर डॉक्स , मैंने यह जांचने के लिए कुछ आंकड़े किए हैं कि कौन से विकल्प डॉक्स द्वारा चुने गए हैं, इसके लिए मैंने मॉड्यूल itertools से 4 itertools -इन itertools और सब कुछ itertools (जिनका उपयोग किया जाता है: itertools. ) देखें कि वे एक सूची में कैसे अनपैक्ड हैं:

  • नक्शा
  • रेंज
  • फिल्टर
  • एक एक करके बताना
  • itertools।

डॉक्स की खोज करने के बाद, मैंने पाया: 0 पुनरावृत्तियों ने विकल्प 1) और 2) और 35 विकल्प 3 का उपयोग करके एक सूची में अनपैक किया)।

निष्कर्ष :

सूची के अंदर एक my_list = list(my_iterator) है: my_list = list(my_iterator)


हालांकि अनपैकिंग ऑपरेटर * का उपयोग किसी एकल सूची में किसी एकल पुनरावृत्ति को बदलने के लिए नहीं किया जाता है (इसलिए [*it] list(it) तुलना में थोड़ा कम पठनीय है, यह कई अन्य मामलों में आसान और अधिक पायथोनिक है:

1. एकल सूची / टपल / सेट में एक पुनरावृत्ति को खोलना, अन्य मूल्यों को जोड़ना:

mixed_list = [a, *it, b]

यह तुलना में अधिक संक्षिप्त और कुशल है

mixed_list = [a]
mixed_list.extend(it)
mixed_list.append(b)

2. एक सूची / टपल / सेट में कई पुनरावृत्तियों + मूल्यों को खोलना

mixed_list = [*it1, *it2, a, b, ... ]

यह पहले मामले के समान है।

3. तत्वों को छोड़कर, एक पुनरावृत्ति को एक सूची में रखना

first, *rest = it

यह इसका पहला तत्व पहले में निकालता है और बाकी को सूची में शामिल करता है। एक भी कर सकते हैं

_, *mid, last = it

यह इसके पहले तत्व को बिना देखभाल वाले चर _ में डंप करता है, अंतिम तत्व को last में बचाता है, और शेष को सूची mid में खोल देता है।

4. एक बयान में एक पुनरावृत्ति के कई स्तरों के नेस्टेड अनपैकिंग

it = (0, range(5), 3)
a1, (*a2,), a3 = it          # Unpack the second element of it into a list a2
e1, (first, *rest), e3 = it  # Separate the first element from the rest while unpacking it[1]

यह भी बयानों के for इस्तेमाल किया जा सकता है:

from itertools import groupby

s = "Axyz123Bcba345D"
for k, (first, *rest) in groupby(s, key=str.isalpha):
    ...

हो सकता है कि इट्रेटर को किसी सूची में बदलने के लिए यह सबसे तेज़ तरीका हो , लेकिन आपका सवाल थोड़ा अलग है क्योंकि आप पूछते हैं कि सबसे पाइथोनिक कौन सा है। स्वीकृत उत्तर list(my_iterator) पर [e for e in my_iterator] क्योंकि हुड के नीचे C में पूर्व रन। एक टिप्पणीकार का [*my_iterator] कि [*my_iterator] list(my_iterator) तुलना में तेज़ है, इसलिए आप यह परीक्षण करना चाहते हैं। मेरा सामान्य मत यह है कि वे सभी समान रूप से पाइथोनिक हैं, इसलिए मैं आपके उपयोग के मामले में दो के तेज के साथ जाऊंगा। यह भी संभव है कि पुराना उत्तर पुराना हो गया हो।





unpack