अंतर

Question

मैं एक सूची p = [[1,2,3],[4,5,6]]

उपयोग कर रहा हूँ, तो मुझे क्या करना:

:

>>>d=zip(p) 
>>>list(d) 
[([1, 2, 3],), ([4, 5, 6],)] 

हालांकि, क्या मैं वास्तव में चाहते हैं तो इस का उपयोग कर प्राप्त किया जाता है

>>>d=zip(*p) 
>>>list(d) 
[(1, 4), (2, 5), (3, 6)] 

मुझे पता चला है कि सूची नाम से पहले '*' जोड़ना मेरे आवश्यक आउटपुट देता है, लेकिन मैं उनके ऑपरेशन में अंतर नहीं कर सकता। क्या आप अंतर को समझा सकते हैं?

Answer 1

हालांकि यह सवाल नहीं है कि आपने जो सवाल पूछा है, उसे मदद करनी चाहिए। चूंकि ज़िप का उपयोग दो सूचियों को गठबंधन करने के लिए किया जाता है, इसलिए आपको यह सुनिश्चित करने के लिए इस list(zip(p[0], p[1])) की तरह कुछ करना चाहिए।

Answer 2

zip एक साथ ज़िप करने के लिए तर्कों का एक गुच्छा चाहता है, लेकिन आपके पास एक भी तर्क है (एक सूची, जिसका तत्व भी सूचीबद्ध है)। एक फंक्शन कॉल में * एक सूची (या अन्य पुनरावृत्त) को "अनपैक" करता है, जिससे प्रत्येक तत्व एक अलग तर्क बनाते हैं। तो * के बिना, आप zip([[1,2,3],[4,5,6]]) कर रहे हैं। * के साथ, आप zip([1,2,3], [4,5,6]) कर रहे हैं।

Answer 3

संक्षेप में, x = [1,2,3] के साथ, f(x) पर कॉल करते समय, x को 1 तर्क [1, 2, 3] प्राप्त होता है। जब आप स्टार ऑपरेटर f(*x) का उपयोग करते हैं, तो एफ को तीन तर्क प्राप्त होते हैं, यह कॉल f(1,2,3) के बराबर है।

यही कारण है कि, पायथन के दस्तावेज़ में, आप अक्सर some_function(*args, **kwargs) देखेंगे। यहां डबल स्टार ऑपरेटर वही करता है, लेकिन एक शब्दकोश के लिए: d={"some_arg":2, "some_other_arg":3} के साथ, f(**d) पर कॉल करना f(some_arg=2, some_other_arg=3) जैसा ही है।

अब जब आप ज़िप का उपयोग करते हैं, तो प्रभावी रूप से आप [1,2,3] [4,5,6] के साथ ज़िप करना चाहते हैं, इसलिए आप ज़िप के लिए 2 तर्क पारित करना चाहते हैं, इसलिए आपको स्टार ऑपरेटर की आवश्यकता है। इसके बिना, आप केवल एक ही तर्क पारित कर रहे हैं।

Answer 4

असल * ऑपरेटर खोल रहा है, और zip समारोह के रूप में iterable आप इस समारोह के लिए कई iterable पारित कर सकते हैं की एक सूची स्वीकार करते हैं:

तो *p का परिणाम है:

[1,2,3],[4,5,6] 

और zip(*p)zip([1,2,3],[4,5,6]) के बराबर है।

बेहतर समझ ध्यान दें कि * एक सूची अनज़िप करने के लिए इस्तेमाल किया जा सकता के लिए

इसके अलावा:

>>> zip(*zip(*p)) 
[(1, 2, 3), (4, 5, 6)] 

उपरोक्त आदेश zip(*p) का परिणाम खोल ताकि आप होगा:

zip((1, 4), (2, 5), (3, 6)) 

zip([iterable, ...])

यह फ़ंक्शन टुपल्स की एक सूची देता है, जहां i-th tuple प्रत्येक तर्क अनुक्रम या पुनरावृत्तियों से i-th तत्व शामिल है। लौटाई गई सूची को सबसे कम तर्क अनुक्रम की लंबाई तक लंबाई में छोटा कर दिया जाता है।जब कई तर्क होते हैं जो सभी समान लंबाई होते हैं, तो ज़िप() किसी भी प्रारंभिक तर्क के साथ मानचित्र() के समान होता है। एक अनुक्रम तर्क के साथ, यह 1-टुपल्स की एक सूची देता है। कोई तर्क नहीं के साथ, यह एक खाली सूची देता है।

Answer 5

* ऑपरेटर फ़ंक्शन आमंत्रण कथन में तर्कों को अनपैक करता है।

इस

def add(x, y): 
    return x + y 

पर विचार करें यदि आप एक सूची t = [1,2] है, तो आप add(t[0], t[1]) जो बेकार में वर्बोज़ है का कहना है कि या तो कर सकते हैं या आप ऐसा add(*t) तरह * ऑपरेटर का उपयोग अलग तर्क में t "खोल" कर सकते हैं।

यह आपके उदाहरण में क्या चल रहा है। zip(p)zip([[1,2,3],[4,5,6]]) चलाने जैसा है। ज़िप में एक भी तर्क है इसलिए यह मामूली रूप से इसे एक टुपल के रूप में लौटाता है।

zip(*p)zip([1,2,3], [4,5,6]) चलाने जैसा है। यह zip(p[0], p[1]) चलाने के समान है और आपको अपेक्षित आउटपुट मिलता है।

Answer 6

"*" ऑपरेटर unpacks एक सूची और इसे किसी फ़ंक्शन पर लागू करता है। zip समारोह दोनों सूचियों के प्रत्येक तत्व से n सूचियों लेता है और बनाता है एन-टपल जोड़े:

जिप ([iterable, ...])

इस समारोह मैं कहाँ tuples की एक सूची, रिटर्न -थ टुपल में प्रत्येक तर्क अनुक्रम या पुनरावृत्तियों से i-th तत्व शामिल है। लौटाई गई सूची को कम से कम तर्क अनुक्रम की लंबाई तक छोटा कर दिया गया है। जब कई तर्क होते हैं जो सभी समान हैं, तो ज़िप() किसी प्रारंभिक तर्क के साथ मानचित्र() के समान है। एक अनुक्रम तर्क के साथ, यह 1-टुपल्स की एक सूची देता है। कोई तर्क नहीं के साथ, यह एक खाली सूची देता है।

असल में, [[1,2,3],[4,5,6]] साथ * उपयोग करके, आप [1,2,3] और [4,5,6] ज़िप करने के लिए तर्क के रूप में गुजर रहे हैं।