پایتون: چگونه لیستی از لیست ها را مسطح کنیم

معرفی

لیست انعطاف پذیرترین ساختار داده در پایتون است. در حالی که یک لیست دوبعدی که معمولاً به عنوان لیست لیست ها شناخته می شود، یک شی لیست است که در آن هر آیتم خود یک لیست است – به عنوان مثال: ((1,2,3), (4,5,6), (7,8,9)).

مسطح کردن یک لیست از لیست ها مستلزم تبدیل یک لیست دو بعدی به یک لیست یک بعدی با غیر تودرتو کردن هر آیتم لیست ذخیره شده در لیست لیست ها است – به عنوان مثال، تبدیل ((1, 2, 3), (4, 5, 6), (7, 8, 9)) به (1, 2, 3, 4, 5, 6, 7, 8, 9) .

این process مسطح کردن را می توان با استفاده از حلقه های تودرتو، درک لیست، بازگشت، توابع داخلی یا با وارد کردن کتابخانه ها در پایتون انجام داد. روی منظم بودن و عمق لیست های تودرتو.

انواع لیست های تودرتو

از آنجایی که پایتون ضعیف است، می توانید با آن مواجه شوید منظم و بی رویه لیست لیست ها

لیست منظم لیست ها

هر عنصر این لیست یک فهرست فرعی است، بنابراین به یکنواختی نوع عنصر پایبند است.
مثال: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) یک لیست منظم از لیست های به عنوان است (1, 2, 3), (4, 5, 6), (7, 8, 9) از نوع است list.

لیست نامنظم لیست ها

هر عنصر این لیست یا یک زیر لیست یا یک آیتم غیر لیست است (مثلاً یک عدد صحیح یا یک رشته). بنابراین از نظر نوع عنصر بی نظمی وجود دارد. مثال: ((1, 2, 3), (4, 5), 6) جایی که (1, 2, 3) و (4, 5) از نوع هستند list و 6 از نوع است int.

با استفاده از Nested فهرست لیست ها را صاف کنید برای حلقه ها

این یک رویکرد brute force برای به دست آوردن یک لیست مسطح با انتخاب هر عنصر از لیست لیست ها و قرار دادن آن در یک لیست 1 بعدی است.

این کد همانطور که در زیر نشان داده شده است بصری است و برای لیست های منظم و نامنظم لیست ها کار می کند:

def flatten_list(_2d_list):
    flat_list = ()
    
    for element in _2d_list:
        if type(element) is list:
            
            for item in element:
                flat_list.append(item)
        else:
            flat_list.append(element)
    return flat_list

nested_list = ((1, 2, 3, 4), (5, 6, 7), (8, 9, 10))
print('Original List', nested_list)
print('Transformed Flat List', flatten_list(nested_list))

این نتیجه در:

Original List ((1, 2, 3, 4), (5, 6, 7), (8, 9, 10))
Transformed Flat List (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

لیست لیست ها را با استفاده از درک لیست صاف کنید

این رویکرد یک راه حل ظریف اما کمتر بصری برای ایجاد یک لیست مسطح ارائه می دهد روی یک لیست دو بعدی موجود:

regular_list = ((1, 2, 3, 4), (5, 6, 7), (8, 9))
flat_list = (item for sublist in regular_list for item in sublist)
print('Original list', regular_list)
print('Transformed list', flat_list)

که خروجی زیر را می دهد:

Original list ((1, 2, 3, 4), (5, 6, 7), (8, 9))
Transformed list (1, 2, 3, 4, 5, 6, 7, 8, 9)

لیست لیست ها را به صورت بازگشتی صاف کنید

لیست دو بعدی را می توان به صورت بازگشتی نیز پهن کرد. پیاده سازی زیر هم برای لیست های منظم و هم نامنظم کار می کند:

def flatten(list_of_lists):
    if len(list_of_lists) == 0:
        return list_of_lists
    if isinstance(list_of_lists(0), list):
        return flatten(list_of_lists(0)) + flatten(list_of_lists(1:))
    return list_of_lists(:1) + flatten(list_of_lists(1:))


print(flatten(((1, 2, 3, 4), (5, 6, 7), (8, 9), 10)))

که به ما می دهد:

(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

استفاده از کتابخانه ها

شما هم می توانید تکیه کنید روی کمک کتابخانه های پایتون برای این کار.

با استفاده از لیست لیست ها را صاف کنید ابزارهای کاربردی (Reduce() و iconcat())

این iconcat() تابع عملیات اصلی الحاق را انجام می دهد و به صورت تجمعی روی آیتم های لیست لیست ها از چپ به راست اعمال می شود تا آن را به یک لیست واحد کاهش دهد:

import functools
import operator
regular_list = ()


def transform(nested_list):
    for ele in nested_list:
        if type(ele) is list:
            regular_list.append(ele)
        else:
            regular_list.append((ele))
    return regular_list


irregular_list = ((1, 2, 3, 4), (5, 6, 7), (8, 9, 10), 11)
regular_2D_list = transform(irregular_list)
print('Original list', irregular_list)
print('Transformed list', functools.reduce(operator.iconcat, regular_2D_list, ()))

که نتیجه مطلوب را به ما می دهد:

Original list ((1, 2, 3, 4), (5, 6, 7), (8, 9, 10), 11)
Transformed list (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

با استفاده از لیست لیست ها را صاف کنید itertools (زنجیر())

این رویکرد برای تبدیل یک لیست دوبعدی به یک لیست مسطح ایده‌آل است زیرا توالی‌های متوالی را با تکرار از طریق تکرار پذیرفته شده به عنوان آرگومان به صورت متوالی در نظر می‌گیرد.

import itertools

regular_list = ((1, 2, 3, 4), (5, 6, 7), (8, 9, 10))
flat_list = list(itertools.chain(*regular_list))

print('Original list', regular_list)
print('Transformed list', flat_list)

باز هم، این به ما یک لیست مسطح به عنوان خروجی می دهد:

Original list ((1, 2, 3, 4), (5, 6, 7), (8, 9, 10))
Transformed list (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

با استفاده از لیست لیست ها را صاف کنید ناتوان (concatenate() و flat())

ناامپی عملیات رایجی را ارائه می دهد که شامل الحاق آرایه های دو بعدی معمولی به صورت ردیفی یا ستونی است. ما نیز از flat برای رسیدن به هدف خود، یک تکرار کننده 1 بعدی روی آرایه دریافت کنیم. با این حال، این رویکرد نسبتا کند است:

import numpy

regular_list = ((1, 2, 3, 4), (5, 6, 7), (8, 9))

flat_list = list(numpy.concatenate(regular_list).flat)

print('Original list', regular_list)
print('Transformed list', flat_list)

که خروجی مورد نظر را به ما می دهد:

Original list ((1, 2, 3, 4), (5, 6, 7), (8, 9))
Transformed list (1, 2, 3, 4, 5, 6, 7, 8, 9)

استفاده از توابع داخلی

وظیفه صاف کردن را می توان با استفاده از توابع داخلی که پایتون ارائه می دهد نیز انجام داد.

با استفاده از لیست لیست ها را صاف کنید مجموع

جمع بندی لیست های داخلی راه حل دیگری است. تابع دارای دو پارامتر است: iterable که لیستی از لیست ها و start که در مورد ما یک لیست خالی است که به عنوان لیست مسطح اولیه که آیتم های زیر لیست های داخلی به آن اضافه می شوند عمل می کند.

این رویکرد راحت است زیرا شما مجبور نیستید import هر چیزی اما کندتر از itertools() و chain() وقتی تعداد زیر لیست ها زیاد باشد عمل می کند:

regular_list = ((1, 2, 3, 4), (5, 6, 7), (8, 9))

flat_list = sum(regular_list, ())

print('Original list', regular_list)
print('Transformed list', flat_list)

با خروجی:

Original list ((1, 2, 3, 4), (5, 6, 7), (8, 9))
Transformed list (1, 2, 3, 4, 5, 6, 7, 8, 9)

لیست لیست ها را با استفاده از لامبدا صاف کنید

یک تابع ناشناس را می توان با استفاده از کلمه کلیدی لامبدا تعریف کرد. لیست منظم/نامنظم به عنوان آرگومان به این تابع ناشناس ارسال می شود و ارزیابی عبارت برای به دست آوردن یک لیست 1 بعدی مسطح انجام می شود:

irregular_list = ((1, 2, 3), (3, 6, 7), (7, 5, 4),7)


flatten_list = lambda irregular_list:(element for item in irregular_list for element in flatten_list(item)) if type(irregular_list) is list else (irregular_list)

print("Original list ", irregular_list)
print("Transformed List ", flatten_list(irregular_list))

ما دوباره به نتیجه دلخواه خواهیم رسید:

Original list  ((1, 2, 3), (3, 6, 7), (7, 5, 4), 7)
Transformed List  (1, 2, 3, 3, 6, 7, 7, 5, 4, 7)

نتیجه

در این مقاله، فهرست گسترده‌ای از راه‌هایی که می‌توانیم کار صاف کردن لیست لیست‌ها را در پایتون تکمیل کنیم، ارائه کردیم.