Как обрезать массив питон

Срезы#

Списки, строки, кортежи и другие последовательности python кроме обычной индексации поддерживают индексацию срезами (slices). Рассмотрим на примере строк.

import string s = string.ascii_lowercase print(s) 

abcdefghijklmnopqrstuvwxyz

Итак, у нас есть строка a , состоящая из строчных символов английского алфавита.

Если мы хотим извлечь подстроку, начиная с позиции start включая и заканчивая позицией stop не включая, то применяется синтаксис

Например, если нас часть строки с 1-го по 5-ый символ (нумерация с нуля), мы запишем

Если нас интересует подстрока с самого начала строки до какого-то символа с индексом stop (не включая), то можно опускать первый параметр среза, т.е. допускается синтаксис

Следующие два среза синонимичны и оба возвращают первые три символа.

То же самое справедливо и про второй параметр: если нас интересует подстрока до самого конца исходной строки, начиная с символа с индексом start (включая), то можно опустить второй параметр, т.е. допускается синтаксис

Следующие два среза синонимичны и оба возвращают символы с 23-го по конце.

Допускается даже опустить оба параметра. Тогда возвращается копия строки.

abcdefghijklmnopqrstuvwxyz

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

# символы '|' по бокам, чтобы наглядно показать края строки print(f"|s[-100:100]>|") print(f"|s[90:100]>|") print(f"|s[5:2]>|") 

|abcdefghijklmnopqrstuvwxyz| || ||

Срезы с шагом#

Для разнообразия теперь будем брать срезы от списков.

Итак, у нас есть список L чисел от 0 до 9.

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

Например, чтобы вырезать каждый второй элемент списка L , начиная с 1-го и заканчивая 8-м (не включая), необходимо записать.

Как и прежде, первые два параметра можно опускать, если start и stop совпадают с началом и концом списка соответственно.

Ниже берется каждый второй элемент всего списка.

Шаг может быть отрицательным, но тогда start должен быть больше step , чтобы вернулась не пустая подпоследовательность. При этом, как и до этого, start попадает в срез, а stop нет.

Получить последовательность в обратном порядке (обратить последовательность) можно синтаксисом

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

Присваивание по срезам#

Если последовательность изменяемая (список, например), то допускается присваивание по срезу.

Если шаг не указан, то можно заменить элементы среза в списке элементами коллекции справа от оператора “ = ” вне зависимости от того, совпадает ли количество элементов в коллекции справа от оператора “ = ” с размером среза слева от оператора “ = ”.

Например, код в ячейке ниже заменяет первые два элемента списка L на новые два элемента (0 заменяется на 3.14, 1 заменяется на 42).

Код в ячейке ниже заменяет первые два элемента (3.14 и 42 после предыдущей замены) на сразу три новых элемента, тем самым расширяя список.

Следующим синтаксисом можно удалить первых два элемента.

Хотя для этого предпочтительнее воспользоваться синтаксисом

Если шаг указан, то количество элементов в коллекции справа от “ = : должно совпадать с количеством элементов в срезе

L = list(range(10)) # Oк print(L[::2]) L[::2] = L[1::2] # Ошибка print(L) L[::2] = [] 

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

--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Input In [16], in () 7 # Ошибка 8 print(L) ----> 9 L[::2] = [] ValueError: attempt to assign sequence of size 0 to extended slice of size 5

Срезы массивов NumPy #

Срезы массивов NumPy введут себя очень похоже с двумя основными отличиями (документация NumPy про срезы):

1. при присваивании по срезу размер массива не может измениться вне зависимости от того, указан шаг или нет;
2. допускается делать многомерные срезы.

Срезы одномерных массивов#

Если массив одномерный, то роль играет только первое отличие.

import numpy as np array = np.arange(10) print(array) 

array[::2] = [9, 7, 5, 3, 1] print(array) 

Многомерные срезы#

Но если массив многомерный, то можно делать срезы сразу вдоль нескольких осей. Рассмотрим на примере двухмерных массивов.

matrix = np.arange(1, 26).reshape(5, 5) print(matrix) 

[[ 1 2 3 4 5] [ 6 7 8 9 10] [11 12 13 14 15] [16 17 18 19 20] [21 22 23 24 25]]

Обратим внимание, что выражением matrix[i, j] мы получаем элемент массива matrix на пересечении i -й строки и j -й строки.

Такая же логика обобщается и на срезы. Например, получить j -й столбец двухмерного массива matrix можно выражением

То есть указать вдоль первой оси ( axis=0 ) указывается полный срез (все строки), а вдоль второй оси ( axis=1 ) указывается число j (только j -й столбец). Получим таким образом нулевой столбец.

Итого, процесс получения двухмерного среза можно мысленно представить в следующем виде:

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

Одну i -ю строку можно получить как выражением matrix[i, :] , так и выражением matrix[i] . Рассмотрим более содержательные примеры.

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

Если требуется получить каждый второй столбец, то вдоль первой оси ( axis=0 ) указывается полный срез (все строки), а вдоль второй оси ( axis=1 ) указывается полный срез с шагом 2 (каждый второй столбец).

array([[ 1, 3, 5], [ 6, 8, 10], [11, 13, 15], [16, 18, 20], [21, 23, 25]])

В качестве последнего примера рассмотрим получение срезом элементов из каждой второй строки и каждого второго столбца.

array([[ 1, 3, 5], [11, 13, 15], [21, 23, 25]])

Присваивание по срезу#

Срезы ссылаются на данные исходного массива. По ним можно производить присваивание. Например, можно целиком заменить столбец матрицы.

matrix[:, 0] = np.arange(-5, 0) print(matrix) 

[[-5 2 3 4 5] [-4 7 8 9 10] [-3 12 13 14 15] [-2 17 18 19 20] [-1 22 23 24 25]]

В примере выше формы среза слева от “ = ” и массива справа от “ = ” совпадают. Это необязательное условие: работают правила броадкастинга, т.е. массив справа от оператора “ = ” может быть расширен до размера среза слева от оператора “ = ”, если их формы совместимы и срез сможет поместить в себе массив по всем измерениям. Например, прибавим к всем элемента первой строки 100, а каждый второй элемент последней строки сделаем равными 42.

matrix[0, :] += 100 matrix[-1, ::2] = 42 print(matrix) 

[[ 95 102 103 104 105] [ -4 7 8 9 10] [ -3 12 13 14 15] [ -2 17 18 19 20] [ 42 22 42 24 42]]

Источник

Understanding Array Slicing in Python

Array slicing in Python is a technique in programming that allows you to extract a portion of an array, or a sequence of elements in Python. This technique plays a crucial role in many data manipulation and analysis tasks, and is widely used in various applications ranging from scientific computing, web development, and data analysis.

In this article, you will learn the fundamentals of array slicing in Python, including syntax, examples, and best practices for using this powerful feature in your code.

What is Array Slicing in Python?

Array slicing in Python is a powerful feature that allows you to create new sub-arrays from existing arrays by specifying the starting and ending indices. The new sub-array is a portion of the original array, and it can be used for a variety of purposes, such as processing specific data, managing memory usage, and more.

Array slicing can be easily done following the Python slicing method. For which the syntax is given below.

Again, Python also provides a function named slice() which returns a slice object containing the indices to be sliced. The syntax for using this method is given below.

• start is the starting index from which we need to slice the array arr. By default set to 0,
• stop is the ending index, before which the slicing operation would end. By default equal to the length of the array,
• step is the steps the slicing process would take from start to stop. By default set to 1.

Methods for Array Slicing in Python

So now that we know the syntax for using both the methods, let us look at some examples and try to understand the slicing procedure.

In the following examples, we are going to consider both arrays from the array module as well as NumPy arrays.

1. With one parameter

Default values for start, stop and step are equal to 0, length of the array, and 1 respectively. Hence, specifying either one of the start or stop, we can slice an array.

import array import numpy as np #array initialisation array_arr= array.array('i',[1,2,3,4,5]) np_arr = np.array([6,7,8,9,10]) #slicing array with 1 parameter print("Sliced array: ", array_arr[:3]) print("Sliced NumPy array: ", np_arr[:4])

Sliced array: array('i', [1, 2, 3]) Sliced NumPy array: [6 7 8 9]

Here, we have initialized two arrays one from array module and another NumPy array. Slicing both of them using one parameter results are shown in the output. As we can see for both the cases, start and step are set by default to 0 and 1. The sliced arrays contain elements of indices 0 to (stop-1). This is one of the quickest methods of array slicing in Python.

2. Array Slicing in Python With two parameters

Again, specifying any two parameters among the start, stop and end, you can perform array slicing in Python by considering default value for the third parameter.

import array import numpy as np #array initialisation array_arr= array.array('i',[1,2,3,4,5]) np_arr = np.array([6,7,8,9,10]) #slicing array with 2 parameters print("Sliced array: ", array_arr[2:5]) print("Sliced NumPy array: ", np_arr[1:4])

Sliced array: array('i', [3, 4, 5]) Sliced NumPy array: [7 8 9]

In this case, too, the sliced array module array and NumPy array contain elements of indices specified start to (stop-1) with step set to 1. The output is hence justified.

3. With the step parameter

When all the three parameters are mentioned, you can perform array slicing in Python from index start to (stop-1) with each index jump equals to the given step.

Look at the example below to have a clear understanding.

import array import numpy as np #array initialisation array_arr= array.array('i',[1,2,3,4,5,6,7,8,9,10]) np_arr = np.array([11,12,13,14,15,16,17,18,19,20]) #slicing array with step parameter print("Sliced array: ", array_arr[1:8:2]) print("Sliced NumPy array: ", np_arr[5:9:3])

Sliced array: array('i', [2, 4, 6, 8]) Sliced NumPy array: [16 19]

Similarly, here we get sliced arrays with values from the arrays from given indices start to stop-1. The only difference here is the step value, this time it is specified as 2 and 3 for both array module array and NumPy array respectively. Hence this time each index jump is of the value of the given step.

4. Array Slicing in Python with the slice() Method

The slice() method in Python returns a sequence of indices ranging from start to stop-1 with the given step value.

Similar to the previous cases, here also the default values of start and stop are 0 and the step is equal to 1.

import array import numpy as np #array initialisation array_arr = array.array('i',[1,2,3,4,5,6,7,8,9,10]) np_arr = np.array([11,12,13,14,15,16,17,18,19,20]) s = slice(3,9,3) #slicing array with slice() print("Sliced array: ", array_arr[s]) print("Sliced NumPy array: ", np_arr[s])

Sliced array: array('i', [4, 7]) Sliced NumPy array: [14 17]

Here, firstly we have initialized two arrays, one from array module and the other from NumPy module. The slice() method is called with start, stop and step mentioned as 3, 9 and 3 respectively. Hence, when we pass this sequence s to the arrays, we get sliced arrays with values containing the elements at indices 3 and 6.

Hence, the output is justified.

Note: Always the original array is kept intact and stays untouched. If needed, the sliced array can be stored in some variable.

Conclusion

So in this tutorial, we got to learn about the concept of array slicing in Python. For any further questions feel free to comment it below.

References

Источник