создание из составного списка, плоский список
Таким способом можно раскрыть 2D список, как из этого сделать для 3D, 4D списка и т.д Рекурсия ? Как ее можно реализовать в данной функции ?
Отслеживать
задан 27 фев 2021 в 10:30
53 2 2 серебряных знака 11 11 бронзовых знаков
27 фев 2021 в 10:35
Здесь идет речь о большом количестве списков внутри списка.
27 фев 2021 в 10:55
ок, давайте я поищу вместо вас. это — не оно разве?
27 фев 2021 в 11:04
27 фев 2021 в 11:26
1 ответ 1
Сортировка: Сброс на вариант по умолчанию
есть наверное средства библиотеки numpy и т.д., но если в лоб встроенными средствами, то можно так:
def flatten_list(arr): res = [] for obj in arr: res += flatten_list(obj) if isinstance(obj, (list, tuple, set)) else [obj] return res print(flatten_list([[[[1],2],3],4,[5,[6,[7], ]]])) данная функция работает со списками ( list ), кортежами ( tuple ) и множествами ( set ) и рекурсивно проходит до самых глубоких вложений
если требуется, чтобы она еще и словари переваривала, тогда ее слегка надо доработать, добавив такую возможность
Python: нарезка итерируемых объектов
Термин нарезка в программировании обычно относится к получению подстроки, подкортежа или подсписка из строки, кортежа или списка соответственно.
Python предлагает множество простых способов разрезать не только эти три, но и любые итерируемые объекты. Итерация, как следует из названия, любой объект, который может повторяться.
В этой статье мы рассмотрим все, что вам нужно знать о нарезке списков в Python.
Нарезка списка в Python
Есть несколько способов разрезать список, наиболее распространенным из которых является использование оператора : со следующим синтаксисом:
a_list[start:end] a_list[start:end:step] Параметр start представляет собой начальный индекс, end это конечный индекс, и step это количество элементов в шаге.
Если step явно не указано, используется значение по умолчанию 1 . Обратите внимание, что элемент с индексом start будет включен в результирующий подсписок, а элемент с индексом end не будет. Первый элемент списка имеет индекс 0 .
Пример без параметра step :
a_list = ['May', 'the', 'Force', 'be', 'with', 'you.'] sublist = a_list[1:3] print(sublist) Это должно напечатать:
['the', 'Force'] Для того, чтобы получить слова через одно, установите step на 2 :
a_list = ['The', 'Force', 'will', 'be', 'with', 'you.', 'Always.'] sublist = a_list[1:8:2] print(sublist) ['Force', 'be', 'you.'] Если step нет в списке, подсписок будет начинаться с начала. Аналогичным образом, если end нет в списке, подсписок будет заканчиваться концом исходного списка:
a_list = ['Do.', 'Or', 'do', 'not.', 'There', 'is', 'no', 'try.'] sublist = a_list[:4] print(sublist) sublist = a_list[4:] print(sublist) Этот фрагмент кода распечатывает:
['Do.', 'Or', 'do', 'not.'] ['There', 'is', 'no', 'try.'] Нахождение начала и конца списка с помощью среза
Обозначение среза может также использоваться с отрицательной индексацией. Отрицательное индексирование работает так же, как обычное индексирование, за исключением того факта, что оно начинает индексирование с последнего элемента, имеющего индекс -1 .
Его можно использовать для получения начала и конца списка заданной длины. Голова списка — это подсписок, который содержит первые n элементы списка, а хвост — подсписок, содержащий последние n элементы.
Давайте продолжим и разделим хвост и начало списка:
# The length of the tail n = 2 a_list = ['Never', 'tell', 'me', 'the', 'odds!'] # Head of the list: sublist = a_list[:n] print(sublist) # Tail of the list: sublist = a_list[-n:] print(sublist) ['Never', 'tell'] ['the', 'odds!'] Использование нотации среза для переворота списка
Даже параметр step может быть отрицательным. Если мы установим отрицательное значение, результирующий список будет перевернут со значением step . Вместо того, чтобы идти вперед, мы делаем шаг назад, от конца списка к началу и включаем следующие элементы:
a_list = ['Power!', 'Unlimited', 'power!'] sublist = a_list[::-1] print(sublist) ['power!', 'Unlimited', 'Power!'] Замена элементов подсписка нотацией среза
Обозначение среза может использоваться для присвоения новых значений элементам определенного подсписка. Например, давайте попробуем заменить хвост и начало списка:
a_list = ['I', 'am', 'no', 'Jedi.'] print(a_list) # Replacing the head of a list a_list[:1] = ['You', 'are'] print(a_list) # Replacing the tail of a list a_list[-1:] = ['Sith'] print(a_list) ['I', 'am', 'no', 'Jedi.'] ['You', 'are', 'no', 'Jedi.'] ['You', 'are', 'no', 'Sith'] Замена каждого n-го элемента списка срезной нотацией
Простой способ заменить каждый n-й элемент списка — установить для параметра step значение n в нотации среза:
a_list = ['I’m', 'just', 'a', 'simple', 'man', 'trying', 'to', 'make', 'my', 'way', 'in', 'the', 'universe.'] print(a_list) # Replacing every other word starting with the word with the index 1 a_list[1::2] = ['only', 'common', 'attempting','do', 'best','the'] print(a_list)
['I’m', 'just', 'a', 'simple', 'man', 'trying', 'to', 'make', 'my', 'way', 'in', 'the', 'universe.'] ['just', 'simple', 'trying', 'make', 'way', 'the'] ['I’m', 'only', 'a', 'common', 'man', 'attempting', 'to', 'do', 'my', 'best', 'in', 'the', 'universe.'] Вывод
Нарезать любую последовательность в Python легко, просто и интуитивно понятно. Отрицательная индексация предлагает простой способ получить первые или последние несколько элементов последовательности или изменить ее порядок.
В этой статье мы рассмотрели, как применить нотацию фрагментов к спискам в Python.
Что такое функция list в Python?
Функция Python list() принимает любую итерацию (объект, который можно перебирать) в качестве параметра и возвращает список.
list(iterable) где iterable это объект, который может быть последовательностью (строка, кортежи) или коллекцией (множество, словарь) или любым объектом-итератором.
x = 'string' print(list(x)) # => ['s', 't', 'r', 'i', 'n', 'g'] x = (1, 2, 3) print(list(x)) # => [1, 2, 3] # В случае преобразования словаря в список элементами списка станут ключи. x = "a": 2, "b": 3> print(list(x)) # => ['a', 'b'] Если мы не передадим ни одного параметра, функция list() вернет пустой список.
print(list()) # => [] Сглаживание вложенных списков в Python – преобразование двумерного в одномерный
Список считается одной из самых гибких структур данных в языке программирования Python. С другой стороны, двумерный список или 2D-список, который обычно называют списком списков, представляет собой объект списка, где каждый элемент является самим списком. Например: [[19, 18, 17], [16, 15, 14], [13, 12, 11]].
Сглаживание вложенных списков в Python – это процесс преобразования двумерного списка в одномерный список путем отмены вложенности каждого элемента списка, хранящегося в списке списков, то есть преобразования [[9, 8, 7], [6 , 5, 4], [3, 2, 1]] до [9, 8, 7, 6, 5, 4, 3, 2, 1].
Мы можем выполнить процесс выравнивания с помощью вложенных циклов for, рекурсии, понимания списков, основных функций или импорта библиотек и пакетов в Python с учетом глубины и регулярности вложенных списков.
В этом руководстве мы разберем как работать над различными методами сглаживания вложенных списков с помощью языка программирования Python. Но прежде чем мы начнем, давайте разберемся с типами вложенных списков.
Какие бывают типы вложенных списков?
Как мы знаем, Python – это язык программирования со слабой типизацией. Таким образом, мы можем встретить два типа списка списков:
- Регулярный список списков.
- Нерегулярный список списков.
Обычный список списков
Каждый элемент в регулярном списке списков называется подсписком, таким образом соблюдается единообразие типа элемента. Например: [[9, 8, 7], [6, 5, 4], [3, 2, 1]] – это обычный список списков как [9, 8, 7], [6, 5, 4] , [3, 2, 1] имеет тип list.
Нерегулярный список списков
Каждый элемент в нерегулярном списке списков называется либо подсписком, либо элементом, не являющимся списком (например, строкой или целым числом). Таким образом, возникает нестыковка по типу элемента. Например: [[9, 8, 7], [6, 5], 4, 3] – это неправильный список списков, поскольку [9, 8, 7] и [6, 5] относятся к типам list, тогда как 4 и 3 имеют тип int.
Сглаживание с помощью вложенных циклов for
Сглаживание списка списков с помощью вложенных циклов считается методом грубой силы для получения плоского списка. Мы можем выполнить этот метод, выбрав каждый элемент из двумерного списка и расположив его в одномерном списке.
Давайте рассмотрим следующий пример, который работает как для обычных, так и для нерегулярных списков списков.
# 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]
В приведенном выше примере мы определили функцию как flattenlist, которая принимает параметр как _2dlist. Затем мы использовали цикл for для перебора элементов вложенного списка и добавления их для создания плоского списка. Затем мы определили вложенный список и реализовали функцию flattenlist. В результате вложенный список успешно преобразовался в плоский список.
Сглаживание вложенного списка с использованием понимания списка
Сглаживание списка списков с помощью понимания списка считается элегантным подходом для получения плоского списка в зависимости от существующего двумерного списка. Однако этот подход предлагает менее интуитивное решение.
Рассмотрим следующий пример:
# 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]
Мы определили функцию и использовали оператор if, указывающий, если длина вложенного списка равна нулю, а затем возвращать вложенный список.
Если элемент данных в нулевом индексе является экземпляром списка, то индекс списка снова входит в функцию и добавляется к следующему индексу списка и так далее. В противном случае функция вернет элементы. Наконец, мы определили вложенный список и выполнили функцию. В результате список списков рекурсивно выровнялся.
Использование библиотек Python
Мы также можем использовать некоторые библиотеки языка программирования Python для сглаживания списка списков. Реализация этих библиотек описана ниже:
- Сглаживание списка списков с помощью функций и библиотек операторов.
Библиотека операторов предоставляет функцию 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 вместе с библиотекой операторов и определили пустой список как обычный список. Затем мы определили функцию convo для преобразования списка списков в плоский список. В этой функции мы использовали цикл for, в котором элементы из вложенного списка добавляются к пустому списку, который мы определили ранее. Позже мы определили вложенный список и выполнили функцию. В результате преобразование в плоский список прошло успешно.
- Сглаживание списка списков с помощью библиотеки itertools.
Библиотека itertools предоставляет функцию chain(), которая позволяет нам в идеале преобразовать вложенный в плоский список. Эта функция обрабатывает последовательные серии как одну серию, повторяя их через итерацию, передаваемую в качестве параметра последовательным способом.
# 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 и создали вложенный список. Затем мы использовали функцию chain() для преобразования заданного вложенного списка в плоский список. Наконец, мы вернули результат пользователям. В результате список списков выровнен успешно.
- Сглаживание списка списков с помощью библиотеки NumPy.
Библиотека NumPy предоставляет различные повседневные операции, включая объединение двумерных регулярных массивов по столбцам или по строкам. Мы будем использовать атрибут, известный как flat, чтобы получить одномерный итератор по массиву для достижения цели. Давайте рассмотрим следующий пример, чтобы понять использование функции конкатенации и атрибута flat.
# 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 вместе с ее атрибутом flat, чтобы сгладить элементы вложенного списка и объединить их в новый сплющенный список. Наконец, мы распечатали результат для пользователей. Таким образом, список списков выравнивается успешно.
Использование основных функций
Мы также можем выполнить задачу выравнивания, используя некоторые основные функции, которые предоставляет язык программирования Python.
- Сглаживание списка списков с помощью функции суммы
Мы можем рассматривать суммирование по внутренним спискам как еще одно решение проблемы. Мы передаем два аргумента функции суммы: первым параметром является iterable, который представляет собой вложенный список, а второй параметр – start, который является пустым списком для следующего случая, который служит начальным плоским списком, в который добавляются элементы данных внутреннего подсписки.
Можно сказать, что этот подход довольно удобен, так как нам не нужно ничего импортировать. Однако он работает медленнее, чем функции itertools() и chain(), когда во вложенном списке присутствует большое количество подсписок.
Рассмотрим следующий пример:
# 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]
Мы определили вложенный список. Затем мы использовали функцию sum(), превратили вложенный список в одномерный список и распечатали результирующий список для пользователей. В результате мы успешно преобразовали список списков в плоский список.
- Сглаживание списка списков с помощью ключевого слова Lambda
Мы можем определить анонимную функцию, используя ключевое слово 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]
В приведенном выше примере мы определили вложенный список. Затем мы использовали ключевое слово lambda вместе с аргументом, определяющим выражение для понимания списка. Затем мы распечатали их для пользователей. В результате мы успешно преобразовали двумерный нерегулярный список в плоский список.