सूचियों की सूची स्थानांतरित करें

Question

चलो ले लो:

l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

परिणाम मैं देख रहा हूँ

r = [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

और नहीं

r = [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

बहुत सराहना की

Answer 1

कैसा रहेगा

map(list, zip(*l))
--> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

अजगर 3.x उपयोगकर्ताओं के लिए उपयोग कर सकते हैं

list(map(list, zip(*l)))

स्पष्टीकरण:

दो चीजें हैं जो हमें समझने की जरूरत है कि क्या हो रहा है:

1. जिप के हस्ताक्षर : zip(*iterables)इसका मतलब zipहै कि मनमाने ढंग से तर्कों की संख्या जिनमें से प्रत्येक को पुनरावृत्त होना चाहिए। जैसे zip([1, 2], [3, 4], [5, 6])।
2. अनपैक्ड लॉजिक लिस्ट : तर्कों के एक क्रम को देखते हुए args, ऐसे f(*args)बुलाएगा fकि प्रत्येक तत्व argsएक अलग स्थिति का तर्क है f।

प्रश्न से इनपुट पर वापस आना l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], zip(*l)समतुल्य होगा zip([1, 2, 3], [4, 5, 6], [7, 8, 9])। बाकी सिर्फ यह सुनिश्चित कर रहा है कि परिणाम ट्यूपल्स की सूची के बजाय सूचियों की एक सूची है।

Comments

खबरदार: यदि lसमान रूप से आकार नहीं है (कहते हैं, कुछ पंक्तियाँ दूसरों की तुलना में छोटी हैं), इसके लिए क्षतिपूर्ति नहींzip करेंगे और इसके बजाय आउटपुट से पंक्तियों को काट लें। तो आपको देता है । l=[[1,2],[3,4],[5]][[1,3,5]]

— badp

itertoolsसमारोह zip_longest()असमान सूचियों के साथ काम करता है। देखें डॉक्स

— अजवायन की पत्ती

उत्तर में एक स्पष्टीकरण अच्छा होगा :)

— बोरिस चुरज़िन

मैं भी लगता है कि list(zip(*l))अजगर में ठीक से काम करता 3.

— Stefano

@Stefano यह काम करता है (जैसा कि zip(*l)पायथन 2 में होता है), लेकिन आपको सूचियों की सूची नहीं बल्कि टुपल्स की एक सूची मिलती है। बेशक, list(list(it))हमेशा की तरह एक ही बात है list(it)।

— एलेक्स शापिल्किन

Answer 2

इसे करने का एक तरीका NumPy के साथ है। एक सूची के लिए:

>>> import numpy as np
>>> np.array(a).T.tolist()
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

या ज़िप के बिना एक और:

>>> map(list,map(None,*a))
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Comments

अपने दूसरे को प्यार करो - मुझे नहीं पता था mapकि वह कर सकता है। यहाँ एक मामूली शोधन है जिसे 2 कॉल की आवश्यकता नहीं है, हालांकि:map(lambda *a: list(a), *l)

— ली डी

यह एक बेहतर जवाब नहीं होना चाहिए क्योंकि यह असमान सूचियों का ध्यान रखता है?

— लियोन

map(None, ...)Py3 के लिए काम करने के लिए प्रतीत नहीं होता है। जनरेटर बनाया गया है, लेकिन next()तुरंत एक त्रुटि उठाता है TypeError: 'NoneType' object is not callable:।

— मैड फिजिसिस्ट

Answer 3

जेना के समाधान के बराबर:

>>> l=[[1,2,3],[4,5,6],[7,8,9]]
>>> [list(i) for i in zip(*l)]
... [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Comments

जैसा कि सूची की समझ अब पसंद की जाती है map(), यह समाधान वह है जो पायथन आत्मा में सबसे अधिक है ...

— पेरर

Answer 4

केवल मज़ेदार, मान्य आयतों और मान लेने के लिए कि मी [0] मौजूद है

>>> m = [[1,2,3],[4,5,6],[7,8,9]]
>>> [[row[i] for row in m] for i in range(len(m[0]))]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Comments

यही वह चीज है जिसकी मैं तलाश कर रहा था और अपना सिर इधर-उधर नहीं कर सकता था। फिर भी @ जेना का समाधान वास्तव में कम है

— टाइटस

हाँ, यह सही पाने के लिए कुछ टायर लगे। ठीक है, कई कोशिश करता है।

— Matchew

अभी भी काफी सही नहीं है - यह केवल तब काम करता है जब आयाम चौकोर हों! यह होना चाहिए [[j[i] for j in l] for i in range(len(l[0]))]:। बेशक, आपको यह सुनिश्चित करना होगा कि सूची lखाली नहीं है।

— ली डी

अभी भी @LeeD करता जेना के उदाहरण एल पर मेरे लिए नहीं काम = [[1,2], [3,4], [5]]

— hobs

@ हब्स जो कि बैडप का उदाहरण था, जेना का जवाब। हालाँकि, मुझे यकीन नहीं है कि यह मेरे लिए समझ में आता है। IMO, ट्रांसपोज़िशन का अर्थ एक आयताकार मैट्रिक्स है - जब सूचियों की सूची के रूप में प्रतिनिधित्व किया जाता है, तो इसका मतलब है कि सभी आंतरिक सूचियों की लंबाई समान होनी चाहिए। इस उदाहरण के "ट्रांसपोज़िशन" के रूप में आप क्या परिणाम चाहते हैं?

— ली डी

Answer 5

तरीके 1 और 2 पायथन 2 या 3 में काम करते हैं, और वे रैग्ड, आयताकार 2 डी सूचियों पर काम करते हैं । इसका मतलब है कि आंतरिक सूचियों को एक-दूसरे (रैग्ड) या बाहरी सूचियों (आयताकार) के समान लंबाई की आवश्यकता नहीं है। अन्य तरीकों, ठीक है, यह जटिल है।

स्थापित करना

import itertools
import six

list_list = [[1,2,3], [4,5,6, 6.1, 6.2, 6.3], [7,8,9]]

---

विधि 1 - map(),zip_longest()

>>> list(map(list, six.moves.zip_longest(*list_list, fillvalue='-')))
[[1, 4, 7], [2, 5, 8], [3, 6, 9], ['-', 6.1, '-'], ['-', 6.2, '-'], ['-', 6.3, '-']]

six.moves.zip_longest() हो जाता है

• itertools.izip_longest() अजगर 2 में
• itertools.zip_longest() पायथन 3 में

डिफ़ॉल्ट भरण है None। @ जेना के जवाब के लिए धन्यवाद , जहां map()आंतरिक ट्यूपल्स को सूचियों में बदल रहा है। यहाँ यह पुनरावृत्तियों को सूचियों में बदल रहा है। @ Oregano's और @ badp की टिप्पणियों के लिए धन्यवाद ।

पायथन 3 में, list()विधि 2 के समान 2 डी सूची प्राप्त करने के लिए परिणाम पास करें ।

---

विधि 2 - सूची समझ, zip_longest()

>>> [list(row) for row in six.moves.zip_longest(*list_list, fillvalue='-')]
[[1, 4, 7], [2, 5, 8], [3, 6, 9], ['-', 6.1, '-'], ['-', 6.2, '-'], ['-', 6.3, '-']]

@ InspectorG4dget विकल्प ।

---

विधि 3 - map()की map()- अजगर 3.6 में टूट

>>> map(list, map(None, *list_list))
[[1, 4, 7], [2, 5, 8], [3, 6, 9], [None, 6.1, None], [None, 6.2, None], [None, 6.3, None]]

यह असाधारण रूप से कॉम्पैक्ट @SiggyF रैग्ड 2 डी सूचियों के साथ दूसरा वैकल्पिक काम करता है, अपने पहले कोड के विपरीत जो रागी सूचियों के माध्यम से स्थानांतरित करने और गुजरने के लिए संख्यात्मक उपयोग करता है। लेकिन कोई भी भरण मूल्य नहीं है। (नहीं, कोई भी आंतरिक मानचित्र में पारित नहीं हुआ है) (भरण मूल्य नहीं है। इसका अर्थ है कि प्रत्येक स्तंभ को संसाधित करने का कोई कार्य नहीं है। स्तंभों को केवल बाहरी मानचित्र के माध्यम से पारित किया जाता है) जो उन्हें ट्यूल से सूचियों में परिवर्तित करता है।

कहीं पायथन 3 में, map()यह सब दुरुपयोग के साथ बंद कर दिया: पहला पैरामीटर कोई भी नहीं हो सकता है, और दांतेदार पुनरावृत्तियों को केवल सबसे छोटा किया जाता है। अन्य विधियां अभी भी काम करती हैं क्योंकि यह केवल आंतरिक मानचित्र () पर लागू होती है।

---

विधि 4 - map()की map()दोबारा गौर

>>> list(map(list, map(lambda *args: args, *list_list)))
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]   // Python 2.7
[[1, 4, 7], [2, 5, 8], [3, 6, 9], [None, 6.1, None], [None, 6.2, None], [None, 6.3, None]] // 3.6+

काश रैग्ड पंक्तियाँ पायथन 3 में रैग्ड कॉलम नहीं बनतीं, उन्हें केवल काट दिया जाता है। बूआ हू प्रगति।

Answer 6

से चुनने के लिए तीन विकल्प:

1. ज़िप के साथ नक्शा

solution1 = map(list, zip(*l))

2. सूची की समझ

solution2 = [list(i) for i in zip(*l)]

3. लूप अप्लाईिंग के लिए

solution3 = []
for i in zip(*l):
    solution3.append((list(i)))

और परिणाम देखने के लिए:

print(*solution1)
print(*solution2)
print(*solution3)

# [1, 4, 7], [2, 5, 8], [3, 6, 9]

Answer 7

शायद सबसे सुरुचिपूर्ण समाधान नहीं है, लेकिन यहाँ छोरों का उपयोग करते समय एक समाधान है:

def transpose(lst):
    newlist = []
    i = 0
    while i < len(lst):
        j = 0
        colvec = []
        while j < len(lst):
            colvec.append(lst[j][i])
            j = j + 1
        newlist.append(colvec)
        i = i + 1
    return newlist

Answer 8

import numpy as np
r = list(map(list, np.transpose(l)))

Answer 9

more_itertools.unzip() पढ़ने में आसान है, और यह जनरेटर के साथ भी काम करता है।

import more_itertools
l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
r = more_itertools.unzip(l) # a tuple of generators.
r = list(map(list, r))      # a list of lists

या समकक्ष

import more_itertools
l = more_itertools.chunked(range(1,10), 3)
r = more_itertools.unzip(l) # a tuple of generators.
r = list(map(list, r))      # a list of lists

Answer 10

यहाँ उन सूचियों की सूची को प्रस्तुत करने का एक समाधान है जो आवश्यक रूप से वर्गाकार नहीं हैं:

maxCol = len(l[0])
for row in l:
    rowLength = len(row)
    if rowLength > maxCol:
        maxCol = rowLength
lTrans = []
for colIndex in range(maxCol):
    lTrans.append([])
    for row in l:
        if colIndex < len(row):
            lTrans[colIndex].append(row[colIndex])

Answer 11

    #Import functions from library
    from numpy import size, array
    #Transpose a 2D list
    def transpose_list_2d(list_in_mat):
        list_out_mat = []
        array_in_mat = array(list_in_mat)
        array_out_mat = array_in_mat.T
        nb_lines = size(array_out_mat, 0)
        for i_line_out in range(0, nb_lines):
            array_out_line = array_out_mat[i_line_out]
            list_out_line = list(array_out_line)
            list_out_mat.append(list_out_line)
        return list_out_mat