Как найти положительные элементы в массиве python

Given a list of list, the task is to get only positive element from given list. Below are some ways to solve the above problem. 

Method #1: Using Iteration 

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

Time complexity: O(n*m), where n is length of Input list and m is length of sub lists in Input list.

Auxiliary Space: O(k), where k is length of Output list.

  Method #2: Using map and list Comprehension 

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

Time complexity: O(n*n), where n is the length of the test_list. The  map and list Comprehension takes O(n*n) time
Auxiliary Space: O(n), where n is the number of elements in the input list 

  Method #3: Using List Comprehension 

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

Method #4: Using map, lambda, filter  Here is an example of how you can use the map() function, the filter() function, and a lambda function to extract the positive elements from each sublist in a list of lists:

The code first initializes a list test_list with two sublists, each containing a mix of positive and negative integers. Then, it uses the map() function, the filter() function, and a lambda function to extract the positive elements from each sublist.

The map() function applies the lambda function to each element in the list test_list, which is a sublist in this case. The lambda function, in turn, uses the filter() function to filter out all the elements in the sublist that are not greater than 0. This results in a list of sublists, where each sublist contains only the positive elements from the corresponding sublist in the original list. Finally, the list() function is used to convert the map object returned by map() into a list, which is stored in the variable result.

The list after filtering positive elements : [[10, 222], [42, 99]]

This approach has a time complexity of O(nm), where n is the number of sublists in the list and m is the number of elements in each sublist, because it requires one iteration over each element in each sublist. The space complexity is also O(nm), because a new list with size equal to the number of elements in the original list is created.

Method #5: Using Regular Expressions

In this approach, we use regular expressions to match positive integers in each sublist. The regular expression pattern bd+b matches one or more digits (d+) surrounded by word boundaries (b). This ensures that only whole numbers are matched, and not negative numbers with a minus sign.

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

Time complexity: O(n*m), where n is length of Input list and m is length of sub lists in Input list.
Auxiliary Space: O(k), where k is length of Output list.

Last Updated :
09 May, 2023

Like Article

Save Article

В Python мы можем использовать функцию numpy.where() для выбора элементов из массива numpy в зависимости от условия.

Не только это, но мы можем выполнять некоторые операции с этими элементами, если условие выполняется.

Давайте посмотрим, как мы можем использовать эту функцию, на нескольких наглядных примерах!

Синтаксис

Эта функция принимает массив типа numpy (например, массив целых и логических значений NumPy).

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

Например, условие может принимать значение массива ([[True, True, True]]), который является логическим массивом типа numpy. (По умолчанию NumPy поддерживает только числовые значения, но мы также можем преобразовать их в bool).

Например, если условием является массив ([[True, True, False]]), а наш массив – a = ndarray ([[1, 2, 3]]), при применении условия к массиву (a [:, condition ]), мы получим массив ndarray ([[1 2]]).

import numpy as np

a = np.arange(10)
print(a[a <= 2]) # Will only capture elements <= 2 and ignore others

Вывод:

array([0 1 2])

ПРИМЕЧАНИЕ. То же условие условия также может быть представлено как <= 2. Это рекомендуемый формат для массива условий, так как записывать его как логический массив очень утомительно.

Но что, если мы хотим сохранить размерность результата и не потерять элементы из нашего исходного массива? Для этого мы можем использовать numpy.where().

numpy.where(condition [, x, y])

У нас есть еще два параметра x и y. Что это? По сути, это означает, что если условие выполняется для некоторого элемента в нашем массиве, новый массив будет выбирать элементы из x.

В противном случае, если это false, будут взяты элементы из y.

При этом наш окончательный выходной массив будет массивом с элементами из x, если условие = True, и элементами из y, если условие = False.

Обратите внимание, что хотя x и y необязательны, если вы указываете x, вы также ДОЛЖНЫ указать y. Это потому, что в этом случае форма выходного массива должна быть такой же, как и входной массив.

ПРИМЕЧАНИЕ. Та же логика применима как для одномерных, так и для многомерных массивов. В обоих случаях мы выполняем фильтрацию по условию. Также помните, что формы x, y и условия передаются вместе.

Теперь давайте рассмотрим несколько примеров, чтобы правильно понять эту функцию.

Предположим, мы хотим взять только положительные элементы из массива numpy и установить для всех отрицательных элементов значение 0, давайте напишем код, используя numpy.where().

1. Замена Elements на numpy.where()

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

import numpy as np

# Random initialization of a (2D array)
a = np.random.randn(2, 3)
print(a)

# b will be all elements of a whenever the condition holds true (i.e only positive elements)
# Otherwise, set it as 0
b = np.where(a > 0, a, 0)

print(b)

Возможный выход:

[[-1.06455975  0.94589166 -1.94987123]
 [-1.72083344 -0.69813711  1.05448464]]
[[0.         0.94589166 0.        ]
 [0.         0.         1.05448464]]

2. Использование только с условием

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

import random
import numpy as np

a = np.random.randn(2, 3)
b = np.where(a > 0)
print(b)

Если вы сейчас попытаетесь запустить приведенный выше код, с этим изменением вы получите следующий результат:

(array([0, 1]), array([2, 1]))

Если вы внимательно посмотрите, b теперь представляет собой кортеж из множества массивов. И в каждом массиве находится положительный элемент. Что это значит? Всякий раз, когда мы предоставляем только условие, эта функция фактически эквивалентна np.asarray.nonzero().

В нашем примере np.asarray (a> 0) вернет логический массив после применения условия, а np.nonzero (arr_like) вернет индексы ненулевых элементов arr_like.

Рассмотрим более простой пример:

import numpy as np

a = np.arange(10)

b = np.where(a < 5, a, a * 10)

print(a)
print(b)

[0 1 2 3 4 5 6 7 8 9]
[ 0  1  2  3  4 50 60 70 80 90]

Здесь условием является <5, что будет массивом типа numpy [True True True True True False False False False], x – это массив a, а y – массив a * 10. Итак, мы выбираем из только если a <5, и от a * 10, если a> 5.

Таким образом, все элементы> = 5 преобразуются путем умножения на 10. Это действительно то, что мы получаем!

Трансляция с помощью numpy.where()

Если мы предоставим все массивы condition, x и y, numpy будет транслировать их вместе.

import numpy as np

a = np.arange(12).reshape(3, 4)

b = np.arange(4).reshape(1, 4)

print(a)
print(b)

# Broadcasts (a < 5, a, and b * 10)
# of shape (3, 4), (3, 4) and (1, 4)
c = np.where(a < 5, a, b * 10)

print(c)

Вывод

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[0 1 2 3]]
[[ 0  1  2  3]
 [ 4 10 20 30]
 [ 0 10 20 30]]

Опять же, здесь вывод выбирается на основе условия, поэтому все элементы, но здесь b, транслируются в форму a. (Одно из его измерений имеет только один элемент, поэтому при трансляции ошибок не будет).

Итак, b теперь станет [[0 1 2 3] [0 1 2 3] [0 1 2 3]], и теперь мы можем выбирать элементы даже из этого транслируемого массива. Таким образом, форма вывода такая же, как у файла.

Заключение

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

29.12.2019Python, Программы Python

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

Initial List is : [[10, -11, 222], [42, -222, -412, 99, -87]]
Modified list is : [[10, 222], [42, 99]]

С помощью метода numpy where() элементы массива ndarray Numpy, удовлетворяющие условиям, могут быть заменены или выполнена заданная обработка. Вы должны установить numpy для этого урока. Также можете проверить свою версию numpy.

Функция np.where() в Python возвращает элементы, выбранные из x или y в зависимости от условия. Если вы хотите выбрать элементы на основе условия, используйте функцию np where(). Функция принимает условное выражение в качестве аргумента и возвращает новый массив numpy.

Синтаксис

Параметры

1. condition: условное выражение, которое возвращает массив логических значений Numpy.
2. x, y: массивы(необязательно, т. е. оба передаются или не передаются)

• Если в методе numpy.where() указаны все аргументы -> condition, x и y, то он вернет элементы, выбранные из x и y, в зависимости от значений в логическом массиве, полученном по условию. Все три массива должны быть одного размера.
• Если аргументы x и y не передаются, а передается только аргумент условия, то он возвращает кортеж массивов(по одному для каждой оси), содержащих индексы элементов, которые имеют значение True в логическом массиве numpy, возвращаемом условием.

Это говорит о том, что если условие возвращает True для некоторого элемента в нашем массиве, новый массив будет выбирать элементы из x. В противном случае, если False, предметы из y будут взяты.

При этом наш окончательный выходной массив будет массивом с элементами из x, где условие = True, и элементами из y, когда условие = False.

Здесь следует отметить одну вещь: хотя x и y являются необязательными, если вы указываете x, вы ДОЛЖНЫ также указать y. Вы должны сделать это, потому что в этом случае форма выходного массива должна быть такой же, как входной массив.

Возвращаемое значение

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

Пример

Выход:

Numpy.where() выполняет итерацию по массиву bool, и для каждого True он дает соответствующий массив элементов x, а для каждого False он дает соответствующий элемент из массива y. Таким образом, он возвращает массив элементов из x, где условие равно True, и элементы из y в другом месте.

Условие может принимать значение массива([[True, True, True]]), который представляет собой логический массив типа numpy. По умолчанию NumPy поддерживает только числовые значения, но мы также можем привести их к типу bool.

Давайте возьмем другой пример, если условие — это массив([[True, True, False]]), а наш массив — это а = ndarray([[1, 2, 3]]), при применении условия к массиву(а[ :, условие]), мы получим массив ndarray([[1 2]]).

Замена элементов на numpy.where()

Мы будем использовать функцию np.random.randn() для создания двумерного массива и будем выводить только положительные элементы. См. код.

Выход:

Из вывода вы можете видеть, что эти элементы с отрицательными значениями удалены, и вместо них 0 заменяется отрицательными значениями.

Использование np where() с несколькими условиями

Если каждое условное выражение заключено в() и & или | используется, обработка применяется к нескольким условиям.

Выход:

Из вывода видно, что мы применили три условия с помощью оператора and и оператора or. Если значение элементов массива находится в диапазоне от 0,1 до 0,99 или 0,5, то он вернет -1, иначе 19.

Даже в случае нескольких условий нет необходимости использовать np.where() для получения логического значения ndarray.

Обработка элементов, удовлетворяющих условию

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

Выход:

Вы можете видеть, что он будет умножать каждый элемент на 10, если какой-либо элемент меньше 10. В противном случае он вернет 19 на этом месте.

Бродкастинг с помощью numpy.where()

Если мы предоставим все массивы условий, x и y, numpy будет транслировать их вместе.

См. следующий код.

Выход: