පයිතන් හි ලැයිස්තු ලැයිස්තුවෙන් සරල ලැයිස්තුවක් සෑදීමට කෙටිමඟක් තිබේදැයි මම කල්පනා කරමි.

මට එය 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'

ලැයිස්තු ලැයිස්තුවක් ලබා දී ඇත 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

පැහැදිලි කිරීම: L උප ලැයිස්තු ඇති විට +( මත පදනම් වූ භාවිතය ඇතුළුව) මත පදනම් වූ කෙටිමං sumඅවශ්‍ය O(L**2)වේ - අතරමැදි ප්‍රති result ල ලැයිස්තුව දිගින් දිගටම පවතින බැවින්, සෑම පියවරකදීම නව අතරමැදි ප්‍රති result ල ලැයිස්තු වස්තුවක් වෙන් කරනු ලැබේ, සහ සියලු අයිතම පෙර අතරමැදි ප්‍රති result ලය පිටපත් කළ යුතුය (මෙන්ම අවසානයේ එකතු කළ නව ඒවා කිහිපයක්). එබැවින්, සරල බව සහ සාමාන්‍යත්වය නැතිවීමකින් තොරව, ඔබට එක් අයිතමයක L උප ලැයිස්තු ඇති බව පවසන්න: පළමු I අයිතම L-1 වතාවක් පෙරළා පිටපත් කරනු ලැබේ, දෙවන I අයිතම L-2 වතාවක් යනාදිය; මුළු පිටපත් ගණන 1 සිට L දක්වා x සඳහා x හි එකතුව මෙන් 1 ගුණයක් වේ, එනම්,I * (L**2)/2 .

ලැයිස්තු අවබෝධය එක් වරකට එක් ලැයිස්තුවක් ජනනය කරන අතර එක් එක් අයිතමය පිටපත් කරයි (එහි මුල් වාසස්ථානයේ සිට ප්‍රති result ල ලැයිස්තුව දක්වා) හරියටම එක් වරක්.

ඔබට භාවිතා කළ හැකිය 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))

කතුවරයාගේ සටහන : මෙය අකාර්යක්ෂමයි. නමුත් විනෝදජනකයි, මොනෝයිඩ් නියමයි. පයිතන් කේතය නිෂ්පාදනය සඳහා එය සුදුසු නොවේ.

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

ලැයිස්තු වල පමණක් ක්‍රියාත්මක වන බව සලකන්න. ලැයිස්තු ලැයිස්තුවක් සඳහා, ඔබට තවත් විසඳුමක් අවශ්‍ය වේ.

මම බොහෝ යෝජනා විසඳුම් පරීක්ෂා perfplot (මගේ සුරතල් ව්යාපෘතිය, පමණ, අවශ්යයෙන්ම දවටනය 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)"
)

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]

ඔබ ජැන්ගෝ භාවිතා කරන්නේ නම් රෝදය ප්‍රතිනිර්මාණය නොකරන්න :

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

... ඉටර්ටූල්ස් :

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

අංක , නූල් , කැදැලි ලැයිස්තු සහ මිශ්‍ර බහාලුම් සඳහා අදාළ වන පොදු ප්‍රවේශයක් මෙන්න .

කේතය

#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
• Python 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.
• කලින් SO පෝස්ට් එකක් හමු විය , සමහර විට මුල් නිරූපණය විය හැකිය.

දත්ත ව්‍යුහයක් සමතලා කිරීමට ඔබට අවශ්‍ය නම් එය කොතරම් ගැඹුරට කැදැල්ලක් දැයි ඔබ නොදන්නේ නම් ඔබට ¹ භාවිතා කළ හැකිය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]

එය උත්පාදක යන්ත්රයක් වන බැවින් ඔබට ප්රති result 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]

සමහර වේලාවන් එකතු කිරීම සඳහා (මෙම පිළිතුරෙහි ඉදිරිපත් කර ඇති ශ්‍රිතය ඇතුළත් නොවූ නිකෝ ෂ්ලමර් පිළිතුර මත පදනම්ව):

විශාල පරාසයක විහිදුණු අගයන් සඳහා ඉඩ සැලසීමට එය ලොග්-ලොග් කුමන්ත්‍රණයකි. ගුණාත්මක තර්කනය සඳහා: පහළ වඩා හොඳය.

ප්‍රති results ල වලින් පෙනී යන්නේ, අනුකාරකයේ අඩංගු වන්නේ අභ්‍යන්තර පුනරාවර්තන කිහිපයක් පමණක් නම් 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()

^{වියාචනය: මම එම පුස්තකාලයේ කර්තෘ වෙමි}

මම මගේ ප්‍රකාශය ආපසු ගන්නෙමි. එකතුව ජයග්‍රාහකයා නොවේ. ලැයිස්තුව කුඩා වන විට එය වේගවත් වුවද. නමුත් විශාල ලැයිස්තු සමඟ කාර්ය සාධනය සැලකිය යුතු ලෙස පිරිහී යයි.

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

සමඟ ව්යාකූලත්වයක් ඇති බව පෙනේ 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

ඔබ දිගුව භාවිතා කරන්නේ ඇයි?

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

මෙය හොඳින් ක්‍රියාත්මක විය යුතුය.

more_itertoolsපැකේජය ස්ථාපනය කිරීම සලකා බලන්න .

> pip install more_itertools

එය ක්‍රියාත්මක කිරීම සමඟ නැව්ගත කරයි flatten( ප්‍රභවය , 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 අනුවාදය අනුව, ඔබට වඩාත් සංකීර්ණ, කැදැලි කළ හැකි දෑ සමඟ සමතලා කළ හැකිය 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]

ඔබගේ ක්‍රියාකාරීත්වය ක්‍රියාත්මක නොවීමට හේතුව, දිගුව තැනින් තැන අරා විහිදෙන අතර එය නැවත ලබා නොදේ. මේ වගේ දෙයක් භාවිතා කරමින් ඔබට තවමත් ලැම්බඩා වෙතින් x ආපසු ලබා දිය හැකිය:

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

සටහන: ලැයිස්තු වල + ට වඩා දිගු කිරීම වඩා කාර්යක්ෂම වේ.

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]

පුනරාවර්තන අනුවාදය

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]

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

ප්‍රති ult ලය:

[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

විචල්‍ය දිග පෙළ පදනම් කරගත් ලැයිස්තු සමඟ කටයුතු කිරීමේදී පිළිගත් පිළිතුර මට වැඩ කළේ නැත. මෙන්න මට වැඩ කළ විකල්ප ප්‍රවේශයකි.

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

පහත දැක්වෙන්නේ මට සරල බව පෙනේ:

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

කෙනෙකුට NumPy හි තට්ටු නිවාසයද භාවිතා කළ හැකිය :

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

සංස්කරණය 11/02/2016: ක්‍රියා කරන්නේ උප ලැයිස්තු වලට සමාන මානයන් ඇති විට පමණි.

ඔබට අංක භාවිතා කළ හැකිය:
flat_list = list(np.concatenate(list_of_list))

ඔබ පිරිසිදු පෙනුම සඳහා වේගය ඉතා කුඩා ප්රමාණයක් අත්හැරීමට කැමති නම්, ඔබ භාවිතා කළ හැකි 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

Doms numpy.concatenate සහ numpy.ravel වෙතින් ඔබට මෙහි වැඩි විස්තර දැනගත හැකිය

මම සොයාගත් වේගවත්ම විසඳුම (කෙසේ වෙතත් විශාල ලැයිස්තුවක් සඳහා):

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

කළා! ලැයිස්තුව (l) ක්‍රියාත්මක කිරීමෙන් ඔබට එය නැවත ලැයිස්තුවක් බවට පත් කළ හැකිය

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

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

සටහන : පහත දැක්වෙන්නේ පයිතන් 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', වේ (සියළුම තාක්ෂණික iterablestr ගේ වේ). කෙසේ වෙතත්, රේඛා අතර තරමක් කියවීම, ඔබට එය එසේ සැලකීමට අවශ්‍ය නැත - ඔබට එය තනි අංගයක් ලෙස සැලකීමට අවශ්‍යය.
• අවසාන මූලද්‍රව්‍යය, [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) මූලද්‍රව්‍යය “නූල් වැනි” නොවන බව සහතික කිරීමටද අවශ්‍ය වේ .

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

මෙම කේතය ද හොඳින් ක්‍රියාත්මක වන අතර එය ලැයිස්තුව සෑම අතින්ම දිගු කරයි. එය බොහෝ සමාන වුවත් ලූප සඳහා ඇත්තේ එකක් පමණි. එබැවින් එය ලූප සඳහා 2 ක් එකතු කිරීමට වඩා අඩු සංකීර්ණතාවයක් ඇත.

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

අනෙක් බොහෝ විසඳුම් දෝෂයක් ඇති අතර මෙම විසඳුම ඒවා හසුරුවයි.

මෙය වඩාත්ම කාර්යක්ෂම ක්‍රමය නොවිය හැකි නමුත් මම සිතුවේ එක් ලයිනර් එකක් (ඇත්ත වශයෙන්ම ලයිනර් දෙකක්) දැමීමටයි. මෙම සංස්කරණ දෙකම අත්තනෝමතික ධූරාවලිය කැදැලි ලැයිස්තු මත ක්‍රියා කරනු ඇති අතර භාෂා ලක්ෂණ (පයිතන් 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ලැයිස්තු අවබෝධය තුළ මවුපියන් වෙත විහිදේ . එමනිසා, මුලදී, පැතලි ලැයිස්තුවක් ආපසු ලබා දෙනු ලැබේ.

ඉහත සඳහන් එක දේශීය ලැයිස්තු කිහිපයක් නිර්මාණය කර දෙමව්පියන්ගේ ලැයිස්තුව දීර් extend කිරීම සඳහා භාවිතා කරයි. මම හිතන්නේ මේ සඳහා ඇති මාර්ගය 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]

කාර්යක්ෂමතාව ගැන මේ අවස්ථාවේ මට විශ්වාස නැත.

පූර්ණ සංඛ්‍යා වල විෂම හා සමජාතීය ලැයිස්තු සඳහා ක්‍රියා කරන තවත් අසාමාන්‍ය ප්‍රවේශයක්:

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