Python разделить массив пополам

Разделить список на более мелкие списки (разделить пополам)

Несколько более общее решение (вы можете указать количество частей, которые хотите, а не просто разделять «пополам» ):

EDIT: обновленная запись для обработки нечетных длин списка

EDIT2: обновить сообщение снова на основе информационных комментариев Brians

def split_list(alist, wanted_parts=1): length = len(alist) return [ alist[i*length // wanted_parts: (i+1)*length // wanted_parts] for i in range(wanted_parts) ] A = [0,1,2,3,4,5,6,7,8,9] print split_list(A, wanted_parts=1) print split_list(A, wanted_parts=2) print split_list(A, wanted_parts=8) 

Когда список не делится равномерно (например, split_list ([1,2,3], 2)), это фактически возвращает списки wanted_parts + 1.

Это верно, я сомневался, каков должен быть правильный подход (иметь еще одну часть или иметь в последнем списке еще один элемент). Я обновлю свой пост, спасибо за комментирование.

На самом деле, это все равно не сработает: у вас может быть остаток> 1. split_list (range (5), 3) даст 5 списков с приведенным выше кодом. Работать с этими делами также сложнее, так как вам нужно распределить список равномерно (например, для списка из 19 элементов из 10 частей вам не нужен элемент 9 * 1 и один с 9).

Я думаю, что лучшим способом было бы: length = len (alist); return [alist [i * length // wanted_parts: (i + 1) * length // wanted_parts] для i в диапазоне (wanted_parts)]. Таким образом, вы получаете равномерно возможный дистрибутив и всегда получаете точно нужные элементы_партов (даже пэды с [], если_парт_парт> len (A))

Источник

Разбить список на равные части в Python 3

В этой статье я рассмотрю способы, с помощью которых можно разбить список на части четкого размера на основе пользовательских методов или с помощью встроенных модулей.

Введение

Разбиение строк и списков — это типичная задача программиста. Иногда нам приходится разбивать наши данные особым образом, но чаще — на равные части.

Язык не имеет встроенной функции для этого, и в этом уроке я покажу, как разбить список в Python.

В большинстве случаев это можно сделать с помощью генераторов:

def func(lst, n): for i in range(0, len(lst), n): yield lst[i:i + n]

Хотя есть и другие интересные способы сделать это, каждый со своими плюсами и минусами!

На равные части из n элементов

Список может быть разделен на основе размера определенного фрагмента. Это означает, что мы можем определить размер данной части. Если подмножество списка не вписывается в размер определенного фрагмента, заполнители должны быть вставлены вместо пустых держателей элементов. В этих случаях я буду использовать функцию None.

Давайте создадим новый файл и начнем программирование:

def func_chunk(lst, n): for x in range(0, len(lst), n): e_c = lst[x : n + x] if len(e_c) < n: e_c = e_c + [None for y in range(n - len(e_c))] yield e_c print(list(func_chunk([9, 8, 7, 6, 5, 4, 3, 2, 1], 3)))

Приведенная выше функция func_chunk принимает аргументы: lst для списка и chunk_size для числа, на которое его нужно разделить. Функция выполняет итерацию по списку с приращением размера фрагмента n.

Ожидается, что каждый фрагмент будет иметь размер, заданный в качестве аргумента. Если элементов недостаточно для разделения на один и тот же размер, оставшиеся неиспользуемые элементы заполняются None.

Список был разделен на равные части по 3 элемента в каждой.

Python имеет утилиты для упрощения этого процесса. Мы можем использовать функцию zip_longest из itertools для упрощения предыдущей функции.

Давайте создадим новый файл и напишем следующий код:

from itertools import zip_longest def func_chunk_itertools(lst): i_ = iter(lst) return list(zip_longest(i_, i_, i_, i_)) print(func_chunk_itertools([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]))

Этот код повторяет элементы и возвращает фрагмент желаемой длины на основе предоставленных вами аргументов.

Мы поместили в коде 4 аргументf i_. Функция zip_longest агрегирует и возвращает элементы из каждой итерации. В этом случае она будет агрегировать элементы из списка, который повторяется 4. Затем создается множество итераторов, содержащих 4 последовательных элементов, которые после преобразуются в список и возвращаются.

Вывод программы будет таков:

[(0, 1, 2, 3), (4, 5, 6, 7), (8, 9, 10, 11), (12, 13, 14, None)]

Эта более короткая функция приводит к тому же выводу программы. Однако этот метод более ограничен, так как нам приходится вручную писать, сколько элементов мы хотим в коде, и немного неудобно просто помещать кучу i_ в вызов zip_longest.

Лучшим решением было бы использование генераторов. Давайте создадим новый файл:

def func_chunks_generators(lst, n): for i in range(0, len(lst), n): yield lst[i : i + n] print( list( func_chunks_generators( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 54, 3, 2, 2, 1], 4 ) ) )

Этот генератор дает подсписок, содержащий n элементов. В конце концов, это дало бы подсписок для каждой части.

[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 8, 7], [6, 54, 3, 2], [2, 1]]

Этот метод работает лучше всего, если вам не нужно заполнение кода с помощью None или иным образом.

На n равных частей

В предыдущем разделе мы разбили список на основе размера отдельных фрагментов так, чтобы каждый фрагмент имел одинаковое количество элементов. Есть и другой способ интерпретировать эту проблему.

Что мы делаем, когда хотим разбить список не по количеству элементов в каждом фрагменте, а по количеству фрагментов, которые мы хотим создать?

Например, вместо того, чтобы разбивать список на части, где каждая часть имеет 7 элементов, мы хотим разбить список на 7 равных частей. В этом случае мы можем не знать размер каждой части.

Логика аналогична предыдущим методам, однако размер части — это предельное значение длины списка, деленное на количество требуемых частей. Как и в предыдущих примерах кода, если в части есть свободные места, они будут заполнены значением None:

import math def func_chunks_num(lst, c_num): n = math.ceil(len(lst) / c_num) for x in range(0, len(lst), n): e_c = lst[x : n + x] if len(e_c) < n: e_c = e_c + [None for y in range(n - len(e_c))] yield e_c print(list(func_chunks_num([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], c_num=3)))

Мы определяем, сколько списков нам нужно создать и сохранить это значение в n. Затем мы создаем подсписок для двух элементов одновременно, заполняя выходные данные в случае, если размер нашего фрагмента меньше желаемой длины.

[[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, None]]

Как видно из приведенных выше выходных данных, список был разделен на 3 отдельных подспискf равных размеров на основе предоставленного аргумента c_num.

Заключение

В этой статье мы рассмотрели способы, с помощью которых можно разбить список на части равного размера на основе пользовательских методов и с помощью встроенных модулей.

Методы, упомянутые в этой статье, не ограничиваются теми, которые были прописаны здесь, но есть множество других творческих способов, с помощью которых вы также можете разделить свой список на равные части!

Программирую на Python с 2017 года. Люблю создавать контент, который помогает людям понять сложные вещи. Не представляю жизнь без непрерывного цикла обучения, спорта и чувства юмора.

Ссылка на мой github есть в шапке. Залетай.

Источник

Как разделить список на части в Python

Существуют следующие методы разделения списка на части в Python:

1. Использование len(): метод len() возвращает длину списка и использует floor деление.
2. Использование понимания списка: разбейте список на части и укажите N для понимания списка.
3. Использование цикла for: используйте цикл for, чтобы разделить список на разные части.
4. Использование numpy array_split() позволяет разбить массив на заданное количество массивов.

Способ 1: использование метода len()

Чтобы разделить список в Python, вы можете использовать метод «len()» с iterable в качестве списка, чтобы найти его длину, а затем разделить длину на 2, используя оператор «//», чтобы найти middle_index списка.

Как видно из вывода, мы разделили список ровно пополам. Мы использовали оператор двоеточия(:) для доступа к первой и второй половине разделенного списка.

Как разбить список на n частей в Python

Чтобы разделить список на n частей в Python, используйте функцию numpy.array_split(). Функция np.split() разбивает массив на несколько подмассивов.

Метод numpy array_split() возвращает список из n массивов Numpy, каждый из которых содержит примерно одинаковое количество элементов из списка.

В этом примере мы разделили список на 3 части.

Разделение списка на четные части по N элементов в Python

Список можно разделить в зависимости от размера определенного фрагмента. Это означает, что мы можем определить размер части. Если подмножество списка не соответствует размеру определенного фрагмента, необходимо вставить заполнители на место держателей пустых элементов.

Поэтому мы будем использовать None в качестве фильтра для заполнения этих пустых держателей элементов.

print ( list ( list_split ( [ 11 , 21 , 31 , 41 , 51 , 61 , 71 , 81 , 91 , 101 , 111 , 112 , 113 ] , 7 ) ) )

Список разбит на равные части по 7 элементов в каждой.

Приведенная выше функция list_split() принимает аргументы: listA для списка и chunk_size для числа, на которое нужно разделить. Затем функция выполняет итерацию по списку с приращением размера фрагмента n.

Ожидается, что каждый фрагмент будет иметь размер, указанный в качестве аргумента. Если элементов недостаточно для разделения одинакового размера, оставшиеся неиспользуемые элементы заполняются None.

Способ 2: использование понимания списка

Используя понимание списка, мы можем разделить «исходный список» и «создать фрагменты». Чтобы разделить список на части, укажите N в синтаксисе «понимания списка», и он создаст новый список с N частями элементов.

Источник