एक फ्लैट सूची या एक मैट्रिक्स में "ट्यूपल्स की सूची" बदलें

Question 1

Sqlite के साथ, एक "select..from" कमांड परिणाम "आउटपुट" देता है, जो प्रिंट करता है (अजगर में):

>>print output
[(12.2817, 12.2817), (0, 0), (8.52, 8.52)]

यह ट्यूपल्स की एक सूची प्रतीत होती है। मैं या तो "आउटपुट" को एक साधारण 1D सरणी में बदलना चाहता हूं (= पायथन में सूची मुझे लगता है):

[12.2817, 12.2817, 0, 0, 8.52, 8.52]

या एक 2x3 मैट्रिक्स:

12.2817 12.2817
0          0 
8.52     8.52

"आउटपुट [i] [j] के माध्यम से पढ़ने के लिए

सपाट कमांड 1 विकल्प के लिए काम नहीं करता है, और मुझे दूसरे के लिए कोई विचार नहीं है ... :)

क्या आप मुझे संकेत दे सकते हैं? कुछ चीजें तेजी से महान होंगी क्योंकि असली डेटा बहुत बड़ा है (यहां सिर्फ एक सरल उदाहरण है)।

Question 2

अब तक का सबसे तेज़ (और सबसे छोटा) समाधान पोस्ट किया गया:

list(sum(output, ()))

itertoolsसमाधान की तुलना में लगभग 50% तेज , और समाधान की तुलना में लगभग 70% तेज map।

Question 3

सूची समझ दृष्टिकोण जो Iterable प्रकार के साथ काम करता है और यहां दिखाए गए अन्य तरीकों से तेज है।

flattened = [item for sublist in l for item in sublist]

lसमतल करने के लिए सूची है ( outputओपी के मामले में कहा जाता है)

समय परीक्षण:

l = list(zip(range(99), range(99)))  # list of tuples to flatten

सूची की समझ

[item for sublist in l for item in sublist]

समय परिणाम = 7.67 ±s result 129 ns प्रति लूप

सूची विस्तार () विधि

flattened = []
list(flattened.extend(item) for item in l)

timeit परिणाम = 11 µs result 433 ns प्रति लूप

योग ()

list(sum(l, ()))

timeit परिणाम = 24.2 ±s result 269 ns प्रति लूप

Question 4

पायथन 2.7, और पायथन 3 के सभी संस्करणों में, आप itertools.chainपुनरावृत्तियों की एक सूची को समतल करने के लिए उपयोग कर सकते हैं । या तो *वाक्य रचना या वर्ग विधि के साथ।

>>> t = [ (1,2), (3,4), (5,6) ]
>>> t
[(1, 2), (3, 4), (5, 6)]
>>> import itertools
>>> list(itertools.chain(*t))
[1, 2, 3, 4, 5, 6]
>>> list(itertools.chain.from_iterable(t))
[1, 2, 3, 4, 5, 6]

Question 5

अद्यतन : विस्तार का उपयोग किए बिना समतल लेकिन बिना समझ के और सूची के रूप में उपयोग किए बिना (सबसे तेज़)

इसके बाद अगले उत्तर की जाँच करने के बाद, जो कि dual forमैंने थोड़ा ट्वीक किया था, और अब बेहतर प्रदर्शन करता है, सूची के माध्यम से तेजी से समाधान प्रदान किया है, पहले सूची का निष्पादन (...) समय का एक बड़ा प्रतिशत खींच रहा था, फिर एक सूची बदल रहा है एक साधारण लूप के लिए समझ थोड़ी और अधिक मुंडा।

नया समाधान है:

l = []
for row in output: l.extend(row)

पुराना:

नक्शा / विस्तार के साथ चपटा:

l = []
list(map(l.extend, output))

नक्शे के बजाय सूची की समझ के साथ चपटा होना

l = []
list(l.extend(row) for row in output)

नए विस्तार के लिए कुछ समय और सुधार केवल [...] के लिए सूची (...) को हटाकर:

import timeit
t = timeit.timeit
o = "output=list(zip(range(1000000000), range(10000000))); l=[]"
steps_ext = "for row in output: l.extend(row)"
steps_ext_old = "list(l.extend(row) for row in output)"
steps_ext_remove_list = "[l.extend(row) for row in output]"
steps_com = "[item for sublist in output for item in sublist]"

print("new extend:      ", t(steps_ext, setup=o, number=10))
print("old extend w []: ", t(steps_ext_remove_list, setup=o, number=10))
print("comprehension:   ", t(steps_com, setup=o, number=10,))
print("old extend:      ", t(steps_ext_old, setup=o, number=10))

>>> new extend:       4.502427191007882
>>> old extend w []:  5.281140706967562
>>> comprehension:    5.54302118299529
>>> old extend:       6.840151469223201

Question 6

उपयोग itertoolsश्रृंखला:

>>> import itertools
>>> list(itertools.chain.from_iterable([(12.2817, 12.2817), (0, 0), (8.52, 8.52)]))
[12.2817, 12.2817, 0, 0, 8.52, 8.52]

Question 7

>>> flat_list = []
>>> nested_list = [(1, 2, 4), (0, 9)]
>>> for a_tuple in nested_list:
...     flat_list.extend(list(a_tuple))
... 
>>> flat_list
[1, 2, 4, 0, 9]
>>>

आप आसानी से ऊपर दिखाए गए अनुसार टपल की सूची से एकल सूची में जा सकते हैं।

Question 8

या आप इस तरह सूची को समतल कर सकते हैं:

reduce(lambda x,y:x+y, map(list, output))

Question 9

यह वह है जो numpyदोनों के लिए एक डेटा संरचनाओं से बनाया गया था, साथ ही साथ गति परिप्रेक्ष्य भी।

import numpy as np

output = [(12.2817, 12.2817), (0, 0), (8.52, 8.52)]
output_ary = np.array(output)   # this is your matrix 
output_vec = output_ary.ravel() # this is your 1d-array

Question 10

मनमानी नेस्टेड सूचियों के मामले में (बस मामले में):

def flatten(lst):
    result = []
    for element in lst: 
        if hasattr(element, '__iter__'):
            result.extend(flatten(element))
        else:
            result.append(element)
    return result

>>> flatten(output)
[12.2817, 12.2817, 0, 0, 8.52, 8.52]