কীভাবে তালিকার তালিকার বাইরে ফ্ল্যাট তালিকা তৈরি করবেন?

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

এখানে এর গভীর-আলোচনা রয়েছে: রাইটফুটিন.ব্লগস্পট.com / 2006 / 09 / more-on-python-flatten.html , স্বেচ্ছাসেবী তালিকাভুক্ত তালিকা তালিকাগুলির বেশ কয়েকটি পদ্ধতি নিয়ে আলোচনা। একটি আকর্ষণীয় পড়া!

— রিচিহিন্ডল

আরও কিছু উত্তর ভাল তবে আপনার ব্যর্থতার কারণ হ'ল 'প্রসারিত' পদ্ধতিটি সর্বদা কোনওটিই দেয় না। দৈর্ঘ্য 2 সহ একটি তালিকার জন্য, এটি কাজ করবে কিন্তু কোনও কিছুই ফেরত পাবে না। দীর্ঘ তালিকার জন্য, এটি প্রথম 2 টি আর্গ ব্যবহার করবে, যা কিছুই দেয় না। তখনই None.extend (<তৃতীয় ARG>), যা এই erro ঘটায় সঙ্গে চলতে

— mehtunguh

@ শন-চিন দ্রবণটি এখানে আরও অজগর, টিউপলস সহ অপারেটর.কোঙ্ক্যাট ব্যবহার করা তালিকার সাথে চেইন.ফর্ম_আবার্যগুলির চেয়ে দ্রুত সম্পাদন করে।

— মাইথাম

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)- মধ্যবর্তী ফলাফলের তালিকাটি দীর্ঘতর হতে থাকে, প্রতিটি ধাপে একটি নতুন অন্তর্বর্তী ফলাফল তালিকার অবজেক্ট বরাদ্দ হয়ে যায় এবং সমস্ত আইটেম থাকে পূর্ববর্তী মধ্যবর্তী ফলাফলটি অবশ্যই অনুলিপি করতে হবে (পাশাপাশি কয়েকটি নতুন যুক্ত হওয়া শেষে)। সুতরাং, সরলতার জন্য এবং সাধারণতার প্রকৃত ক্ষতি ছাড়াই, বলুন যে আপনার প্রত্যেকটি আই আইটেমের এল সাবলিস্ট রয়েছে: প্রথম আইটেমগুলি L-1 বার পিছনে নকল করা হয়, দ্বিতীয় আমি আই -2 বার আইটেম এবং আরও; কপির সর্বমোট সংখ্যাটি আমি x থেকে 1 অবধি এল থেকে বাদে, অর্থাৎ, এর যোগফলের গুণগুণ 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

আপনি বুঝতে পারছেন না অবধি সিনট্যাক্সটি বোঝা শক্ত হয়ে গেছে যতক্ষণ না আপনি লুপের জন্য নেস্টের মতো ঠিক মতো ভাবতে পারেন। এল-এ সাবলিস্টের জন্য: সাবলিস্টে আইটেমের জন্য: ফলন আইটেম

— রব ক্রোয়েল

@ বরিসচেরভেনকভ: লক্ষ্য করুন যে আমি তালিকার মধ্যে পুনরাবৃত্তিকারীকে list()উপলব্ধি করার জন্য কলটি গুটিয়ে রেখেছি ।

— 20:56

[গাছের পাতার জন্য বনে গাছের জন্য পাতা] বোঝা এবং প্রয়োগ করা আরও সহজ হতে পারে।

— জন মে

@ জোয়েল, আসলে আজকাল 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"].

— গৌরভকরের

Answer 3

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

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

এটি বেশ ঝরঝরে এবং চতুর কিন্তু আমি এটি ব্যবহার করব না কারণ এটি পড়ার জন্য বিভ্রান্তিকর।

— অ্যান্ড্রুর্ক

এটি চিত্রশিল্পীর আলগোরিদিম joelonsoftware.com/articles/fog0000000319.html - অকার্যকর পাশাপাশি অকারণে কুৎসিত।

— মাইক গ্রাহাম 18

তালিকাগুলিতে সংযোজন অপারেশনটি একটি তৈরি করে Monoid, যা +সাধারণ অর্থে অপারেশন ভাবার জন্য সবচেয়ে সুবিধাজনক বিমূর্ততাগুলির মধ্যে একটি (কেবলমাত্র সংখ্যায় সীমাবদ্ধ নয়)। সুতরাং এই উত্তরটি monoid হিসাবে তালিকাগুলির (সঠিক) চিকিত্সার জন্য আমার কাছ থেকে একটি +1 প্রাপ্য। পারফরম্যান্স যদিও সম্পর্কিত ...

— ulidtko

@ অ্যান্ড্রুআরক ওয়েল, কিছু লোক মনে করেন এটি এটি করার সবচেয়ে সহজ উপায়: youtube.com/watch?v=IOiZatlZtGU যেগুলি কেন শীতল তা পায় না কেবল কয়েক দশক অপেক্ষা করা দরকার যতক্ষণ না সবাই এইভাবে কাজ করে: ) আসুন আমরা প্রোগ্রামিং ভাষা (এবং বিমূর্তি) ব্যবহার করি যা আবিষ্কার হয় এবং আবিষ্কার হয় না, মনোয়েড আবিষ্কার হয়।

— gedেগেদাস

যোগফলের চতুর্ভুজ দিকের কারণে এটি একটি খুব অদক্ষ উপায়।

— জিন-

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)' উপরের সমস্ত ফাংশনের মধ্যে দ্রুততম।

— সারা

রেজেক্স ব্যবহার করে চেষ্টা করা হয়েছে: 'তালিকা (মানচিত্র (int, re.findall (r "[, w] +", str (a)))))'। গতিটি কিছুটা ধীরে ধীরে সেই নম্পি_কন্টেনেটে

— জাস্টাস

3-ডি পারফ্লট করার কোনও উপায় আছে কি? অ্যারের গড় আকার দ্বারা অ্যারে সংখ্যা?

— লিও

আমি আপনার সমাধান ভালোবাসি। সংক্ষিপ্ত, সহজ এবং দক্ষ :-)

— শ্যাডিএমবিএ

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

— লুকমডো

এটি চিত্রশিল্পীর আলগোরিদিম joelonsoftware.com/articles/fog0000000319.html

— মাইক গ্রাহাম

এটি শুধুমাত্র জন্য ব্যবহার করতে পারেন integers। তবে তালিকায় কী আছে string?

— ফ্রেডি

@ ফ্রেডি: operator.addফাংশনটি পূর্ণসংখ্যা এবং স্ট্রিংয়ের তালিকা উভয়ের জন্য সমানভাবে কাজ করে well

— গ্রেগ হিউগিল

Answer 6

যদি আপনি জ্যাঙ্গো ব্যবহার করেন তবে চাকাটি পুনরায় উদ্ভাবন করবেন না :

>>> 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সঠিক উত্তরটি হওয়া উচিত

— জেকো

দুর্দান্ত উত্তর! পান্ডের ক্ষেত্রে l = [[[[১, ২, ৩]], [৪, ৫]], ৫] এর জন্যও কাজ করে

— মার্কাস ডুশচে

আমি পান্ডাস সমাধানটি পছন্দ করি। আপনি ভালো কিছু থাকে: list_of_menuitems = [1, 2, [3, [4, 5, [6]]]], এটি স্থাপিত হবে: [1, 2, 3, 4, 5, 6]। আমি যা মিস করছি তা সমতল স্তর।

— imjosangel

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, পাইথন কুকবুক তৃতীয় সংস্করণ, ও'রেলি মিডিয়া ইনক। সেবাস্তোপল, সিএ: 2013।
• একটি পূর্ববর্তী এসও পোস্ট পাওয়া গেছে , সম্ভবত আসল প্রদর্শনী।

Comments

আমি ঠিক অনেকটা একই রকম লিখেছি, কারণ আমি আপনার সমাধানটি দেখতে পাই নি ... এখানে আমি "একাধিক তালিকাগুলির পুনরাবৃত্তভাবে সম্পূর্ণ সমতলকরণ" খুঁজছিলাম ... (+1)

— মার্টিন থোমা

@ মার্টিন থোমা অনেক প্রশংসা করেছেন এফওয়াইআই, যদি নেস্টেড পুনরাবৃত্তিগুলি সমতল করা আপনার পক্ষে একটি সাধারণ অভ্যাস হয় তবে কিছু তৃতীয় পক্ষের প্যাকেজ রয়েছে যা এটি ভালভাবে পরিচালনা করে। এটি চাকা পুনর্নির্মাণ থেকে বাঁচাতে পারে। আমি more_itertoolsএই পোস্টে আলোচিত অন্যদের মধ্যে উল্লেখ করেছি । চিয়ার্স।

— পাইলং

সম্ভবত traverseকোনও গাছের এই পথের জন্য একটি ভাল নামও হতে পারে, আমি নেস্টেড তালিকাগুলিতে আটকে এই উত্তরটির জন্য এটিকে কম সর্বজনীন রাখতে পারি ।

— ওল্ফ

আপনি if hasattr(x, '__iter__')আমদানি / চেকের পরিবর্তে চেক করতে পারেন Iterableএবং এর সাথে স্ট্রিংগুলিও বাদ দেওয়া হবে।

— রায়ান অ্যালেন

উপরের কোডটি নেস্টেড তালিকার একটিতে স্ট্রিংয়ের একটি তালিকা থাকলে এটি কাজ করছে বলে মনে হচ্ছে না। [1, 2, [3, 4], [4], [], 9, 9.5, 'এসএসএসএস', ['আরআর', 'এসএসএস', 'এসএস'], [3, 4, 5]] আউটপুট: - [1, 2, 3, 4, 4, 9, 9.5, 'ssssss', 3, 4, 5]

— সানএক্স

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]

এটি একটি জেনারেটর তাই আপনাকে ফলাফলটি একটিতে castালাই করা দরকার 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__।

— ইয়ান ভার্নিয়ার

@ ইয়ান ভার্নিয়ার এই তথ্যের জন্য ধন্যবাদ। আমি ভেবেছিলাম আমি পাইথন 3.6 এ এই মানদণ্ডগুলি চালিয়েছি এবং এটি দিয়ে কাজ করে sum। কোন পাইথন সংস্করণে এটি কাজ করা বন্ধ করে দিয়েছিল তা কি আপনি জানতে পেরেছেন?

— MSefert

আমার কিছুটা ভুল হয়েছিল। 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 টি সাবলিস্ট যুক্ত একটি, সম্ভবত - তবে যেহেতু যোগফলের কর্মক্ষমতা O (N ** 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

হুম ন্যায্য দ্বিতীয় উদাহরণ হতে হবে এছাড়াও তালিকা হওয়া উচিত (বা প্রথম tuple?)

— Mr_and_Mrs_D

এই জাতীয় ছোট ইনপুট ব্যবহার করা মোটামুটি তুলনা নয়। দৈর্ঘ্যের 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

অজগর 3from functools import reduce

— andorov

দুঃখিত, এটি সত্যিই ধীরে ধীরে বাকি উত্তরগুলি দেখুন

— Mr_and_Mrs_D

পাইথন 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]

সংস্করণ ২.৪ অনুসারে, আপনি আরও জটিল, নেস্টেড পুনরাবৃত্তগুলি 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]

Comments

প্রকৃতপক্ষে. এটি গ্রহণযোগ্য উত্তর হওয়া উচিত

— ব্রুনেটটন

আপনি যদি আপনার প্রকল্পে একটি প্যাকেজ যুক্ত করতে সক্ষম হন - এই উত্তরটি সেরা

— viddik13

Answer 13

কারণ আপনার ফাংশন কাজ করে নি কারণ প্রসারিত ইন-জায়গা একটি অ্যারের প্রসারিত এবং এটি ফেরত দেয় না। আপনি লাম্বদা থেকে এই জাতীয় কিছু ব্যবহার করেও এক্স ফিরিয়ে দিতে পারেন:

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]

এটি আন্ডারস্কোরের চেয়ে 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

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

আপনি নকল ব্যবহার করতে পারেন:
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.concateate এবং 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

এটি ভুল, চ্যাপ্টা এনডি অ্যারের মাত্রা একটিকে হ্রাস করবে, তবে তালিকাগুলি এক হিসাবে সারণী করে না।

— Ando Jurai

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

@ এল_ডন: আন্ডারস্কোর.পি রিডমে পৃষ্ঠা থেকে "অ্যান্ডস্কোর.পি হ'ল দুর্দান্ত জাভাস্ক্রিপ্ট লাইব্রেরি আন্ডারস্কোর.জেসের একটি অজগর বন্দর"। আমি মনে করি এটি এই নামের কারণ। এবং হ্যাঁ, এটি অজগরটির পক্ষে ভাল নাম নয়

— ভু আন

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

প্রশ্নে নেস্টেড তালিকার উদাহরণের জন্য পাইথন 2.7 এর জন্য ব্যর্থ:[[1, 2, 3], [4, 5, 6], [7], [8, 9]]

— EL_DON

@ এল_ডন পাইথন ২.7.৫ এ পরীক্ষা করেছেন। এটি সূক্ষ্মভাবে কাজ করে

— ই

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]) প্রসারিত করবেন?

— ম্যাকিক 18

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

এটি ইতিমধ্যে complicated৩০০০ এর আগে পোস্ট করার একটি আরও জটিল এবং কিছুটা ধীর পথ way আমি গতকাল তার প্রস্তাবটি নতুন করে দিয়েছি, সুতরাং এই পদ্ধতিটি আজকাল বেশ জনপ্রিয় বলে মনে হয়;)

— ডারকোনট

পুরোপুরি নয়: 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]

— ই

আমার এক লাইনের হিসাবে কোডটি হবে: flat_list = [int(e.replace('[','').replace(']','')) for e in str(deep_list).split(',')]

— 11:38

আপনি সত্যই সঠিক +1, ᴡʜᴀᴄᴋᴀᴍᴀᴅᴏᴏᴅʟᴇ3000 এর প্রস্তাবটি একাধিক সংখ্যা সংখ্যার সাথে কাজ করবে না, আমি এটি আগে পরীক্ষাও করিনি যদিও এটি সুস্পষ্ট হওয়া উচিত। আপনি আপনার কোডটি সহজ করে লিখতে পারেন [int(e.strip('[ ]')) for e in str(deep_list).split(',')]। তবে আমি বাস্তব ব্যবহারের ক্ষেত্রে ডেলিটের প্রস্তাবটি মেনে চলার পরামর্শ দেব। এটি হ্যাকি ধরণের রূপান্তর ধারণ করে না, এটি দ্রুত এবং আরও বহুমুখী কারণ এটি প্রাকৃতিকভাবে মিশ্র প্রকারের সাথে তালিকাগুলিও পরিচালনা করে।

— ডারকনাট

দুর্ভাগ্যক্রমে না. তবে আমি সম্প্রতি এখানে এই কোডটি দেখেছি: পাইথন অনুশীলন বই 6.1.2

— থার্ডেন্ড