python - তালিকা তালিকা থেকে একটি সমতল তালিকা কিভাবে?




list multidimensional-array flatten (25)

Python এ তালিকাগুলির তালিকা থেকে একটি সহজ তালিকা তৈরি করার জন্য একটি শর্টকাট আছে কিনা আমি অবাক।

আমি একটি লুপ জন্য যে করতে পারেন, কিন্তু সম্ভবত কিছু শীতল "এক-মাছ ধরার নৌকা" আছে? আমি এটি কমাতে চেষ্টা করেছি, কিন্তু আমি একটি ত্রুটি পেতে।

কোড

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'

Answers

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]

এটি আন্ডারস্কোর চেয়ে 18x দ্রুত ._। ফ্ল্যাট:

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

যদি আপনি কোনও তথ্য-কাঠামোকে ফ্ল্যাট করতে চান যেখানে আপনি এটি গভীরভাবে নিস্তেজ না হন তবে এটি iteration_utilities.deepflatten 1 ব্যবহার করতে পারে।

>>> 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 কাছাকাছি একটি পাতলা মোড়ক 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]

শুধু কিছু সময় যোগ করার জন্য (নিক Schlömer উত্তরটির উপর ভিত্তি করে যা এই উত্তরটিতে উপস্থাপিত ফাংশনটি অন্তর্ভুক্ত করে নি):

এটি একটি লগ-লগ প্লট যা ব্যয়বহুল মানগুলির বিস্তৃত পরিসরের জন্য উপযুক্ত। গুণগত যুক্তি জন্য: নিম্নতর ভাল।

ফলাফলগুলি দেখায় যে যদি কেবলমাত্র কয়েকটি অভ্যন্তরীণ ইথারবেল থাকে তবে sum দ্রুততম হবে, তবে itertools.chain.from_iterable জন্য শুধুমাত্র itertools.chain.from_iterable , iteration_utilities.deepflatten বা nested বোঝার সাথে itertools.chain.from_iterable দ্রুততম কার্যকারিতা রয়েছে (ইতিমধ্যে নিক Schlömer দ্বারা লক্ষ্য করেছেন)।

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 দাবিঃ আমি সেই লাইব্রেরীর লেখক


আপনি numpy ব্যবহার করতে পারেন:
flat_list = list(np.concatenate(list_of_list))


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

এই কোডটি ঠিক ভাবেই তালিকাটি প্রসারিত করে জরিমানা করে। যদিও এটি অনেক অনুরূপ কিন্তু শুধুমাত্র লুপের জন্য একটি। তাই loops জন্য 2 যোগ চেয়ে কম জটিলতা আছে।


more_itertools প্যাকেজ ইনস্টল করার কথা বিবেচনা করুন।

> pip install more_itertools

এটি flatten জন্য একটি বাস্তবায়ন সঙ্গে জাহাজ ( source , itertools রেসিপি থেকে ):

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 হিসাবে, আপনি আরো জটিল, nested more_itertools.collapse ( source , অবরনেট দ্বারা অবদান) দিয়ে more_itertools.collapse করতে পারেন।

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]

আমি ফিরে আমার বিবৃতি নিতে। চূড়ান্ত বিজয়ী নয়। তালিকাটি ছোট হলেও এটি দ্রুত। কিন্তু কর্মক্ষমতা বড় তালিকা সঙ্গে উল্লেখযোগ্যভাবে হ্রাস।

>>> 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

আমি perfplot (খনি একটি পোষা প্রকল্প, মূলত timeit কাছাকাছি একটি wrapper) সঙ্গে সবচেয়ে প্রস্তাবিত সমাধান পরীক্ষা, এবং পাওয়া যায়

list(itertools.chain.from_iterable(a))

দ্রুততম সমাধান হতে (যদি 10 টির বেশি তালিকা সংহত হয়)।

প্লট পুনরুত্পাদন কোড:

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 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,
    kernels=[
        forfor, sum_brackets, functools_reduce, itertools_chain, numpy_flat,
        numpy_concatenate
        ],
    n_range=[2**k for k in range(16)],
    logx=True,
    logy=True,
    xlabel='num lists'
    )

underscore.py প্যাকেজ ফ্যানের জন্য সহজ কোড

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

এটি সমস্ত flatten সমস্যার সমাধান (কোন তালিকা আইটেম বা জটিল নেস্টিং)

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

আমি সম্প্রতি একটি পরিস্থিতি জুড়ে এসেছি যেখানে আমি যেমন sublists মধ্যে স্ট্রিং এবং সংখ্যাসূচক তথ্য মিশ্রিত ছিল

test = ['591212948',
['special', 'assoc', 'of', 'Chicago', 'Jon', 'Doe'],
['Jon'],
['Doe'],
['fl'],
92001,
555555555,
'hello',
['hello2', 'a'],
'b',
['hello33', ['z', 'w'], 'b']]

যেখানে পদ্ধতি flat_list = [item for sublist in test for item in sublist]কাজ করে না। তাই, আমি 1+ স্তরের sublists জন্য নিচের সমাধান নিয়ে এসেছি

def concatList(data):
    results = []
    for rec in data:
        if type(rec) == list:
            results += rec
            results = concatList(results)
        else:
            results.append(rec)
    return results

এবং ফলাফল

In [38]: concatList(test)
Out[38]:
 Out[60]:
['591212948',
'special',
'assoc',
'of',
'Chicago',
'Jon',
'Doe',
'Jon',
'Doe',
'fl',
92001,
555555555,
'hello',
'hello2',
'a',
'b',
'hello33',
'z',
'w',
'b']

নিম্নলিখিত আমার কাছে সহজ মনে হয়:

>>> 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]

এটি সবচেয়ে কার্যকরী উপায় হতে পারে না তবে আমি একটি এক-মাছ ধরার নৌকা (আসলে একটি দুই-মাছ ধরার নৌকা) লাগাতে চিন্তা। উভয় সংস্করণ ইচ্ছাকৃতভাবে অনুক্রমের তালিকাভুক্ত নেস্টেড তালিকাগুলিতে কাজ করবে এবং ভাষা বৈশিষ্ট্যগুলি (Python3.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নীচের মত একটি gloabl তৈরি হতে পারে মনে হয় ।

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]

আমি দক্ষতা সম্পর্কে এই সময়ে নিশ্চিত না হলেও।


পরিবর্তনশীল উত্তর টেক্সট-ভিত্তিক তালিকা মোকাবেলা করার সময় গৃহীত উত্তর আমার জন্য কাজ করে না। এখানে আমার জন্য কাজ করে যে একটি বিকল্প পদ্ধতির।

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']

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]

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 সংস্করণ করতে একটি দ্রুত উপায় হবে

>>> 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]

আপনি বেশ সহজভাবে একটি প্রকৃত স্ট্যাক তথ্য গঠন ব্যবহার করে স্ট্যাকের recursive কল এড়াতে পারেন।

alist = [1,[1,2],[1,2,[4,5,6],3, "33"]]
newlist = []

while len(alist) > 0 :
  templist = alist.pop()
  if type(templist) == type(list()) :
    while len(templist) > 0 :
      temp = templist.pop()
      if type(temp) == type(list()) :
        for x in temp :
          templist.append(x)
      else :
        newlist.append(temp)
  else :
    newlist.append(templist)
print(list(reversed(newlist)))

তালিকা reduceথেকে functoolsএবং addঅপারেটর ব্যবহার করে একটি সহজ recursive পদ্ধতি :

>>> from functools import reduce
>>> from operator import add
>>> flatten = lambda lst: [lst] if type(lst) is int else reduce(add, [flatten(ele) for ele in lst])
>>> flatten(l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

ফাংশন হিসাবে পরামিতি flattenলাগে lst। এটা সব উপাদান loops lstপর্যন্ত পৌঁছনো পূর্ণসংখ্যার (এছাড়াও পরিবর্তন করতে পারেন intথেকে float, strযা দূরতম পুনরাবৃত্তির ফেরত মান যোগ করা হয় অন্য ডেটা ধরনের জন্য, ইত্যাদি)।

forলুপ এবং মণ্যাডের মতো পদ্ধতির বিপরীতে , এটি একটি সাধারণ সমাধান তালিকা গভীরতার দ্বারা সীমাবদ্ধ নয় । উদাহরণস্বরূপ, 5 এর গভীরতা সহ একটি তালিকা একইভাবে ফ্ল্যাট করা যেতে পারে l:

>>> l2 = [[3, [1, 2], [[[6], 5], 4, 0], 7, [[8]], [9, 10]]]
>>> flatten(l2)
[3, 1, 2, 6, 5, 4, 0, 7, 8, 9, 10]

লেখক থেকে নোট : এই অদক্ষ। কিন্তু মজা, monads ভয়ঙ্কর কারণ। এটা পাইথন কোড উত্পাদন জন্য উপযুক্ত নয়।

>>> 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]

তালিকা তালিকা শুধুমাত্র কাজ করে নোট। তালিকা তালিকা তালিকা জন্য, আপনি অন্য সমাধান প্রয়োজন হবে।


কেউ নুম্পির flat ব্যবহার করতে পারে:

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

সম্পাদন 11/02/2016: শুধুমাত্র sublists অভিন্ন মাত্রা আছে যখন কাজ করে।


আপনি প্রসারিত ব্যবহার করবেন কেন?

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

এই জরিমানা কাজ করা উচিত।


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

আপনার ফাংশন কাজ করে না কারণ: প্রসারিত অ্যারে প্রসারিত এবং এটি ফেরত না। আপনি এখনও কিছু কৌশল ব্যবহার করে, ল্যাম্বা থেকে এক্সটি ফিরে পেতে পারেন:

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

দ্রষ্টব্য: তালিকা থেকে + বেশি কার্যকর প্রসারিত।


এখানে একটি সাধারণ পদ্ধতি যা সংখ্যা , স্ট্রিং , নেস্টেড তালিকা এবং মিশ্র পাত্রে প্রয়োগ করা হয়।

কোড

from collections import Iterable


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 এ, for sub_x in flatten(x): yield sub_x yield from flatten(x) প্রতিস্থাপন করতে পারে for sub_x in flatten(x): yield sub_x

ডেমো

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']

উল্লেখ

  • এই সমাধানটি Beazley, D. এবং B. জোন্সের রেসিপি থেকে সংশোধন করা হয় রেসিপি 4.14, পাইথন কুকবুক 3 য় এড।, ও'রাইলি মিডিয়া ইনক। সেবাস্তোপোল, সিএ: 2013।
  • একটি পূর্ববর্তী SO পোস্ট , সম্ভবত মূল বিক্ষোভ পাওয়া গেছে।

দ্রষ্টব্য : এটি ব্যবহার করে কারণ পাইথন 3.3+ এ প্রযোজ্য yield_fromsixএটি একটি তৃতীয় পক্ষের প্যাকেজ, যদিও এটি স্থিতিশীল। অন্যথায়, আপনি ব্যবহার করতে পারেন 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শুধু একটি scalar হয়; এটি পুনরাবৃত্তিযোগ্য নয়, তাই উপরের রুট এখানে ব্যর্থ হবে।
  • এক উপাদান 'abc', হয় টেকনিক্যালি iterable (সমস্ত strগুলি আছে)। যাইহোক, লাইনগুলির মধ্যে একটু পড়া, আপনি এটির মতো আচরণ করতে চান না - আপনি এটি একটি একক উপাদান হিসাবে আচরণ করতে চান।
  • চূড়ান্ত উপাদান, [8, [9, 10]]নিজেই একটি nested পুনরাবৃত্তিযোগ্য। বেসিক তালিকা বোঝার এবং 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 হয় Iterable, থেকে একটি এবিসি itertools, কিন্তু তা নিশ্চিত করার জন্য (2) উপাদান চান না "STRING মত।"


হিটের জন্য কাজ করে এমন আরেকটি অস্বাভাবিক পদ্ধতি- এবং পূর্ণসংখ্যার একক তালিকা:

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(',')]

আপনি তাদের একত্রিত করতে + অপারেটর ব্যবহার করতে পারেন:

listone = [1,2,3]
listtwo = [4,5,6]

mergedlist = listone + listtwo

আউটপুট:

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




python list multidimensional-array flatten