पायथन में जिप सूची

Question

मैं यह जानने की कोशिश कर रहा हूं कि "ज़िप" की सूची कैसे बनाई जाए। इसके लिए, मेरा एक कार्यक्रम है, जहां एक विशेष बिंदु पर, मैं निम्नलिखित कार्य करता हूं:

x1, x2, x3 = stuff.calculations(withdataa)

यह मैं तीन सूचियों देता है, x1, x2, और x3,, में से प्रत्येक का कहना है, आकार 20।

अब मैं करता हूँ:

zipall = zip(x1, x2, x3)

हालाँकि, जब मैं करता हूँ:

print "len of zipall %s" % len(zipall)

मुझे 20 मिले, जो मुझे उम्मीद नहीं थी। मुझे तीन की उम्मीद थी। मुझे लगता है कि मैं मौलिक रूप से कुछ गलत कर रहा हूं।

Comments

वास्तव में आप क्या zipकरने की उम्मीद कर रहे हैं? आपके पास तीन सूचियाँ क्यों होनी चाहिए - वे कैसी दिखेंगी?

— डैनियल रोज़मैन

ज़िप टुपल्स की सूची देता है।

— डेमो

Answer 1

जब आप zip()एक साथ तीन सूचियों में से प्रत्येक में 20 तत्व होते हैं, तो परिणाम में बीस तत्व होते हैं। प्रत्येक तत्व एक तीन-टपल है।

अपने आप को देखो:

In [1]: a = b = c = range(20)

In [2]: zip(a, b, c)
Out[2]: 
[(0, 0, 0),
 (1, 1, 1),
 ...
 (17, 17, 17),
 (18, 18, 18),
 (19, 19, 19)]

यह पता लगाने के लिए कि प्रत्येक टपल में कितने तत्व हैं, आप पहले तत्व की लंबाई की जांच कर सकते हैं:

In [3]: result = zip(a, b, c)

In [4]: len(result[0])
Out[4]: 3

यदि सूचियों को शुरू करने के लिए खाली थे, तो निश्चित रूप से यह काम नहीं करेगा।

Comments

len (परिणाम [को ०]) अभ्यस्त काम। not जिप ’वस्तु

— ग्राह्य

पायथन 2 में @ गिलबर्ट zipने एक सूची वापस की। पायथन 3 में यह एक

— पुनरावृत्ति

Answer 2

zip सूची पसंद का एक गुच्छा लेता है

a: a1 a2 a3 a4 a5 a6 a7...
b: b1 b2 b3 b4 b5 b6 b7...
c: c1 c2 c3 c4 c5 c6 c7...

और "ज़िप" एक सूची में जिनकी प्रविष्टियां 3-ट्यूपल हैं (ai, bi, ci)। बाएं से दाएं क्षैतिज रूप से जिपर खींचने की कल्पना करें।

Comments

@ सिगुर: "

— डेविड कैरी

Answer 3

पायथन 2.7 में यह ठीक काम कर सकता है:

>>> a = b = c = range(20)
>>> zip(a, b, c)

लेकिन पाइथन 3.4 में यह होना चाहिए (अन्यथा, परिणाम कुछ इस तरह होगा <zip object at 0x00000256124E7DC8>):

>>> a = b = c = range(20)
>>> list(zip(a, b, c))

Answer 4

zip एक नई सूची बनाता है, जो अनुपयोगी तर्कों से तत्वों से युक्त है:

>>> zip ([1,2],[3,4])
[(1,3), (2,4)]

मैं उम्मीद करता हूं कि आप जो भी करने की कोशिश करेंगे वह एक ऐसा टपल है जहां प्रत्येक तत्व एक सूची है।

Answer 5

स्रोत: मेरा ब्लॉग पोस्ट (बेहतर प्रारूपण)

उदाहरण

numbers = [1,2,3]
letters = 'abcd'

zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]

इनपुट

शून्य या अधिक पुनरावृत्तियाँ [1] (पूर्व सूची, स्ट्रिंग, टपल, शब्दकोश)

आउटपुट (सूची)

1 टपल = (संख्याओं का तत्व १, अक्षरों का तत्व १)

2 टुपल = (ई २ अंक, ई २ अक्षर)

...

n-th टुपल = (e_n नंबर, e_n अक्षर)

1. N ट्यूपल्स की सूची: n सबसे छोटे तर्क की लंबाई है (इनपुट)
   • len (संख्याएं) == 3 <len (अक्षर) == 4 → लघु = 3 → 3 tuples लौटें
2. लंबाई प्रत्येक tuple = # args की (tuple प्रत्येक arg से एक तत्व लेता है)
   • args = (संख्या, अक्षर); len (args) == 2 → 2 तत्वों के साथ टपल
3. iवें tuple = (element_i arg1, element_i arg2…, element_i arg n)

एज केस

1) खाली स्ट्रिंग: लेन (str) = 0 = कोई ट्यूपल नहीं

2) सिंगल स्ट्रिंग: लेन (str) == 2 ट्यून विथ लेन (आर्ग्स) == 1 एलिमेंट (एस)

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

---

लड़ाई में जिप!

1. दो सूचियों में से एक शब्दकोश [2] बनाएँ

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

• zip एक सुरुचिपूर्ण, स्पष्ट और संक्षिप्त समाधान है

2. एक तालिका में कॉलम प्रिंट करें

"*" [3] को "अनपैकिंग" कहा जाता है: f(*[arg1,arg2,arg3]) == f(arg1, arg2, arg3)

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

---

अतिरिक्त क्रेडिट: Unzipping

zip(*args) इसे "अनजिपिंग" कहा जाता है क्योंकि इसका उलटा प्रभाव होता है zip

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

• unzipped: tuple_1 = प्रत्येक zipped tuple का e1। tuple_2 = प्रत्येक का e2zipped

---

फुटनोट

1. एक वस्तु जो एक बार में अपने सदस्यों को वापस करने में सक्षम है (उदा। सूची [1,2,3], स्ट्रिंग 'I like codin', tuple (1,2,3), शब्दकोश {'a': 1, 'b' : 2})
2. {की १: मान १, की २: मान २ ...}
3. "अनपैकिंग" (*)

* कोड:

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

*लिया numbers(1 arg) और "unpacked" अपने '2 तत्वों को 2 args में

Answer 6

मूल रूप से जिप फ़ंक्शन पायथन में सूचियों, ट्यूपल्स और शब्दकोशों पर काम करता है। अगर आप IPython का उपयोग कर रहे हैं तो सिर्फ zip टाइप करें? और चेक करें कि ज़िप किस बारे में है।

यदि आप IPython का उपयोग नहीं कर रहे हैं, तो बस इसे स्थापित करें: "pip install ipython"

सूचियों के लिए

a = ['a', 'b', 'c']
b = ['p', 'q', 'r']
zip(a, b)

आउटपुट है [('a', 'p'), ('b', 'q'), ('c', 'r')

शब्दकोश के लिए:

c = {'gaurav':'waghs', 'nilesh':'kashid', 'ramesh':'sawant', 'anu':'raje'}
d = {'amit':'wagh', 'swapnil':'dalavi', 'anish':'mane', 'raghu':'rokda'}
zip(c, d)

आउटपुट है:

[('gaurav', 'amit'),
 ('nilesh', 'swapnil'),
 ('ramesh', 'anish'),
 ('anu', 'raghu')]

Comments

zip (c, d) प्रदर्शन कर रहा है zip (सूची (c), सूची (d))

— स्टीफन वुडब्रिज

Answer 7

पायथन 3 में इसके zipबजाय एक पुनरावृत्ति देता है और ज़िप्ड ट्यूपल्स प्राप्त करने के लिए एक सूची फ़ंक्शन को पारित करने की आवश्यकता होती है:

x = [1, 2, 3]; y = ['a','b','c']
z = zip(x, y)
z = list(z)
print(z)
>>> [(1, 'a'), (2, 'b'), (3, 'c')]

फिर unzipउन्हें वापस सिर्फ ज़िप्ड इट्रीजर को संयुग्मित करें:

x_back, y_back = zip(*z)
print(x_back); print(y_back)
>>> (1, 2, 3)
>>> ('a', 'b', 'c')

यदि ट्यूपल्स के बजाय सूची के मूल रूप की आवश्यकता है:

x_back, y_back = zip(*z)
print(list(x_back)); print(list(y_back))
>>> [1,2,3]
>>> ['a','b','c']

Comments

प्रश्न टैग में कहा गया है कि पायथन 2.7; यह पायथन 3 के लिए है। इसके अलावा, इस जवाब में पहले से ही इस का उल्लेख है।

— 0 0

Answer 8

पूर्णता के लिए।

जब ज़िपित सूचियों की लंबाई बराबर नहीं होती है। परिणाम सूची की लंबाई बिना किसी त्रुटि के सबसे छोटी हो जाएगी

>>> a = [1]
>>> b = ["2", 3]
>>> zip(a,b)
[(1, '2')]

Answer 9

मुझे नहीं लगता कि zipकोई सूची लौटाता है। zipएक जनरेटर देता है। list(zip(a, b))टुपल्स की एक सूची प्राप्त करने के लिए आपको क्या करना है।

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)

Comments

प्रश्न टैग में कहा गया है कि पायथन 2.7; यह पायथन 3 के लिए है। इसके अलावा, इस जवाब में पहले से ही इस का उल्लेख है।

— 0 0

Answer 10

यह यहाँ जोड़ने लायक है क्योंकि यह ज़िप पर इतना उच्च रैंकिंग वाला प्रश्न है। zipमहान, मुहावरेदार पायथन है - लेकिन यह बड़ी सूचियों के लिए बिल्कुल अच्छा नहीं है।

के बजाय:

books = ['AAAAAAA', 'BAAAAAAA', ... , 'ZZZZZZZ']
words = [345, 567, ... , 672]

for book, word in zip(books, words):
   print('{}: {}'.format(book, word))

का उपयोग करें izip। आधुनिक प्रसंस्करण के लिए, यह इसे L1 कैश मेमोरी में संग्रहीत करता है और बड़ी सूचियों के लिए कहीं अधिक प्रदर्शनकारी है। इसे जोड़ने के रूप में बस एक का उपयोग करें i:

for book, word in izip(books, words):
   print('{}: {}'.format(book, word))