Представяне
А списък се счита за една от най-гъвкавите структури от данни в езика за програмиране Python. От друга страна, двуизмерен списък или 2D списък, който обикновено се нарича списък от списъци, е обект на списък, където всеки елемент сам по себе си е списък. Например: [[19, 18, 17], [16, 15, 14], [13, 12, 11]].
Изравняването на списък от списъци е процес на трансформиране на двуизмерен списък в едноизмерен списък чрез премахване на влагането на всеки елемент от списъка, съхраняван в списъка със списъци, тоест трансформиране на [[9, 8, 7], [6 , 5, 4], [3, 2, 1]] до [9, 8, 7, 6, 5, 4, 3, 2, 1].
Можем да извършим процеса на сплескване с помощта на вложените за цикли, рекурсия, разбиране на списъци, основни функции или импортиране на библиотеки или пакети в Python за дълбочината и редовността на вложените списъци.
В този урок ще работим върху различни методи за изглаждане на вложените списъци с помощта на езика за програмиране Python. Но преди да започнем, нека разберем типовете вложени списъци.
Какви са типовете вложени списъци?
Както знаем, Python е слабо типизиран език за програмиране. Следователно можем да срещнем два вида списък със списъци. Тези Списъци със списъци или Вложени списъци са както следва:
- Редовен списък със списъци
- Неправилен списък със списъци
Редовен списък със списъци
Всеки елемент в Редовния списък със списъци се нарича Подсписък, като по този начин се спазва еднаквостта на типа на елемента. Например: [[9, 8, 7], [6, 5, 4], [3, 2, 1]] е обикновен списък от списъци като [9, 8, 7], [6, 5, 4] , [3, 2, 1] е от списъчен тип.
Неправилен списък със списъци
баш ако условие
Всеки елемент в нередовния списък със списъци се нарича подсписък или несписъчен елемент (например низ или цяло число). Така има нередност по отношение на вида на елемента. Например: [[9, 8, 7], [6, 5], 4, 3] е неправилен списък от списъци, тъй като [9, 8, 7] и [6, 5] са от типовете списъци, докато 4 и 3 са от тип int.
Изравняване на списъка със списъци с помощта на вложените цикли for
Изравняване на списъка със списъци с вложените за Помощта на Loops се счита за подход с груба сила за получаване на плосък списък. Можем да изпълним този метод, като изберем всеки елемент от двумерния списък и го подредим в едномерен списък.
Нека разгледаме следния пример, който работи както за редовни, така и за нередовни списъци от списъци.
Пример:
# defining the function def flattenlist(_2dlist): # defining an empty list flatlist = [] # Iterating through the outer list for item in _2dlist: if type(item) is list: # If the item is of the list type, iterating through the sub-list for element in item: flatlist.append(element) else: flatlist.append(item) return flatlist # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] print('Genuine List:', nestedlist) print('Converted Flat List:', flattenlist(nestedlist))
Изход:
Genuine List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] Converted Flat List: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Обяснение:
В горния пример дефинирахме функция като плоски списък който приема параметър като _2dlist . След това използвахме за цикъл за повторение на елементите на вложения списък и добавянето им за генериране на сплескан списък. След това дефинирахме вложения списък и внедрихме плоски списък функция. В резултат на това вложеният списък успешно се трансформира в сплескан списък.
Изравняване на вложения списък с помощта на разбиране на списък
Изравняването на списъка със списъци с помощта на разбиране на списък се счита за елегантен подход за получаване на плосък списък в зависимост от съществуващ двуизмерен списък. Този подход обаче предлага по-малко интуитивно решение.
Нека разгледаме следния пример.
Пример:
# defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # list comprehension flatlist = [element for sub_list in nestedlist for element in sub_list] print('Genuine list:', nestedlist) print('Converted list:', flatlist)
Изход:
Genuine list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Обяснение:
В горния пример сме дефинирали вложен списък и разбиране на списъка. След това ги отпечатахме за потребителите. В резултат на това вложеният списък е успешно трансформиран в сплескан списък.
Изравняване на списъка със списъци с помощта на рекурсивен метод
Можем също да използваме рекурсивния метод, за да изравним двуизмерния списък. Нека разгледаме следния пример, прилагащ рекурсивния метод, за да изравним списъка от списъци. Тази реализация работи добре както за редовен, така и за нередовен списък от списъци.
Пример:
# defining a function def flattenlist(nestedlist): if len(nestedlist) == 0: return nestedlist if isinstance(nestedlist[0], list): return flattenlist(nestedlist[0]) + flattenlist(nestedlist[1:]) return nestedlist[:1] + flattenlist(nestedlist[1:]) print(flattenlist([[10, 20, 30, 40], [50, 60, 70], [80, 90], 100]))
Изход:
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Обяснение:
В горния пример сме дефинирали функция и сме използвали an ако изявление посочвайки дали дължината на вложения списък е равна на нула, след което връща вложения списък.
хакерска обработка
Ако елементът от данни на нулевия индекс е екземпляр на списък, тогава индексът на списъка отива отново във функцията и се добавя към следващия индекс на списъка и така нататък. В противен случай функцията ще върне елементите и т.н. Най-накрая дефинирахме вложения списък и изпълнихме функцията. В резултат на това списъкът със списъци се изравнява рекурсивно.
Използване на библиотеки на Python
Можем също да използваме някои от библиотеките на езика за програмиране Python, за да изравним списъка със списъци. Изпълнението на тези библиотеки е описано по-долу:
Изравняване на списъка със списъци с помощта на функционални инструменти и библиотеки с оператори
The оператор библиотеката предоставя iconcat() функция за извършване на основна операция като конкатенация. Можем да приложим тази функция кумулативно към елементите с данни на вложен списък, отляво надясно, което води до намаляване на вложения списък до сплескан списък.
Нека разгледаме следния пример, за да разберем неговото изпълнение.
Пример:
# importing the required libraries import operator import functools regularlist = [] # Converting the list of lists into a flattened one. def convo(nestedlist): for element in nestedlist: if type(element) is list: regularlist.append(element) else: regularlist.append([element]) return regularlist twoDlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110] regular2Dlist = convo(twoDlist) print('Given List:', twoDlist) print('Converted list:', functools.reduce(operator.iconcat, regular2Dlist, []))
Изход:
Given List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110] Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110]
Обяснение:
В горния пример ние импортирахме functools библиотека заедно с оператор библиотека. След това дефинирахме празен списък като редовен списък . След това дефинирахме функция като разговор за да трансформирате списъка със списъци в сплескан списък. В тази функция сме използвали за цикъл, където елементите от вложения списък се добавят към празния списък, който дефинирахме по-рано. По-късно сме дефинирали вложения списък и изпълняваме функцията. В резултат на това списъкът със списъци се преобразува успешно в сплескан списък.
Изравняване на списъка със списъци с помощта на библиотеката itertools
java преобразува низ в int
The itertools библиотеката предоставя верига() функция, която ни позволява да трансформираме вложен списък в единичен сплескан списък в идеалния случай. Тази функция третира последователните серии като единична серия, като ги итерира чрез итерируемото, подадено като параметър по сериен начин.
Нека разгледаме следния пример:
Пример:
# importing the itertools library import itertools # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] flattenlist = list(itertools.chain(*nestedlist)) print('The nested list:', nestedlist) print('The flattened list:', flattenlist
Изход:
The nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]] The flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Обяснение:
В горния пример ние импортирахме itertools библиотека и генерира вложен списък. След това използвахме верига() функция за преобразуване на дадения вложен списък в сплескан списък. Най-накрая върнахме резултата на потребителите. В резултат на това списъкът със списъци е изравнен успешно.
Изравняване на списъка със списъци с помощта на библиотеката NumPy
The NumPy библиотеката предоставя различни ежедневни операции, включително конкатенация на двуизмерни редовни масиви по колони или по редове. Ще използваме атрибута, известен като апартамент за да получите едномерен итератор над масива, за да завладеете целта. Нека разгледаме следния пример, за да разберем използването на функцията за свързване и плоския атрибут.
Пример:
# importing the library import numpy # defining the nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # using the concatenate function along with the flat attribute flattenlist = list(numpy.concatenate(nestedlist).flat) print('The Nested list:', nestedlist) print('The Flattened list:', flattenlist)
Изход:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Обяснение:
В горния пример ние импортирахме numpy библиотека и дефинира вложен списък. След това използвахме съединявам функция на numpy библиотека заедно със своята апартамент атрибут, за да изравните елементите на вложения списък и да ги свържете в нов изравнен списък. Най-накрая отпечатахме резултата за потребителите. По този начин списъкът със списъци е изравнен успешно.
Използване на основни функции
Можем също така да изпълним задачата за изравняване, като използваме някои основни функции, които езикът за програмиране Python предоставя.
Изравняване на списъка със списъци с помощта на функцията сума
Можем да разгледаме сумирането върху вътрешни списъци като друго решение на проблема. Предаваме два аргумента на сума функция: Първият параметър е итерируем , който е вложен списък, а вторият параметър е започнете което е празен списък за следния случай, който служи като първоначален плосък списък, където ще се добавят елементите с данни на вътрешните подсписъци.
Можем да кажем, че този подход е доста удобен, тъй като не се налага да импортираме нищо. Въпреки това, той е по-бавен от itertools() и верига() функции, когато има голям брой подсписъци във вложения списък.
Нека разгледаме следния пример:
Пример:
# defining a nested list nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]] # using the sum function flattenlist = sum(nestedlist, []) print('The Nested list:', nestedlist) print('The Flattened list:', flattenlist)
Изход:
The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]] The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Обяснение:
В горния пример дефинирахме вложен списък. След това използвахме сума () функция и изравнява вложения списък в едномерен списък и отпечатва получения списък за потребителите. В резултат на това успешно трансформирахме списъка със списъци в плосък списък.
Изравняване на списъка със списъци с помощта на ключова дума Lambda
Актрисата Сай Палави
Можем да дефинираме анонимна функция, използвайки ключовата дума ламбда . Можем да предадем редовния/нередовния списък като параметър на тази анонимна функция. Оценката на израза се прави, за да се получи плосък едномерен списък.
Нека разгледаме следния пример:
Пример:
# Defining the nested list nestedlist = [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70] # Using lambda parameters: expression flattenlist = lambda nestedlist:[item for element in nestedlist for item in flattenlist(element)] if type(nestedlist) is list else [nestedlist] print('The Nested list:', nestedlist) print('The Flattened List:', flattenlist(nestedlist))
Изход:
The Nested list: [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70] The Flattened List: [10, 20, 30, 30, 50, 60, 40, 60, 70, 70]
Обяснение:
В горния пример сме дефинирали вложен списък. След това използвахме ламбда ключова дума заедно с аргумент, дефиниращ израз за разбиране на списък. След това ги отпечатахме за потребителите. В резултат на това ние успешно преобразувахме двумерния неправилен списък в сплескан списък.