सूचियों की सूची से बाहर एक फ्लैट सूची कैसे बनाएं?

Question

मुझे आश्चर्य है कि पायथन में सूचियों की सूची से बाहर एक सरल सूची बनाने के लिए कोई शॉर्टकट है या नहीं।

मैं एक forपाश में ऐसा कर सकता हूं , लेकिन शायद कुछ अच्छा "वन-लाइनर" है? मैंने इसके साथ प्रयास किया reduce(), लेकिन मुझे एक त्रुटि मिली।

कोड

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
reduce(lambda x, y: x.extend(y), l)

त्रुटि संदेश

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <lambda>
AttributeError: 'NoneType' object has no attribute 'extend'

Comments

इसमें यहाँ की गहन चर्चा है: rightfootin.blogspot.com/2006/09/more-on-python-flatten.html , सूचियों की मनमाने ढंग से नेस्टेड सूची को समतल करने के कई तरीकों पर चर्चा करना। एक दिलचस्प पढ़ा!

— रिचीहिंडले

कुछ अन्य उत्तर बेहतर हैं लेकिन आपके असफल होने का कारण यह है कि 'विस्तार' विधि हमेशा कोई भी नहीं लौटाती है। लंबाई 2 वाली सूची के लिए, यह काम करेगा लेकिन वापस नहीं। लंबी सूची के लिए, यह पहले 2 आर्गों का उपभोग करेगा, जो कि कोई नहीं लौटाता है। यह तो None.extend (<तीसरे आर्ग>) है, जो इस erro का कारण बनता है के साथ जारी है

— mehtunguh

@ शॉन-चिन समाधान यहां अधिक पाइथोनिक है, लेकिन यदि आपको अनुक्रम प्रकार को संरक्षित करने की आवश्यकता है, तो कहें कि आपके पास सूचियों की सूची के बजाय ट्यूपल्स का एक टपल है, तो आपको कम करना चाहिए (ऑपरेटर। कॉनकट, tuple_of_tuples)। ट्यूपल्स के साथ ऑपरेटर.कॉन्केट का उपयोग करना चेन के साथ तेजी से प्रदर्शन करना प्रतीत होता है। सूची के साथ फेरोमेटराइटर।

— मीथम

Answer 1

सूचियों की एक सूची दी l,

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

जिसका मतलब है:

flat_list = []
for sublist in l:
    for item in sublist:
        flat_list.append(item)

अब तक पोस्ट किए गए शॉर्टकट से अधिक तेज़ है। ( lसमतल करने के लिए सूची है।)

यहाँ इसी समारोह है:

flatten = lambda l: [item for sublist in l for item in sublist]

सबूत के रूप में, आप timeitमानक पुस्तकालय में मॉड्यूल का उपयोग कर सकते हैं :

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 143 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 969 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 3: 1.1 msec per loop

स्पष्टीकरण: आवश्यकता पर आधारित +(जब निहित उपयोग सहित sum) शॉर्टकट हैं, O(L**2)जब एल उप-कलाकार होते हैं - जैसे कि मध्यवर्ती परिणाम सूची लंबे समय तक बनी रहती है, प्रत्येक चरण पर एक नया मध्यवर्ती परिणाम सूची ऑब्जेक्ट आवंटित किया जाता है, और सभी आइटम पिछले मध्यवर्ती परिणाम में (साथ ही अंत में कुछ नए जोड़े गए) पर कॉपी किया जाना चाहिए। तो, सादगी के लिए और सामान्यता के वास्तविक नुकसान के बिना, मान लें कि आपके पास I आइटम के एल सब्लिस्ट हैं: पहले I आइटम को कॉपी किया जाता है L-1 बार, दूसरा I आइटम L-2 बार, और इसी तरह; प्रतियों की कुल संख्या I है x के लिए x से 1 से L तक x का योग है, अर्थात I * (L**2)/2।

सूची की समझ बस एक सूची उत्पन्न करती है, एक बार, और प्रत्येक आइटम को उसके निवास स्थान से (परिणाम सूची के लिए) बिल्कुल एक बार कॉपी करती है।

Comments

मैं एक ही डेटा के साथ एक परीक्षण की कोशिश की, का उपयोग करते हुए itertools.chain.from_iterable: $ python -mtimeit -s'from itertools import chain; l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'list(chain.from_iterable(l))'। यह नेस्टेड लिस्ट कॉम्प्रिहेंशन के मुकाबले दोगुना से ज्यादा तेज चलता है जो कि यहां दिखाए गए विकल्पों में से सबसे तेज है।

— intuited

मुझे यह समझने में मुश्किल सिंटैक्स मिला जब तक कि मुझे एहसास नहीं हुआ कि आप इसके बारे में सोच सकते हैं जैसे छोरों के लिए नेस्टेड है। l में सबलिस्ट के लिए: सबलिस्ट में आइटम के लिए: उपज आइटम

— रोब क्रॉवेल

@BorisChervenkov: ध्यान दें कि मैंने पुनरावृत्ति list()को एक सूची में महसूस करने के लिए कॉल को लपेट दिया ।

— intuited

[पेड़ में पत्ती के लिए जंगल में पेड़ के लिए पत्ती] समझना और लागू करना आसान हो सकता है।

— जॉन मी

@ योएल, वास्तव में आजकल list(itertools.chain.from_iterable(l))सबसे अच्छा है - जैसा कि अन्य टिप्पणियों और शॉन के जवाब में देखा गया है।

— एलेक्स मार्टेली

Answer 2

आप उपयोग कर सकते हैं itertools.chain():

import itertools
list2d = [[1,2,3], [4,5,6], [7], [8,9]]
merged = list(itertools.chain(*list2d))

या आप ऑपरेटर केitertools.chain.from_iterable() साथ सूची को अनपैक करने की आवश्यकता नहीं कर सकते हैं :*

import itertools
list2d = [[1,2,3], [4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

Comments

*मुश्किल बात यह है कि बनाता है chainसूची समझ से भी कम समय सीधा। आपको यह जानना होगा कि श्रृंखला केवल मापदंडों के रूप में पारित होने वाले पुनरावृत्तियों में शामिल होती है, और * शीर्ष-स्तरीय सूची को मापदंडों में विस्तारित करने का कारण बनता है, इसलिए chainउन सभी पुनरावृत्तियों में एक साथ जुड़ता है, लेकिन आगे नहीं उतरता है। मुझे लगता है कि यह इस मामले में श्रृंखला के उपयोग से समझ को अधिक पठनीय बनाता है।

— टिम डायरक्स

@ टिममरिक्स: मुझे यकीन नहीं है "यह आपको पायथन सिंटैक्स को समझने की आवश्यकता है" पायथन में दी गई तकनीक का उपयोग करने के खिलाफ एक तर्क है। निश्चित रूप से, जटिल उपयोग भ्रमित कर सकता है, लेकिन "स्पैट" ऑपरेटर आमतौर पर कई परिस्थितियों में उपयोगी होता है, और यह इसका उपयोग विशेष रूप से अस्पष्ट तरीके से नहीं करता है; सभी भाषा सुविधाओं को अस्वीकार करना जो उपयोगकर्ताओं को शुरू करने के लिए आवश्यक रूप से स्पष्ट नहीं हैं, इसका मतलब है कि आप अपनी पीठ के पीछे एक हाथ बांध रहे हैं। जब आप इस पर हों तब भी सूची की समझ को फेंक दें; अन्य पृष्ठभूमि के उपयोगकर्ताओं को एक forलूप मिलेगा जो बार-बार appendअधिक स्पष्ट होता है।

— शैडो रेंजर

यह उत्तर, और अन्य उत्तर यहां, गलत परिणाम देते हैं यदि शीर्ष स्तर में भी एक मूल्य होता है। उदाहरण के लिए, के list = [["abc","bcd"],["cde","def"],"efg"]परिणाम में होगा["abc", "bcd", "cde", "def", "e", "f", "g"].

— gouravkr

Answer 3

लेखक से ध्यान दें : यह अक्षम है। लेकिन मज़ा, क्योंकि monoids भयानक हैं। यह उत्पादन पायथन कोड के लिए उपयुक्त नहीं है।

>>> sum(l, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

यह सिर्फ पहली दलील में पास किए गए चलने योग्य तत्वों को शामिल करता है, दूसरे तर्क को योग के प्रारंभिक मूल्य के रूप में मानता है (यदि नहीं दिया गया है, तो 0इसके बजाय इसका उपयोग किया जाता है और यह मामला आपको एक त्रुटि देगा)।

क्योंकि आप नेस्टेड सूचियों को समेट रहे हैं, आप वास्तव [1,3]+[2,4]में इसके परिणामस्वरूप प्राप्त करते हैं sum([[1,3],[2,4]],[]), जो कि बराबर है [1,3,2,4]।

ध्यान दें कि केवल सूचियों की सूची पर काम करता है। सूचियों की सूचियों की सूची के लिए, आपको एक और समाधान की आवश्यकता होगी।

Comments

यह बहुत साफ और चालाक है, लेकिन मैं इसका उपयोग नहीं करूंगा क्योंकि यह पढ़ने के लिए भ्रमित है।

— andrrk

यह एक Shlemiel चित्रकार के एल्गोरिथ्म joelonsoftware.com/articles/fog0000000319.html - अनावश्यक रूप से अक्षम होने के साथ-साथ अनावश्यक रूप से बदसूरत है।

— माइक ग्राहम

सूचियों पर परिशिष्ट ऑपरेशन एक बनाता है Monoid, जो +सामान्य अर्थों में एक ऑपरेशन के बारे में सोचने के लिए सबसे सुविधाजनक सार है (केवल संख्याओं तक सीमित नहीं है)। तो यह जवाब मेरे लिए एक मोनोड के रूप में सूचियों के (सही) उपचार के लिए +1 योग्य है। प्रदर्शन हालांकि से संबंधित है ...

— ulidtko

@andrewrk खैर, कुछ लोगों को लगता है कि यह करने का सबसे साफ तरीका है: youtube.com/watch?v=IOiZatlZtGU जिन लोगों को यह नहीं मिलता है, उन्हें शांत रहने के लिए कुछ दशकों तक इंतजार करना पड़ता है जब तक कि हर कोई इस तरह से काम न करे: ) आइए उन प्रोग्रामिंग भाषाओं (और अमूर्तताओं) का उपयोग करें जिन्हें खोजा गया है और उनका आविष्कार नहीं किया गया है, मोनॉयड की खोज की गई है।

— jhegedus 8

यह राशि के द्विघात पहलू के कारण बहुत ही अक्षम तरीका है।

— जीन-फ्रांस्वा फेबरे

Answer 4

मैंने परफ्लोट (मेरा एक पालतू प्रोजेक्ट, अनिवार्य रूप से एक आवरण के आसपास timeit) के साथ सबसे अधिक सुझाए गए समाधानों का परीक्षण किया , और पाया

functools.reduce(operator.iconcat, a, [])

सबसे तेज़ समाधान, दोनों जब कई छोटी सूचियाँ और कुछ लंबी सूचियाँ समवर्ती हों। ( operator.iaddसमान रूप से तेज़ है।)

---

प्लॉट को फिर से तैयार करने के लिए कोड:

import functools
import itertools
import numpy
import operator
import perfplot


def forfor(a):
    return [item for sublist in a for item in sublist]


def sum_brackets(a):
    return sum(a, [])


def functools_reduce(a):
    return functools.reduce(operator.concat, a)


def functools_reduce_iconcat(a):
    return functools.reduce(operator.iconcat, a, [])


def itertools_chain(a):
    return list(itertools.chain.from_iterable(a))


def numpy_flat(a):
    return list(numpy.array(a).flat)


def numpy_concatenate(a):
    return list(numpy.concatenate(a))


perfplot.show(
    setup=lambda n: [list(range(10))] * n,
    # setup=lambda n: [list(range(n))] * 10,
    kernels=[
        forfor,
        sum_brackets,
        functools_reduce,
        functools_reduce_iconcat,
        itertools_chain,
        numpy_flat,
        numpy_concatenate,
    ],
    n_range=[2 ** k for k in range(16)],
    xlabel="num lists (of length 10)",
    # xlabel="len lists (10 lists total)"
)

Comments

विशाल नेस्टेड सूचियों के लिए, 'लिस्ट (numpy.array (a) .flat)' उपरोक्त सभी कार्यों में सबसे तेज़ है।

— सारा

रेगेक्स का उपयोग करने की कोशिश की गई: 'सूची (नक्शा (इंट, रि.फ़ंड) (आर "[\ w] +", str (a)))'। स्पीड थोड़ी धीमी है कि numpy_concatenate

— Justas

वहाँ एक रास्ता 3-डी perfplot करने के लिए है? सरणी के औसत आकार द्वारा सरणियों की संख्या?

— सिंह

मुझे आपके समाधान से प्यार है। लघु, सरल और कुशल :-)

— ShadyMBA

Answer 5

from functools import reduce #python 3

>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(lambda x,y: x+y,l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

extend()अपने उदाहरण में विधि को संशोधित करता है xबजाय एक उपयोगी मूल्य लौटने का (जोreduce() उम्मीद है)।

reduceसंस्करण करने का एक तेज़ तरीका होगा

>>> import operator
>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(operator.concat, l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Comments

reduce(operator.add, l)reduceसंस्करण करने का सही तरीका होगा । अंतर्निर्मित लैम्बदास से तेज हैं।

— एजीएफ

@agf यहाँ है: * timeit.timeit('reduce(operator.add, l)', 'import operator; l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]', number=10000) 0.017956018447875977 * timeit.timeit('reduce(lambda x, y: x+y, l)', 'import operator; l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]', number=10000) 0.025218963623046875

— lukmdo

यह एक Shlemiel चित्रकार की एल्गोरिथ्म joelonsoftware.com/articles/fog0000000319.html

— माइक ग्राहम

यह केवल के लिए उपयोग कर सकते हैं integers। लेकिन क्या होगा अगर सूची में शामिल है string?

— फ्रेडी

@Freddy: operator.addपूर्णांक और स्ट्रिंग्स की सूची दोनों के लिए फ़ंक्शन समान रूप से अच्छी तरह से काम करता है।

— ग्रेग हेविगिल

Answer 6

यदि आप Django का उपयोग करते हैं तो पहिया को फिर से न करें :

>>> from django.contrib.admin.utils import flatten
>>> l = [[1,2,3], [4,5], [6]]
>>> flatten(l)
>>> [1, 2, 3, 4, 5, 6]

... पंडों :

>>> from pandas.core.common import flatten
>>> list(flatten(l))

... Itertools :

>>> import itertools
>>> flatten = itertools.chain.from_iterable
>>> list(flatten(l))

... माटप्लोटलिब

>>> from matplotlib.cbook import flatten
>>> list(flatten(l))

... यूनिपथ :

>>> from unipath.path import flatten
>>> list(flatten(l))

... सेटपूल :

>>> from setuptools.namespaces import flatten
>>> list(flatten(l))

Comments

flatten = itertools.chain.from_iterableसही उत्तर होना चाहिए

— geckos

बहुत बढ़िया जवाब! एल के लिए भी काम करता है = [[१, २, ३], [४, ५]], ५] पंडों के मामले में

— मार्कस डट्सचके

मुझे पंडों का हल पसंद है। आप की तरह कुछ है: list_of_menuitems = [1, 2, [3, [4, 5, [6]]]]उस पर परिणाम होगा: [1, 2, 3, 4, 5, 6]। मुझे जो याद है वह समतल स्तर है।

— imjoseangel

Answer 7

यहां एक सामान्य दृष्टिकोण है जो संख्याओं , तारों , नेस्टेड सूचियों और मिश्रित कंटेनरों पर लागू होता है ।

कोड

#from typing import Iterable 
from collections import Iterable                            # < py38


def flatten(items):
    """Yield items from any nested iterable; see Reference."""
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            for sub_x in flatten(x):
                yield sub_x
        else:
            yield x

नोट :

• पायथन 3 में, yield from flatten(x)प्रतिस्थापित कर सकता हैfor sub_x in flatten(x): yield sub_x
• अजगर 3.8 में, सार आधार वर्ग कर रहे हैं ले जाया गया से collection.abcकरने के लिए typingमॉड्यूल।

डेमो

lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(flatten(lst))                                         # nested lists
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

mixed = [[1, [2]], (3, 4, {5, 6}, 7), 8, "9"]              # numbers, strs, nested & mixed
list(flatten(mixed))
# [1, 2, 3, 4, 5, 6, 7, 8, '9']

संदर्भ

• इस समाधान को एक नुस्खा से संशोधित किया गया है बेज़ले, डी और बी जोन्स । पकाने की विधि 4.14, पायथन कुकबुक 3 एड।, ओ रेली मीडिया इंक। सेबेस्टोपोल, सीए: 2013।
• पहले एसओ पद मिला , मूल प्रदर्शन।

Comments

मैंने अभी बहुत अधिक वही लिखा है, क्योंकि मैंने आपका समाधान नहीं देखा है ... यहाँ मैंने "पुनरावृत्ति पूर्ण रूप से कई सूचियों को समतल करने के लिए देखा" ... (+1)

— मार्टिन थोमा

@MartinThoma बहुत सराहना की। FYI करें, यदि सपाट नेस्टेड iterables आपके लिए एक सामान्य अभ्यास है, तो कुछ तृतीय-पक्ष पैकेज हैं जो इसे अच्छी तरह से संभालते हैं। इससे पहिए को फिर से लगने से बचाया जा सकता है। मैंने more_itertoolsइस पोस्ट में चर्चा किए गए अन्य लोगों के बीच उल्लेख किया है । चीयर्स।

— पाइलैंग

शायद traverseपेड़ के इस तरीके का एक अच्छा नाम हो सकता है, जबकि मैं इस सूची के लिए नेस्टेड सूचियों पर चिपकाकर इसे कम सार्वभौमिक रखूंगा।

— वुल्फ

आप if hasattr(x, '__iter__')आयात करने / जाँच करने के बजाय जाँच कर सकते हैं Iterableऔर यह तार को भी बाहर कर देगा।

— रायन एलन

उपरोक्त कोड के लिए काम करने के लिए प्रतीत होता है अगर नेस्टेड सूची में से एक तार की सूची है। [1, 2, [3, 4], [4], [], 9, 9.5, 'ssssss', ['str', 'sss', 'ss'], [3, 4, 5]] आउटपुट: - [1, 2, 3, 4, 4, 9, 9.5, 'ssssss', 3, 4, 5]

— sunXX

Answer 8

यदि आप एक डेटा-संरचना को समतल करना चाहते हैं, जहां आपको पता नहीं है कि यह कितना गहरा है तो आप ^{1 का} उपयोग कर सकते हैंiteration_utilities.deepflatten

>>> from iteration_utilities import deepflatten

>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(deepflatten(l, depth=1))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> l = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
>>> list(deepflatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

यह एक जनरेटर है जिससे आपको परिणाम को listस्पष्ट रूप से डालना होगा या स्पष्ट रूप से उस पर पुनरावृति करना होगा।

---

केवल एक स्तर को समतल करने के लिए और यदि प्रत्येक आइटम स्वयं ही चलने योग्य है, तो आप इसका उपयोग भी कर सकते हैं, iteration_utilities.flattenजो स्वयं के चारों ओर एक पतली आवरण है itertools.chain.from_iterable:

>>> from iteration_utilities import flatten
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(flatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

---

बस कुछ समय जोड़ने के लिए (निको श्लोमर के उत्तर के आधार पर जो इस उत्तर में प्रस्तुत समारोह में शामिल नहीं थे):

यह एक लॉग-लॉग प्लॉट है, जिसमें फैले मूल्यों की विशाल श्रृंखला को समायोजित किया जाता है। गुणात्मक तर्क के लिए: निचला बेहतर है।

परिणाम दिखाते हैं कि यदि चलने योग्य में केवल कुछ आंतरिक पुनरावृत्तियाँ हैं, तो sumसबसे तेज़ होगा, हालाँकि लंबे पुनरावृत्तियों के लिए केवल itertools.chain.from_iterable, iteration_utilities.deepflattenया नेस्टेड समझ itertools.chain.from_iterableमें सबसे तेज़ प्रदर्शन होता है (जैसा कि पहले से ही निको श्लोमर द्वारा देखा गया है)।

from itertools import chain
from functools import reduce
from collections import Iterable  # or from collections.abc import Iterable
import operator
from iteration_utilities import deepflatten

def nested_list_comprehension(lsts):
    return [item for sublist in lsts for item in sublist]

def itertools_chain_from_iterable(lsts):
    return list(chain.from_iterable(lsts))

def pythons_sum(lsts):
    return sum(lsts, [])

def reduce_add(lsts):
    return reduce(lambda x, y: x + y, lsts)

def pylangs_flatten(lsts):
    return list(flatten(lsts))

def flatten(items):
    """Yield items from any nested iterable; see REF."""
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            yield from flatten(x)
        else:
            yield x

def reduce_concat(lsts):
    return reduce(operator.concat, lsts)

def iteration_utilities_deepflatten(lsts):
    return list(deepflatten(lsts, depth=1))


from simple_benchmark import benchmark

b = benchmark(
    [nested_list_comprehension, itertools_chain_from_iterable, pythons_sum, reduce_add,
     pylangs_flatten, reduce_concat, iteration_utilities_deepflatten],
    arguments={2**i: [[0]*5]*(2**i) for i in range(1, 13)},
    argument_name='number of inner lists'
)

b.plot()

---

^{1 अस्वीकरण: मैं उस पुस्तकालय का लेखक हूं}

Comments

sumअब मनमाना क्रमों पर काम नहीं करता है क्योंकि यह शुरू होता है 0, functools.reduce(operator.add, sequences)प्रतिस्थापन बना रहा है (क्या हमें खुशी नहीं है कि वे निर्माण से हटाए reduceगए हैं?)। जब प्रकार ज्ञात होते हैं तो यह उपयोग करने के लिए तेज़ हो सकता है type.__add__।

— यान वर्नियर

@YannVernier जानकारी के लिए धन्यवाद। मुझे लगा कि मैंने पायथन 3.6 पर इन बेंचमार्क को चलाया और इसके साथ काम किया sum। क्या आपको पता है कि किस पायथन संस्करण ने काम करना बंद कर दिया है?

— MSeifert

मैं कुछ गलत था। 0बस डिफ़ॉल्ट प्रारंभिक मूल्य है, इसलिए यह काम करता है यदि कोई खाली सूची के साथ शुरू करने के लिए प्रारंभ तर्क का उपयोग करता है ... लेकिन यह अभी भी विशेष मामलों को तार करता है और मुझे जुड़ने का उपयोग करने के लिए कहता है। इसके foldlबजाय लागू हो रहा है foldl1। 2.7 में एक ही समस्या पॉप अप होती है।

— यान वर्नियर

Answer 9

मैं अपना बयान वापस लेता हूं। योग विजेता नहीं है। हालाँकि यह छोटी है जब सूची छोटी है। लेकिन प्रदर्शन बड़ी सूची के साथ काफी कम हो जाता है।

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10000'
    ).timeit(100)
2.0440959930419922

योग संस्करण अभी भी एक मिनट से अधिक समय से चल रहा है और इसने अभी तक प्रसंस्करण नहीं किया है!

मध्यम सूचियों के लिए:

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
20.126545906066895
>>> timeit.Timer(
        'reduce(lambda x,y: x+y,l)',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
22.242258071899414
>>> timeit.Timer(
        'sum(l, [])',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
16.449732065200806

छोटी सूचियों और समय का उपयोग करना: संख्या = 1000000

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
2.4598159790039062
>>> timeit.Timer(
        'reduce(lambda x,y: x+y,l)',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
1.5289170742034912
>>> timeit.Timer(
        'sum(l, [])',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
1.0598428249359131

Comments

वास्तव में एक छोटी सी सूची के लिए, उदाहरण के लिए 3 उपविदों के साथ एक, हो सकता है - लेकिन चूंकि योग का प्रदर्शन ओ (एन ** 2) के साथ जाता है, जबकि सूची की समझ ओ (एन) के साथ जाती है, बस इनपुट सूची बढ़ने से चीजें थोड़ी उलट हो जाएंगी - - वास्तव में नियंत्रण रेखा सीमा की तुलना में "अनंत रूप से तेज" होगी क्योंकि एन बढ़ता है। मैं योग को डिजाइन करने और पायथन रनटाइम में इसका पहला कार्यान्वयन करने के लिए ज़िम्मेदार था, और मैं अभी भी चाहता हूं कि मुझे संख्याओं को समेटने के लिए इसे प्रभावी रूप से प्रतिबंधित करने का एक तरीका मिल गया है (यह वास्तव में अच्छा क्या है) और "आकर्षक उपद्रव" को ब्लॉक करने के लिए यह लोगों को प्रदान करता है जो "योग" सूचियाँ चाहते हैं ;-)।

— एलेक्स मार्टेली

Answer 10

के साथ एक भ्रम होने लगता है operator.add! जब आप दो सूचियों को एक साथ जोड़ते हैं, तो उसके लिए सही शब्द है concat, जोड़ नहीं।operator.concatवह है जो आपको उपयोग करने की आवश्यकता है।

यदि आप कार्यात्मक सोच रहे हैं, तो यह आसान है ::

>>> from functools import reduce
>>> list2d = ((1, 2, 3), (4, 5, 6), (7,), (8, 9))
>>> reduce(operator.concat, list2d)
(1, 2, 3, 4, 5, 6, 7, 8, 9)

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

>>> list2d = [[1, 2, 3],[4, 5, 6], [7], [8, 9]]
>>> reduce(operator.concat, list2d)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

अहा, आपको एक सूची वापस मिलती है।

प्रदर्शन के बारे में कैसे ::

>>> list2d = [[1, 2, 3],[4, 5, 6], [7], [8, 9]]
>>> %timeit list(itertools.chain.from_iterable(list2d))
1000000 loops, best of 3: 1.36 µs per loop

from_iterableबहुत तेज़ है! लेकिन इसके साथ कोई तुलना नहीं है concat।

>>> list2d = ((1, 2, 3),(4, 5, 6), (7,), (8, 9))
>>> %timeit reduce(operator.concat, list2d)
1000000 loops, best of 3: 492 ns per loop

Comments

हम्म निष्पक्ष होने के लिए दूसरा उदाहरण भी सूची होना चाहिए (या पहले टपल?)

— Mr_and_Mrs_D

इस तरह के छोटे इनपुट का उपयोग करना काफी हद तक सही नहीं है। लंबाई 1000 के 1000 अनुक्रमों के लिए, मुझे 0.037 सेकंड list(chain.from_iterable(...))और 2.5 सेकंड के लिए मिलता है reduce(concat, ...)। समस्या यह है कि reduce(concat, ...)द्विघात रनटाइम है, जबकि chainरैखिक है।

— काया 3

Answer 11

आप एक्सटेंशन का उपयोग क्यों करते हैं?

reduce(lambda x, y: x+y, l)

यह ठीक काम करना चाहिए।

Comments

के लिए python3from functools import reduce

— andorov

क्षमा करें कि वास्तव में धीमी गति से शेष उत्तर

— मिलते हैं

यह पाइथन 2 पर काम करने वाले अभी तक के सबसे छोटे समाधानों को समझने में सबसे आसान है और 3. मुझे एहसास है कि बहुत सारे पायथन लोग डेटा प्रोसेसिंग में हैं, जहां डेटा की बड़ी मात्रा में प्रक्रिया होती है और इस प्रकार गति के बारे में बहुत परवाह होती है, लेकिन जब आप एक शेल स्क्रिप्ट लिख रहे हैं और केवल कुछ उप-सूचियों में कुछ दर्जन तत्व हैं, तो यह एकदम सही है।

— असफंद काजी

Answer 12

more_itertoolsपैकेज स्थापित करने पर विचार करें ।

> pip install more_itertools

यह flatten( इटर्स्टूल व्यंजनों से स्रोत ) के कार्यान्वयन के साथ जहाज :

import more_itertools


lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(more_itertools.flatten(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

संस्करण 2.4 के रूप में, आप अधिक जटिल, नेस्टेड iterables के साथ समतल कर सकते हैं more_itertools.collapse( स्रोत , abarnet द्वारा योगदान)।

lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(more_itertools.collapse(lst)) 
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

lst = [[1, 2, 3], [[4, 5, 6]], [[[7]]], 8, 9]              # complex nesting
list(more_itertools.collapse(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Comments

वास्तव में। यह स्वीकृत उत्तर होना चाहिए

— ब्रुनेटन डिक

यदि आप अपनी परियोजना में एक पैकेज जोड़ सकते हैं - यह उत्तर सबसे अच्छा है

— vidik13

Answer 13

आपके फ़ंक्शन के काम न करने का कारण यह है कि विस्तार एक सरणी में जगह बढ़ाता है और इसे वापस नहीं करता है। आप अभी भी lambda से x वापस कर सकते हैं, इस तरह से कुछ का उपयोग कर:

reduce(lambda x,y: x.extend(y) or x, l)

नोट: सूचियों की तुलना में विस्तार अधिक कुशल है।

Comments

extendके रूप में उपयोग किया जाता है newlist = [], बेहतर है extend = newlist.extend, for sublist in l: extend(l)क्योंकि यह (बल्कि बड़े) ओवरहेड से बचता है lambda, पर विशेषता लुकअप xऔर or।

— agf

अजगर 3 जोड़ के लिएfrom functools import reduce

— मार्कस डट्सचके

Answer 14

def flatten(l, a):
    for i in l:
        if isinstance(i, list):
            flatten(i, a)
        else:
            a.append(i)
    return a

print(flatten([[[1, [1,1, [3, [4,5,]]]], 2, 3], [4, 5],6], []))

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

Comments

def flatten(l, a=None): if a is None: a = [][...]

— पोइक

Answer 15

पुनरावर्ती संस्करण

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

def flatten_list(k):
    result = list()
    for i in k:
        if isinstance(i,list):

            #The isinstance() function checks if the object (first argument) is an 
            #instance or subclass of classinfo class (second argument)

            result.extend(flatten_list(i)) #Recursive call
        else:
            result.append(i)
    return result

flatten_list(x)
#result = [1,2,3,4,5,6,7,8,9,10]

Comments

अच्छा, कोई आयात की आवश्यकता नहीं है और यह स्पष्ट है कि यह क्या कर रहा है ... एक सूची को समतल कर रहा है, अवधि :)

— गोरान बी।

बस शानदार!

— सचिन शर्मा

Answer 16

matplotlib.cbook.flatten() नेस्टेड सूचियों के लिए काम करेंगे भले ही वे उदाहरण की तुलना में अधिक गहराई से घोंसला बनाते हों।

import matplotlib
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
print(list(matplotlib.cbook.flatten(l)))
l2 = [[1, 2, 3], [4, 5, 6], [7], [8, [9, 10, [11, 12, [13]]]]]
print list(matplotlib.cbook.flatten(l2))

परिणाम:

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

यह अंडरस्कोर की तुलना में 18 गुना तेज है ।_। समतल:

Average time over 1000 trials of matplotlib.cbook.flatten: 2.55e-05 sec
Average time over 1000 trials of underscore._.flatten: 4.63e-04 sec
(time for underscore._)/(time for matplotlib.cbook) = 18.1233394636

Answer 17

चर लंबाई की पाठ-आधारित सूचियों के साथ काम करते समय स्वीकृत उत्तर मेरे काम नहीं आया। यहाँ एक वैकल्पिक दृष्टिकोण है जो मेरे लिए काम करता है।

l = ['aaa', 'bb', 'cccccc', ['xx', 'yyyyyyy']]

स्वीकृत जवाब जो काम नहीं आया :

flat_list = [item for sublist in l for item in sublist]
print(flat_list)
['a', 'a', 'a', 'b', 'b', 'c', 'c', 'c', 'c', 'c', 'c', 'xx', 'yyyyyyy']

नया प्रस्तावित समाधान जिसने मेरे लिए काम किया :

flat_list = []
_ = [flat_list.extend(item) if isinstance(item, list) else flat_list.append(item) for item in l if item]
print(flat_list)
['aaa', 'bb', 'cccccc', 'xx', 'yyyyyyy']

Answer 18

ऊपर अनिल के कार्य की एक ख़ासियत यह है कि उपयोगकर्ता को खाली सूची होने के लिए दूसरे तर्क को मैन्युअल रूप से निर्दिष्ट करने की आवश्यकता होती है [] । इसके बजाय डिफ़ॉल्ट होना चाहिए। अजगर वस्तुओं के काम करने के तरीके के कारण, इन्हें फ़ंक्शन के अंदर सेट किया जाना चाहिए, न कि तर्कों में।

यहाँ एक काम कर रहा है:

def list_flatten(l, a=None):
    #check a
    if a is None:
        #initialize with empty list
        a = []

    for i in l:
        if isinstance(i, list):
            list_flatten(i, a)
        else:
            a.append(i)
    return a

परिक्षण:

In [2]: lst = [1, 2, [3], [[4]],[5,[6]]]

In [3]: lst
Out[3]: [1, 2, [3], [[4]], [5, [6]]]

In [11]: list_flatten(lst)
Out[11]: [1, 2, 3, 4, 5, 6]

Answer 19

निम्नलिखित मुझे सबसे सरल लगते हैं:

>>> import numpy as np
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> print (np.concatenate(l))
[1 2 3 4 5 6 7 8 9]

Comments

विभिन्न आयामों वाली सूचियों के लिए काम नहीं करता है। -1

— नर्सरी

Answer 20

NumPy के फ्लैट का भी उपयोग कर सकते हैं :

import numpy as np
list(np.array(l).flat)

11/02/2016 संपादित करें: केवल तब काम करता है जब सब्लिस्ट समान आयाम होते हैं।

Comments

क्या यह इष्टतम समाधान होगा?

— अक्टूबर को रेट्रोकोड

Answer 21

आप numpy का उपयोग कर सकते हैं:
flat_list = list(np.concatenate(list_of_list))

Comments

यह संख्यात्मक, तार और मिश्रित सूचियों के लिए भी काम करता है

— नितिन

असमान रूप से नेस्टेड डेटा के लिए विफल, जैसे[1, 2, [3], [[4]], [5, [6]]]

— EL_DON

Answer 22

यदि आप एक क्लीनर लुक के लिए गति की एक छोटी राशि देने को तैयार हैं, तो आप उपयोग कर सकते हैं numpy.concatenate().tolist()या numpy.concatenate().ravel().tolist():

import numpy

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

%timeit numpy.concatenate(l).ravel().tolist()
1000 loops, best of 3: 313 µs per loop

%timeit numpy.concatenate(l).tolist()
1000 loops, best of 3: 312 µs per loop

%timeit [item for sublist in l for item in sublist]
1000 loops, best of 3: 31.5 µs per loop

आप डॉक्स numpy.concatenate और numpy.ravel में यहां और अधिक जानकारी प्राप्त कर सकते हैं

Comments

असमान नेस्टेड सूचियों के लिए काम नहीं करता है जैसे[1, 2, [3], [[4]], [5, [6]]]

— EL_DON

Answer 23

सबसे तेज़ समाधान जो मैंने पाया है (वैसे भी बड़ी सूची के लिए):

import numpy as np
#turn list into an array and flatten()
np.array(l).flatten()

किया हुआ! आप निश्चित रूप से सूची (एल) निष्पादित करके इसे वापस सूची में बदल सकते हैं

Comments

यह गलत है, समतल एनडी सरणी के आयामों को एक तक कम कर देगा, लेकिन सूचियों को एक के रूप में नहीं बदलना चाहिए।

— एंडो जुराई

Answer 24

underscore.pyपैकेज प्रशंसक के लिए सरल कोड

from underscore import _
_.flatten([[1, 2, 3], [4, 5, 6], [7], [8, 9]])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

यह सभी समतल समस्याओं (कोई सूची आइटम या जटिल घोंसले के शिकार) हल करती है

from underscore import _
# 1 is none list item
# [2, [3]] is complex nesting
_.flatten([1, [2, [3]], [4, 5, 6], [7], [8, 9]])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

आप underscore.pyपाइप के साथ स्थापित कर सकते हैं

pip install underscore.py

Comments

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

— gliemezis

यह सुपर स्लो है।

— निको श्लोमर

इसमें _ नाम का मॉड्यूल क्यों है? यह एक बुरे नाम की तरह लगता है। देखें stackoverflow.com/a/5893946/6605826

— EL_DON

@EL_DON: underscore.py readme पेज से "Underscore.py उत्कृष्ट जावास्क्रिप्ट लाइब्रेरी underscore.js का एक अजगर बंदरगाह है"। मुझे लगता है कि यह इस नाम का कारण है। और हाँ, यह अजगर के लिए एक अच्छा नाम नहीं है

— वु अनह

Answer 25

def flatten(alist):
    if alist == []:
        return []
    elif type(alist) is not list:
        return [alist]
    else:
        return flatten(alist[0]) + flatten(alist[1:])

Comments

उदाहरण के लिए python2.7 के लिए प्रश्न में नेस्टेड सूची:[[1, 2, 3], [4, 5, 6], [7], [8, 9]]

— EL_DON

@EL_DON ने अजगर 2.7.5 पर परीक्षण किया। यह ठीक काम करता है

— englealuze

Answer 26

नोट : नीचे पायथन 3.3+ पर लागू होता है क्योंकि यह उपयोग करता है yield_from। sixथर्ड-पार्टी पैकेज भी है, हालांकि यह स्थिर है। वैकल्पिक रूप से, आप उपयोग कर सकते हैं sys.version।

---

के मामले में obj = [[1, 2,], [3, 4], [5, 6]], यहाँ के सभी समाधान अच्छे हैं, जिसमें सूची समझ और शामिल हैं itertools.chain.from_iterable।

हालाँकि, इसे थोड़ा और जटिल मामला मानें:

>>> obj = [[1, 2, 3], [4, 5], 6, 'abc', [7], [8, [9, 10]]]

यहाँ कई समस्याएं हैं:

• एक तत्व, 6सिर्फ एक अदिश राशि है; यह चलने योग्य नहीं है, इसलिए उपरोक्त मार्ग यहां विफल हो जाएंगे।
• एक तत्व, 'abc', है तकनीकी रूप से iterable (सभी strरों हैं)। हालांकि, लाइनों के बीच थोड़ा सा पढ़ना, आप इसे इस तरह से व्यवहार नहीं करना चाहते हैं - आप इसे एक ही तत्व के रूप में व्यवहार करना चाहते हैं।
• अंतिम तत्व, [8, [9, 10]]स्वयं एक नेस्टेड है। मूल सूची समझ और chain.from_iterableकेवल "1 स्तर नीचे" निकालें।

आप इसका उपाय इस प्रकार कर सकते हैं:

>>> from collections import Iterable
>>> from six import string_types

>>> def flatten(obj):
...     for i in obj:
...         if isinstance(i, Iterable) and not isinstance(i, string_types):
...             yield from flatten(i)
...         else:
...             yield i


>>> list(flatten(obj))
[1, 2, 3, 4, 5, 6, 'abc', 7, 8, 9, 10]

यहां, आप जांचते हैं कि उप-तत्व (1) के साथ चलने योग्य है Iterable, एबीसी से itertools, लेकिन यह भी सुनिश्चित करना चाहते हैं कि (2) तत्व "स्ट्रिंग-जैसा" नहीं है ।

Comments

यदि आप अभी भी अजगर 2 संगतता में रुचि रखते हैं, तो yield fromएक forलूप में बदलें , जैसेfor x in flatten(i): yield x

— पाइलैंग

Answer 27

flat_list = []
for i in list_of_list:
    flat_list+=i

यह कोड भी ठीक काम करता है क्योंकि यह सूची को सभी तरह से विस्तारित करता है। हालांकि यह बहुत समान है लेकिन लूप के लिए केवल एक ही है। तो इसमें छोरों के लिए 2 जोड़ने की तुलना में कम जटिलता है।

Answer 28

from nltk import flatten

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

इस समाधान का लाभ यहां अन्य लोगों पर है कि यदि आपके पास एक सूची है:

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

जबकि अधिकांश अन्य समाधान एक त्रुटि फेंकते हैं यह समाधान उन्हें संभालता है।

Comments

प्रश्न "सूचियों की सूची" बताता है, लेकिन आपकी उदाहरण सूची में एक गैर-सूची आइटम शामिल है। अधिकांश अन्य समाधान मूल प्रश्न से चिपके हुए हैं। आपका समाधान एक व्यापक समस्या को हल करता है, लेकिन इसके लिए एक गैर-बेस पायथन पैकेज (nltk) की भी आवश्यकता होती है जिसे पहले स्थापित किया जाना चाहिए।

— सिमोनोबो

Answer 29

यह सबसे कारगर तरीका नहीं हो सकता है लेकिन मैंने वन-लाइनर (वास्तव में टू-लाइनर) लगाने का सोचा। दोनों संस्करण मनमानी श्रेणीबद्ध नेस्टेड सूचियों पर काम करेंगे, और भाषा की विशेषताओं (पायथन 3.5) और पुनरावृत्ति का फायदा उठाते हैं।

def make_list_flat (l):
    flist = []
    flist.extend ([l]) if (type (l) is not list) else [flist.extend (make_list_flat (e)) for e in l]
    return flist

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = make_list_flat(a)
print (flist)

आउटपुट है

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

यह पहले तरीके से गहराई से काम करता है। जब तक यह एक गैर-सूची तत्व नहीं पाता है, तब तक पुनरावृत्ति कम हो जाती है, फिर स्थानीय चर का विस्तार करता है flistऔर फिर इसे वापस माता-पिता के पास ले जाता है। जब भी flistलौटाया जाता है, तो यह flistसूची की समझ में माता-पिता तक बढ़ा दी जाती है । इसलिए, रूट पर, एक फ्लैट सूची दी गई है।

उपरोक्त व्यक्ति कई स्थानीय सूचियाँ बनाता है और उन्हें वापस करता है जो कि माता-पिता की सूची का विस्तार करने के लिए उपयोग किया जाता है। मुझे लगता है कि इसके लिए चारों ओर flistनीचे की तरह एक ग्लोबल बनाया जा सकता है ।

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = []
def make_list_flat (l):
    flist.extend ([l]) if (type (l) is not list) else [make_list_flat (e) for e in l]

make_list_flat(a)
print (flist)

आउटपुट फिर से है

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

यद्यपि मैं इस समय दक्षता के बारे में निश्चित नहीं हूं।

Comments

अपेंड (l) के बजाय ([l]) का विस्तार क्यों?

— मैकिक

Answer 30

एक और असामान्य दृष्टिकोण जो हेट्रो के लिए काम करता है- और पूर्णांकों की सजातीय सूची:

from typing import List


def flatten(l: list) -> List[int]:
    """Flatten an arbitrary deep nested list of lists of integers.

    Examples:
        >>> flatten([1, 2, [1, [10]]])
        [1, 2, 1, 10]

    Args:
        l: Union[l, Union[int, List[int]]

    Returns:
        Flatted list of integer
    """
    return [int(i.strip('[ ]')) for i in str(l).split(',')]

Comments

यह सिर्फ एक और अधिक जटिल और थोड़ा धीमा तरीका है जो already3000 पहले से ही पोस्ट किया गया है। मैंने कल उनके प्रस्ताव पर

— लगाम लगाई

बिलकुल नहीं: wierd_list = [[1, 2, 3], [4, 5, 6], [7], [8, 9], 10]>>nice_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0]

— tharndt

एक लाइनर के रूप में मेरा कोड होगा: flat_list = [int(e.replace('[','').replace(']','')) for e in str(deep_list).split(',')]

— tharndt

आप वास्तव में सही हैं +1,'s3000 का प्रस्ताव कई अंकों की संख्या के साथ काम नहीं करेगा, मैंने पहले भी इसका परीक्षण नहीं किया था हालांकि यह स्पष्ट होना चाहिए। आप अपना कोड सरल कर सकते हैं और लिख सकते हैं [int(e.strip('[ ]')) for e in str(deep_list).split(',')]। लेकिन मैं वास्तविक उपयोग के मामलों के लिए डेलेट के प्रस्ताव के साथ रहने का सुझाव दूंगा। इसमें हैकी टाइप ट्रांसफ़ॉर्मेशन नहीं है, यह तेज़ और अधिक बहुमुखी है क्योंकि यह स्वाभाविक रूप से मिश्रित प्रकारों के साथ सूचियों को भी संभालता है।

— डार्कनॉट

दुर्भाग्यवश नहीं। लेकिन मैंने इस कोड को हाल ही में यहाँ देखा: पायथन प्रैक्टिस बुक 6.1.2

— थर्ंड्ट