Np argsort: Сортировка с помощью argsort в python

argsort | NumPy


numpy.argsort(a, axis=-1, kind='quicksort', order=None)


Функция argsort() возвращает индексы, сортирующие элементы исходного массива.

Параметры:

a — массив NumPy или подобный массиву объект.

Исходный массив.

axis — целое число (необязательный параметр).

Определяет ось вдоль которой выполняется сортировка элементов. Если равен None, то сортировка выполняется по сжатому до одной оси представлению исходного массива. По умолчанию axis = -1, что соответствует сортировке по последней оси массива.

kind — строка (необязательный параметр).

Одна строка из множества {'quicksort', 'mergesort', 'heapsort', 'stable'}, которая указывает на алгоритм сортировки. Значение 'stable' приводит к автоматическому выбору устойчивого, лучшего алгоритма для типа данных сортируемого массива. По умолчанию kind = 'quicksort'.

order — строка или список строк (необязательный параметр).

В случае, когда массив a является структурированным, и его полям присвоено имя, то данный параметр позволяет указать порядок в котором они должны учавствовать в сортировке Если указаны не все поля, то неуказанные будут использоваться в том порядке в котором они перечислены в dtype структурированного массива.

Возвращает:

ndarray — массив NumPy

Массив индексов, которые сортируют элементы исходного массива вдоль указанной оси axis. Если a это одномерный массив, то a[np.argsort(a)] вернет его отсортированным. Получить отсортированные многомерные массивы можно выполнив либо итерирование по ним с использованием возвращаемого массива индексов, либо воспользовавшись командой np.take_along_axis(a, np.argsort(a, axis = ax), axis=ax).

Примеры

Одномерные массивы:

>>> import numpy as np
>>> 
>>> a = np. random.randint(0, 20, 10)
>>> a
array([ 8, 17,  8, 14, 14, 16,  4,  3, 12,  6])
>>> 
>>> ind = np.argsort(a)
>>> ind
array([7, 6, 9, 0, 2, 8, 3, 4, 5, 1], dtype=int32)
>>> 
>>> a[ind]
array([ 3,  4,  6,  8,  8, 12, 14, 14, 16, 17])

Двумерные массивы:

>>> a = np.random.randint(0, 20, (3, 4))
>>> a
array([[19,  3,  5,  6],
       [ 0,  0,  3,  2],
       [13, 14,  8, 13]])
>>> 
>>>               
>>> #  Индексы отсортированных строк:
... ind_r = np.argsort(a)    #  эквивалентно ind_r = np.argsort(a, axis = 1)
>>> ind_r
array([[1, 2, 3, 0],
       [0, 1, 3, 2],
       [2, 0, 3, 1]], dtype=int32)
>>> 
>>> 
>>> #  Индексы отсортированных столбцов:
... ind_c = np.argsort(a, axis = 0)
>>> ind_c
array([[1, 1, 1, 1],
       [2, 0, 0, 0],
       [0, 2, 2, 2]], dtype=int32)

Самый простой способ получить отсортированный массив — воспользоваться функцией np. take_along_axis():

>>> np.take_along_axis(a, ind_r, axis = 1)
array([[ 3,  5,  6, 19],
       [ 0,  0,  2,  3],
       [ 8, 13, 13, 14]])
>>> 
>>> np.take_along_axis(a, ind_c, axis = 0)
array([[ 0,  0,  3,  2],
       [13,  3,  5,  6],
       [19, 14,  8, 13]])

Функция np.argsort() так же позволяет выполнить лексикографическую сортировку структурированного массива:

>>> arr = np.array([(0, 12), (0, 11), (1, 55),
...                 (0, 87), (1, 54), (1, 21)],
...                dtype = np.dtype([('a', int), ('b', int)]))
>>> arr
array([(0, 12), (0, 11), (1, 55), (0, 87), (1, 54), (1, 21)],
      dtype=[('a', '<i4'), ('b', '<i4')])
>>> 
>>> ind = np.argsort(arr, order = ['a', 'b'])
>>> ind
array([1, 0, 3, 5, 4, 2], dtype=int32)
>>> 
>>> arr[ind]
array([(0, 11), (0, 12), (0, 87), (1, 21), (1, 54), (1, 55)],
      dtype=[('a', '<i4'), ('b', '<i4')])
>>> 
>>> 
>>> ind = np. argsort(arr, order = ['b', 'a'])
>>> ind
array([1, 0, 5, 4, 2, 3], dtype=int32)
>>> 
>>> arr[ind]
array([(0, 11), (0, 12), (1, 21), (1, 54), (1, 55), (0, 87)],
      dtype=[('a', '<i4'), ('b', '<i4')])

Можно ли использовать argsort в порядке убывания?

Если вы отрицаете массив, самые низкие элементы становятся самыми высокими элементами и наоборот. Таким образом, индексы n самых высоких элементов равны:

(-avgDists).argsort()[:n]

Другой способ рассуждать об этом, как упоминалось в комментариях , состоит в том, чтобы заметить, что большие элементы идут последними в argsort. Таким образом, вы можете прочитать из хвоста argsort, чтобы найти n самых высоких элементов:

avgDists. argsort()[::-1][:n]

Оба метода имеют O(n log n) во временной сложности, потому что вызов argsort является здесь доминирующим термином. Но у второго подхода есть хорошее преимущество: он заменяет отрицание O(n) массива срезом O(1) . Если вы работаете с небольшими массивами внутри циклов, то вы можете получить некоторый выигрыш в производительности, избегая этого отрицания, а если вы работаете с огромными массивами, то вы можете сэкономить на использовании памяти, потому что отрицание создает копию всего массива.

Обратите внимание , что эти методы не всегда дают эквивалентные результаты: если требуется стабильная реализация сортировки в argsort, например если передать ключевое слово аргумент kind='mergesort' , то первая стратегия сохранит стабильность сортировки, но вторая стратегия нарушит стабильность (т. е. позиции равных элементов будут перевернуты).

Пример таймингов :

Используя небольшой массив из 100 поплавков и хвост длиной 30, метод просмотра был примерно на 15% быстрее

>>> avgDists = np. random.rand(100)
>>> n = 30
>>> timeit (-avgDists).argsort()[:n]
1.93 µs ± 6.68 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
>>> timeit avgDists.argsort()[::-1][:n]
1.64 µs ± 3.39 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
>>> timeit avgDists.argsort()[-n:][::-1]
1.64 µs ± 3.66 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Для больших массивов argsort является доминирующим, и нет существенной разницы во времени

>>> avgDists = np.random.rand(1000)
>>> n = 300
>>> timeit (-avgDists).argsort()[:n]
21.9 µs ± 51.2 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> timeit avgDists.argsort()[::-1][:n]
21.7 µs ± 33.3 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> timeit avgDists.argsort()[-n:][::-1]
21.9 µs ± 37.1 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Пожалуйста, обратите внимание, что комментарий от nedim ниже неверен. Усечение до или после реверсирования не имеет никакого значения в эффективности, поскольку обе эти операции только шагают по виду массива по-разному и фактически не копируют данные.

Эффективно сортировать массив numpy в порядке убывания? Ru Python

Я удивлен, что этот конкретный вопрос не задавался раньше, но я действительно не нашел его на SO или документации np.sort .

Скажем, у меня есть случайный массив numpy, содержащий целые числа, например:

 > temp = np.random.randint(1,10, 10) > temp array([2, 4, 7, 4, 2, 2, 7, 6, 4, 4]) 

Если я его сортирую, по умолчанию получаю по возрастанию:

 > np.sort(temp) array([2, 2, 2, 4, 4, 4, 4, 6, 7, 7]) 

но я хочу, чтобы решение сортировалось в порядке убывания.

Теперь я знаю, что всегда могу:

 reverse_order = np.sort(temp)[::-1] 

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

temp[::-1].sort() сортирует массив на месте, np.sort(temp)[::-1] создает новый массив.

 In [25]: temp = np.random.randint(1,10, 10) In [26]: temp Out[26]: array([5, 2, 7, 4, 4, 2, 8, 6, 4, 4]) In [27]: id(temp) Out[27]: 139962713524944 In [28]: temp[::-1].sort() In [29]: temp Out[29]: array([8, 7, 6, 5, 4, 4, 4, 4, 2, 2]) In [30]: id(temp) Out[30]: 139962713524944 

Для коротких массивов я предлагаю использовать np.argsort() , найдя индексы отсортированного отрицательного массива, который немного быстрее, чем реверсирование отсортированного массива:

 In [37]: temp = np.random.randint(1,10, 10) In [38]: %timeit np.sort(temp)[::-1] 100000 loops, best of 3: 4.65 µs per loop In [39]: %timeit temp[np.argsort(-temp)] 100000 loops, best of 3: 3.91 µs per loop 

К сожалению, когда у вас сложный массив, работает только np. sort(temp)[::-1] . Два других метода, упомянутых здесь, неэффективны.

 >>> a=np.array([5, 2, 7, 4, 4, 2, 8, 6, 4, 4]) >>> np.sort(a) array([2, 2, 4, 4, 4, 4, 5, 6, 7, 8]) >>> -np.sort(-a) array([8, 7, 6, 5, 4, 4, 4, 4, 2, 2]) 

4 приема Python NumPy, которые должен знать каждый новичок

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

Помогая коллегам и друзьям с трудностями в NumPy, мы пришли к 4 приемам, которые должен знать каждый новичок Python. Эти фишки помогут вам написать более аккуратные и читаемые коды.  

1. Arg-функции — позиции

Для массива функции arr, np.argmax(arr), np.argmin(arr) и np.argwhere(condition(arr)) возвращают показатели максимальных значений, минимальных значений и значений, которые удовлетворяют определенным условиям пользователя соответственно. Хотя эти функции arg широко используются, мы часто игнорируем функцию np.argsort(), возвращающую показатели, которые сортируют массив.

Мы можем использовать np.argsort для сортировки значений массивов по другому массиву. Ниже представлен пример сортировки имен студентов с использованием их результатов экзамена. Отсортированный массив имен также можно преобразовать обратно в исходный порядок, используя np.argsort(np.argsort(score)).

1. score = np.array([70, 60, 50, 10, 90, 40, 80])
2. name = np.array(['Ada', 'Ben', 'Charlie', 'Danny', 'Eden', 'Fanny', 'George'])
3. sorted_name = name[np.argsort(score)] # an array of names in ascending order of their scores
4.  print(sorted_name) # ['Danny' 'Fanny' 'Charlie' 'Ben' 'Ada' 'George' 'Eden']
5.
6. original_name = sorted_name[np.argsort(np.argsort(score))]
7. print(original_name) # ['Ada' 'Ben' 'Charlie' 'Danny' 'Eden' 'Fanny' 'George']
8.
9.
10. %timeit name[np.argsort(score)] 
11. # 1.83 µs ± 182 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
12. %timeit sorted(zip(score, name))
13. # 3.2 µs ± 76.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Эффективность данной функции выше, нежели результат использования встроенной функции Python sorted(zip()). Кроме того, она, пожалуй, более читабельна.

2. Бродкастинг — формы

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

Например, вы можете использовать приращение всех значений в массиве на 1, используя arr + 1 независимо от измерения arr. Вы также можете проверить, все ли значения в массиве больше, чем 2, с помощью arr > 2.

Но как мы узнаем, совместимы ли два массива с бродкастинг?

Argument 1 (4D array): 7 × 5 × 3 × 1
Argument 2 (3D array): 1 × 3 × 9
Output (4D array): 7 × 5 × 3 × 9

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

3. Параметры Ellipsis и NewAxis

Синтаксис для нарезки массива numpy — это i:j где i, j — начальный индекс и индекс остановки соответственно. Например, для массива numpy arr = np.array(range(10)) команда arr[:3] дает [0, 1, 2]. 

При работе с массивами с более высокими размерностями мы используем  :  для выбора индекса по каждой оси. Мы также можем использовать … для выбора индексов по нескольким осям. Точное количество осей выводится. 

1. arr = np.array(range(1000)).reshape(2,5,2,10,-1)
2. print(arr[:,:,:,3,2] == arr[...,3,2])
3. # [[[ True, True],
4. # [ True, True],
5. # [ True, True],
6. # [ True, True],
7. # [ True, True]],
8. # [[ True, True],
9. # [ True, True],
10. # [ True, True],
11. # [ True, True],
12. # [ True, True]]])
13. 
14. print(arr.shape) # (2, 5, 2, 10, 5)
15. print(arr[...,np.newaxis,:,:,:].shape) # (2, 5, 1, 2, 10, 5)

С другой стороны, использование, np.newaxis, как показано выше, вставляет новую ось в заданное пользователем положение оси. Эта операция расширяет форму массива на одну единицу измерения. Хотя это также можно сделать с помощью np.expand_dims(), использование np.newaxis гораздо более читабельно и, пожалуй, изящно. 

4. Замаскированный массив — селекция

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

У Numpy есть подмодуль numpy.ma, который поддерживает массивы данных с масками. Маскированный массив содержит обычный массив numpy и маску, которая указывает положение недопустимых записей. 

np.ma.MaskedArray(data=arr, mask=invalid_mask)

Недопустимые записи в массиве иногда помечаются с использованием отрицательных значений или строк. Если мы знаем замаскированное значение, скажем -999, мы можем также создать замаскированный массив, используя np.ma.masked_values(arr, value=-999). Любая операция numpy, принимающая замаскированный массив в качестве аргумента, автоматически игнорирует эти недействительные записи, как показано ниже.

1. import math
2. def is_prime(n):
3. assert n > 1, 'Input must be larger than 1'
4.  if n % 2 == 0 and n > 2:
5. return False
6. return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))
7. 
8. arr = np.array(range(2,100))
9. non_prime_mask = [not is_prime(n) for n in a]
10. prime_arr = np.ma.MaskedArray(data=arr, mask=non_prime_mask)
11. print(prime_arr)
12. # [2 3 -- 5 -- 7 -- -- -- 11 -- 13 -- -- -- 17 -- 19 -- -- -- 23 -- -- -- --
13. # -- 29 -- 31 -- -- -- -- -- 37 -- -- -- 41 -- 43 -- -- -- 47 -- -- -- --
14. # -- 53 -- -- -- -- -- 59 -- 61 -- -- -- -- -- 67 -- -- -- 71 -- 73 -- --
15. # -- -- -- 79 -- -- -- 83 -- -- -- -- -- 89 -- -- -- -- -- -- -- 97 -- --]
16. 
17. arr = np.array(range(11))
18. print(arr.sum()) # 55
19. 
20. arr[-1] = -999 # indicates missing value
21. masked_arr = np.ma.masked_values(arr, -999)
22. print(masked_arr.sum()) # 45
23.

Источник

Numpy sort-sort (), argsort ()

Официальный документ

1. Сортировка контента: sort ()

Функциональный прототип: Сортировать сам массив

numpy. sort(a, axis=-1, kind='quicksort', order=None)

Параметры:

• a: массив numpy для сортировки
• ось: отсортированное измерение, по умолчанию -1 последнее измерение, None сортируется после выравнивания всех элементов
• Вид: алгоритм сортировки, есть: «быстрая сортировка», «слияние», «heapsort», «стабильный»
• порядок: порядок многоуровневой сортировки, поле должно быть построено

Пример:

import numpy as np
a = np.array([[1,4],[3,1]])

 # Сортировать по последнему измерению по умолчанию, каждая строка сортируется отдельно
np.sort(a)               
=> narray([[1, 4],
           [1, 3]])

 # Сортировать по 1D, каждый столбец сортируется отдельно         
np.sort(a, axis=0)
=> narray([[1, 1],
           [3, 4]])

 # Сортировать все элементы
np.sort(a, axis=None)
=> narray([1, 1, 3, 4])

 # Многоуровневая сортировка
dtype = [('name', 'S10'), ('height', float), ('age', int)]
values = [('Arthur', 1. 8, 41),  ('Lancelot', 1.9, 38), ('Galahad', 1.7, 38)]
a = np.array(values, dtype=dtype)
np.sort(a, order='height')                        
=> array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41), ('Lancelot', 1.8999999999999999, 38)],
      	 dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

2. Сортировка подстрочного индекса: argsort ()

Функциональный прототип: Сам массив остается неизменным, а отсортированный индексный массив возвращается

numpy.argsort(a, axis=-1, kind='quicksort', order=None)

Параметры:

• a: массив numpy для сортировки
• ось: отсортированное измерение, по умолчанию -1 последнее измерение, None сортируется после выравнивания всех элементов
• Вид: алгоритм сортировки, есть: «быстрая сортировка», «слияние», «heapsort», «стабильный»
• порядок: порядок многоуровневой сортировки, поле должно быть построено

Пример:

import numpy as np

# Одномерный массив
x = np.  2) 
  0 
  нет 
  ‘Сортировка слиянием’ 
  2 
  О (п * журнала (п)) 
  ~ П / 2 
  да 
  «Пирамидальная сортировка» 
  3 
  О (п * журнала (п)) 
  0 
  нет 
  numpy.sort () 
  Функция sort () возвращает отсортированную копию входного массива.  Имеет следующие параметры — 
numpy.sort(a, axis, kind, order)
 Куда,
 Sr.No.
 Параметр и описание
 1
 Массив для сортировки
 2
 ось
 Ось, по которой должен быть отсортирован массив.  Если нет, массив выравнивается, сортируется по последней оси
 3
 Добрый
 По умолчанию это быстрая сортировка
 4
 порядок
 Если массив содержит поля, порядок сортировки полей
 Массив для сортировки
 ось
 Ось, по которой должен быть отсортирован массив. Если нет, массив выравнивается, сортируется по последней оси
 Добрый
 По умолчанию это быстрая сортировка
 порядок
 Если массив содержит поля, порядок сортировки полей
 пример 
  Live Demo
import numpy as np  
a = np.array([[3,7],[9,1]]) 

print 'Our array is:' 
print a 
print '\n'

print 'Applying sort() function:' 
print np.sort(a) 
print '\n' 
  
print 'Sort along axis 0:' 
print np.sort(a, axis = 0) 
print '\n'  

# Order parameter in sort function 
dt = np.dtype([('name', 'S10'),('age', int)]) 
a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt) 

print 'Our array is:' 
print a 
print '\n'  

print 'Order by name:' 
print np.sort(a, order = 'name')
 Это даст следующий результат —
Our array is:
[[3 7]
 [9 1]]

Applying sort() function:
[[3 7]
 [1 9]]

Sort along axis 0:
[[3 1]
 [9 7]]

Our array is:
[('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]

Order by name:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]
 numpy.
 argsort ()
 Функция numpy.argsort () выполняет косвенную сортировку входного массива вдоль заданной оси и использует указанный вид сортировки для возврата массива индексов данных.  Этот массив индексов используется для построения отсортированного массива.
 пример 
  Live Demo
import numpy as np 
x = np.array([3, 1, 2]) 

print 'Our array is:' 
print x 
print '\n'  

print 'Applying argsort() to x:' 
y = np.argsort(x) 
print y 
print '\n'  

print 'Reconstruct original array in sorted order:' 
print x[y] 
print '\n'  

print 'Reconstruct the original array using loop:' 
for i in y: 
   print x[i],
 Это даст следующий результат —
Our array is:
[3 1 2]

Applying argsort() to x:
[1 2 0]

Reconstruct original array in sorted order:
[1 2 3]

Reconstruct the original array using loop:
1 2 3
 numpy.lexsort () 
 Функция выполняет косвенную сортировку с использованием последовательности клавиш.  Ключи можно увидеть в виде столбца в электронной таблице. Функция возвращает массив индексов, по которому можно получить отсортированные данные.  Обратите внимание, что последний ключ является первичным ключом сортировки.
 пример 
  Live Demo
import numpy as np 

nm = ('raju','anil','ravi','amar') 
dv = ('f.y.', 's.y.', 's.y.', 'f.y.') 
ind = np.lexsort((dv,nm)) 

print 'Applying lexsort() function:' 
print ind 
print '\n'  

print 'Use this index to get sorted data:' 
print [nm[i] + ", " + dv[i] for i in ind] 
 Это даст следующий результат —
Applying lexsort() function:
[3 1 0 2]

Use this index to get sorted data:
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']
 Модуль NumPy имеет ряд функций для поиска внутри массива.  Доступны функции для нахождения максимума, минимума, а также элементы, удовлетворяющие заданному условию.
 numpy.argmax () и numpy.argmin () 
 Эти две функции возвращают индексы максимального и минимального элементов соответственно вдоль заданной оси.
 пример 
  Live Demo
import numpy as np 
a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 

print 'Our array is:' 
print a 
print '\n' 

print 'Applying argmax() function:' 
print np.argmax(a) 
print '\n'  

print 'Index of maximum number in flattened array' 
print a.flatten() 
print '\n'  

print 'Array containing indices of maximum along axis 0:' 
maxindex = np.argmax(a, axis = 0) 
print maxindex 
print '\n'  

print 'Array containing indices of maximum along axis 1:' 
maxindex = np.argmax(a, axis = 1) 
print maxindex 
print '\n'  

print 'Applying argmin() function:' 
minindex = np.argmin(a) 
print minindex 
print '\n'  
   
print 'Flattened array:' 
print a.flatten()[minindex] 
print '\n'  

print 'Flattened array along axis 0:' 
minindex = np.argmin(a, axis = 0) 
print minindex
print '\n'

print 'Flattened array along axis 1:' 
minindex = np.argmin(a, axis = 1) 
print minindex
 Это даст следующий результат —
Our array is:
[[30 40 70]
 [80 20 10]
 [50 90 60]]

Applying argmax() function:
7

Index of maximum number in flattened array
[30 40 70 80 20 10 50 90 60]

Array containing indices of maximum along axis 0:
[1 2 0]

Array containing indices of maximum along axis 1:
[2 0 1]

Applying argmin() function:
5

Flattened array:
10

Flattened array along axis 0:
[0 1 1]

Flattened array along axis 1:
[0 2 0]
 numpy.
 nonzero ()
 Функция numpy.nonzero () возвращает индексы ненулевых элементов во входном массиве.
 пример 
  Live Demo
import numpy as np 
a = np.array([[30,40,0],[0,20,10],[50,0,60]]) 

print 'Our array is:' 
print a 
print '\n'  

print 'Applying nonzero() function:' 
print np.nonzero (a)
 Это даст следующий результат —
Our array is:
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]

Applying nonzero() function:
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
 numpy.where () 
 Функция where () возвращает индексы элементов во входном массиве, где заданное условие выполняется.
 пример 
  Live Demo
import numpy as np 
x = np.arange(9.).reshape(3, 3) 

print 'Our array is:' 
print x  

print 'Indices of elements > 3' 
y = np.where(x > 3) 
print y  

print 'Use these indices to get elements satisfying the condition' 
print x[y]
 Это даст следующий результат —
Our array is:
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

Indices of elements > 3
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

Use these indices to get elements satisfying the condition
[ 4. 5. 6. 7. 8.]
 numpy.extract () 
 Функция extract () возвращает элементы, удовлетворяющие любому условию.
  Live Demo
import numpy as np 
x = np.arange(9.).reshape(3, 3) 

print 'Our array is:' 
print x  

# define a condition 
condition = np.mod(x,2) == 0 

print 'Element-wise value of condition' 
print condition  

print 'Extract elements using condition' 
print np.extract(condition, x)
 Это даст следующий результат —
Как отсортировать массив Numpy | питон
 В этой статье мы узнаем, как сортировать массив Numpy. В Numpy есть несколько способов сортировки массива в зависимости от требований. Давайте попробуем понять их с помощью примеров.
 Пример # 1: Просто отсортируйте данный массив на основе оси, используя метод sort ().
import numpy as np 
   
a = np.array([[12, 15], [10, 1]]) 
arr1 = np.sort(a, axis = 0)         
print ("Along first axis : \n", arr1)         
   
   
a = np.array([[10, 15], [12, 1]]) 
arr2 = np.sort(a, axis = -1)         
print ("\nAlong first axis : \n", arr2) 
   
   
a = np.array([[12, 15], [10, 1]]) 
arr1 = np.sort(a, axis = None)         
print ("\nAlong none axis : \n", arr1) 
 Выход:
Along first axis : 
 [[10  1]
 [12 15]]

Along first axis : 
 [[10 15]
 [ 1 12]]

Along none axis : 
 [ 1 10 12 15]

 Пример # 2: Получить индексы, которые могут вернуть отсортированный массив, используя метод argsort ()
import numpy as np 
   
a = np.array([9, 3, 1, 7, 4, 3, 6]) 
   
print('Original array:\n', a) 
   
b = np.argsort(a) 
print('Sorted indices of original array->', b) 
   
c = np.zeros(len(b), dtype = int) 
for i in range(0, len(b)): 
    c[i]= a[b[i]] 
print('Sorted array->', c) 
 Выход:
Original array:
 [9 3 1 7 4 3 6]
Sorted indices of original array-> [2 1 5 4 6 3 0]
Sorted array-> [1 3 3 4 6 7 9]
 Пример № 3: Получить стабильную сортировку, используя последовательность ключей.
import numpy as np 
   
a = np.array([9, 3, 1, 3, 4, 3, 6]) 
   
b = np.array([4, 6, 9, 2, 1, 8, 7])  
print('column a, column b') 
for (i, j) in zip(a, b): 
    print(i, ' ', j) 
   
ind = np.lexsort((b, a))  
print('Sorted indices->', ind) 
 Выход:
column a, column b
9   4
3   6
1   9
3   2
4   1
3   8
6   7
Sorted indices-> [2 3 1 5 4 6 0]

Рекомендуемые посты:
Как отсортировать массив Numpy | питон
0.00 (0%) 0 votes
 numpy.argsort () в Python - GeeksforGeeks 
 numpy.argsort () в Python
   numpy.argsort ()  Функция  используется для выполнения косвенной сортировки по заданной оси с использованием алгоритма, указанного ключевым словом kind . Он возвращает массив индексов той же формы, что и arr, который будет сортировать массив.
  Синтаксис:  numpy.argsort (arr, axis = -1, kind = ’quicksort’, order = None)
  Параметры:  
  arr:  [array_like] Входной массив.
  ось:  [int или None] Ось, по которой выполняется сортировка. Если нет, массив выравнивается перед сортировкой. Значение по умолчанию - -1, что соответствует последней оси. 
  kind:  [«quicksort», «mergesort», «heapsort»] Алгоритм выбора. По умолчанию используется «быстрая сортировка». 
  order:  [str or list of str] Когда arr представляет собой массив с определенными полями, этот аргумент указывает, какие поля сравнивать первое, второе и т. Д.
  Возврат:  [index_array, ndarray] Массив индексов, которые сортируют arr по указанной оси.Если arr одномерный, тогда arr [index_array] возвращает отсортированный arr.
  Код # 1: 
  
  import   numpy as geek 
  
  in_rayar6      ,   0  ,   1  ,   5  ,   4  ,   1  ,   9  ]         «Входной несортированный массив:»  , in_arr) 
  
  out_arr   =   geek.argsort (in_arr) 
  print   (  "Индексы отсортированного массива вывода:"  , out_arr) 
  print   (  "Вывод отсортированного массива:"  , out_arr] 
  Выход: 
Входной несортированный массив: [2 0 1 5 4 1 9]
Вывести индексы отсортированного массива: [1 2 5 0 4 3 6]
Выходной отсортированный массив: [0 1 1 2 4 5 9]
 
  Код # 2: 
  
  import   numpy as geek 
  
  in_arr   =  =  =  =массив ([[  2  ,   0  ,   1  ], [  5  ,   4  ,   3  000]] печать    (  "Входной массив:"  , in_arr) 
  
  out_arr1   =   geek.argsort (in_arr, kind   = 000  = 000  '   0  ) 
  print   (  "Выводить индексы сортированного массива по оси 0:"  , out_arr1) 
  out_arr2   =  geek. argsort (in_arr, kind   =   'heapsort'  , axis   =   1  ) 
  print   (  "Вывод сортированных индексов массива  по оси 1:" ) 
  Выход: 
Входной массив: [[2 0 1]
 [5 4 3]]
Вывести индексы сортированного массива по оси 0: [[0 0 0]
 [1 1 1]]
Вывести индексы сортированного массива по оси 1: [[1 2 0]
 [2 1 0]]
 
 Внимание компьютерщик! Укрепите свои основы с помощью курса  Python Programming Foundation  и изучите основы.
 Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса  Python DS . И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к  Машинное обучение - курс базового уровня 
 python - Numpy argsort - что он делает? 
  [2, 3, 1, 0]  указывает, что наименьший элемент имеет индекс 2, следующий наименьший элемент - индекс 3, затем индекс 1, затем индекс 0.
 Есть несколько способов получить желаемый результат:
  импортировать numpy как np
импорт scipy.статистика как статистика

def using_indexed_assignment (x):
    "https://stackoverflow.com/a/5284703/1 (Свен Марнах)"
    результат = np.empty (len (x), dtype = int)
    temp = x.argsort ()
    результат [temp] = np.arange (len (x))
    вернуть результат

def using_rankdata (x):
    вернуть stats.rankdata (x) -1

def using_argsort_twice (x):
    "https://stackoverflow.com/a/6266510/1 (k.rooijers)"
    вернуть np.argsort (np.argsort (x))

def using_digitize (x):
    уникальные_валлы, индекс = np.unique (x, return_inverse = True)
    вернуть нп.digitize (x, bins = unique_val) - 1
  
 Например,
  В [72]: x = np.array ([1.48,1.41,0.0,0.1])

В [73]: using_indexed_assignment (x)
Выход [73]: массив ([3, 2, 0, 1])
  
 Это проверяет, что все они дают одинаковый результат:
  x = np.random.random (10 ** 5)
ожидаемый = using_indexed_assignment (x)
для функции в (using_argsort_twice, using_digitize, using_rankdata):
    утверждать np.allclose (ожидается, func (x))
  
 Эти тесты IPython % timeit  предлагают для больших массивов  using_indexed_assignment  - самый быстрый:
  В [50]: x = np.random.random (10 ** 5)
В [66]:% timeit using_indexed_assignment (x)
100 циклов, лучшее из 3: 9,32 мс на цикл

В [70]:% timeit using_rankdata (x)
100 циклов, лучшее из 3: 10,6 мс на цикл

В [56]:% timeit using_argsort_twice (x)
100 циклов, лучшее из 3: 16,2 мс на цикл

В [59]:% timeit using_digitize (x)
10 циклов, лучшее из 3: 27 мс на цикл
  
 Для небольших массивов  using_argsort_twice  может быть быстрее:
  В [78]: x = np.random.random (10 ** 2)

В [81]:% timeit using_argsort_twice (x)
100000 петель, лучшее из 3: 3.45 мкс на цикл

В [79]:% timeit using_indexed_assignment (x)
100000 петель, лучшее из 3: 4,78 мкс на петлю

В [80]:% timeit using_rankdata (x)
100000 петель, лучшее из 3: 19 мкс на петлю

В [82]:% timeit using_digitize (x)
10000 петель, лучшее из 3: 26,2 мкс на петлю
  
 Обратите внимание, что  stats.rankdata  дает вам больше контроля над тем, как обрабатывать элементы равного значения.
 python - можно ли использовать сортировку по убыванию? 
 Если вы инвертируете массив, самые низкие элементы становятся самыми высокими элементами, и наоборот.Следовательно, индексы  n  высших элементов равны:
  (-avgDists) .argsort () [: n]
  
 Другой способ рассуждать об этом, как упоминалось в комментариях, - это заметить, что большие элементы прибывают  последние  в argsort. Итак, вы можете прочитать из хвоста сортировки аргументов, чтобы найти  n  самых высоких элементов:
  avgDists.argsort () [:: - 1] [: n]
  
 Оба метода имеют временную сложность  O (n log n) , потому что вызов  argsort  является здесь доминирующим термином.Но у второго подхода есть приятное преимущество: он заменяет отрицание массива  O (n)  на срез  O (1) . Если вы работаете с небольшими массивами внутри циклов, вы можете получить некоторый прирост производительности, избегая этого отрицания, а если вы работаете с огромными массивами, вы можете сэкономить на использовании памяти, потому что отрицание создает копию всего массива.
 Обратите внимание, что эти методы не всегда дают эквивалентные результаты: если стабильная реализация сортировки запрашивается в  argsort , e.грамм. передав аргумент ключевого слова  kind = 'mergesort' , тогда первая стратегия сохранит стабильность сортировки, но вторая стратегия нарушит стабильность (то есть позиции одинаковых элементов будут перевернуты).
   Пример тайминга:  
 Используя небольшой массив из 100 поплавков и хвостовую часть длиной 30, метод просмотра был примерно на 15% быстрее
  >>> avgDists = np.random.rand (100)
>>> п = 30
>>> timeit (-avgDists).argsort () [: n]
1,93 мкс ± 6,68 нс на цикл (среднее ± стандартное отклонение из 7 прогонов, по 1000000 циклов в каждом)
>>> timeit avgDists.argsort () [:: - 1] [: n]
1,64 мкс ± 3,39 нс на цикл (среднее ± стандартное отклонение из 7 прогонов, по 1000000 циклов в каждом)
>>> timeit avgDists.argsort () [- n:] [:: - 1]
1,64 мкс ± 3,66 нс на цикл (среднее ± стандартное отклонение из 7 прогонов, по 1000000 циклов в каждом)
  
 Для массивов большего размера преобладает сортировка по аргументу, и нет значительной разницы во времени.
  >>> avgDists = np.random.rand (1000)
>>> п = 300
>>> timeit (-avgDists) .argsort () [: n]
21,9 мкс ± 51,2 нс на цикл (среднее ± стандартное отклонение из 7 прогонов, 10000 циклов в каждом)
>>> timeit avgDists.argsort () [:: - 1] [: n]
21,7 мкс ± 33,3 нс на цикл (среднее ± стандартное отклонение из 7 прогонов, 10000 циклов в каждом)
>>> timeit avgDists.argsort () [- n:] [:: - 1]
21,9 мкс ± 37,1 нс на цикл (среднее ± стандартное отклонение из 7 прогонов, 10000 циклов в каждом)
  
 Обратите внимание, что комментарий от nedim ниже неверен. Усечение до или после реверсирования не имеет значения для эффективности, поскольку обе эти операции только по-разному просматривают массив, а не фактически копируют данные.
 numpy.argsort () в Python - Javatpoint 
 Модуль NumPy предоставляет функцию argsort (), возвращает индексы, которые будут сортировать массив.
 Модуль NumPy предоставляет функцию для выполнения косвенной сортировки по заданной оси с помощью алгоритма, указанного ключевым словом. Эта функция возвращает массив индексов той же формы, что и 'a', который сортирует массив.
 Синтаксис 
 тупой.argsort (a, axis = -1, kind = None, order = None)
 Параметры 
 Это следующие параметры в функции numpy.argsort ():
  a: array_like 
 Этот параметр определяет исходный массив, который мы хотим отсортировать.
  ось: int или None (необязательно) 
 Этот параметр определяет ось, по которой выполняется сортировка. По умолчанию ось -1. Если мы установим для этого параметра значение None, будет использоваться плоский массив.
  kind: {'quicksort', 'mergesort', 'heapsort', 'stable'} (необязательно) 
 Этот параметр определяет алгоритм сортировки. По умолчанию алгоритм  quicksort . И  mergesort , и  stable  используют таймерную сортировку. Фактическая реализация будет зависеть от типа данных. Параметр  mergesort  сохранен для обратной совместимости.
  заказ: str или список str (опционально) 
 Если 'a' - это массив с определенными полями, этот аргумент указывает, какие поля сравнивать первым, вторым и т. Д.Одиночное поле можно указать как строку, и не все поля нужно указывать. Но неуказанные поля все равно будут использоваться в том порядке, в котором они появляются в dtype, чтобы разорвать связи.
 Возвращает: index_array: ndarray, int 
 Эта функция возвращает массив индексов, которые сортируют «а» вместе с указанной осью. Если 'a' 1-D, [index_array] дает отсортированный 'a'. В более общем смысле  np.take_along_axis (arr1, index_array, axis = axis)  всегда дает отсортированный «a», независимо от размерности.
 Пример 1: np.argsort () 
 импортировать numpy как np
 a = np.array ([456,11,63])
 а
 b = np.argsort (а)
 б
  В приведенном выше коде 
 Мы импортировали numpy с псевдонимом np.
 Мы создали массив 'a' с помощью функции np.array ().
 Мы объявили переменную 'b' и присвоили возвращаемое значение функции np.argsort ().
 Мы передали в функцию массив 'a'.
 Наконец, мы попытались вывести значение b.
 В выводе был показан ndarray, содержащий индексы (указывающие позицию элемента для отсортированного массива) и dtype.
  Выход: 
массив ([456, 11, 63])
массив ([1, 2, 0], dtype = int64)
 
 Пример 2: Для двумерного массива (сортировка по первой оси (вниз)) 
 импортировать numpy как np
 a = np.array ([[0, 5], [3, 2]])
 индексы = np.argsort (a, ось = 0)
 индексы
  Выход: 
массив ([[0, 1],
       [1, 0]], dtype = int64)
 
 Пример 3: Для двумерного массива (альтернатива оси = 0) 
 импортировать numpy как np
 a = np.array ([[0, 5], [3, 2]])
 индексы = np.argsort (a, ось = 0)
 индексы
 np.take_along_axis (a, индексы, ось = 0)
  В приведенном выше коде 
 Мы импортировали numpy с псевдонимом np.
 Мы создали двумерный массив «a» с помощью функции np.array ().
 Мы объявили индексы переменных и присвоили возвращаемое значение функции np.argsort ().
 Мы передали двумерный массив 'a' и ось как 0.
 Затем мы использовали функцию take_along_axis () и передали исходный массив, индексы и ось.
 Эта функция вернула отсортированный двумерный массив.
 На выходе был показан двумерный массив с отсортированными элементами.
  Выход: 
 Пример 4: Для двумерного массива (сортировка по последней оси (по горизонтали)) 
 импортировать numpy как np
 a = np.array ([[0, 5], [3, 2]])
 индексы = np.argsort (a, ось = 1)
 индексы
  Выход: 
массив ([[0, 1],
       [1, 0]], dtype = int64)
 
 Пример 5: Для двумерного массива (альтернатива оси = 1) 
 импортировать numpy как np
 а = нп.массив ([[0, 5], [3, 2]])
 индексы = np.argsort (a, ось = 1)
 индексы
 np.take_along_axis (a, индексы, ось = 1)
  Выход: 
 Пример 6: Для массива N-D 
 импортировать numpy как np
 a = np.array ([[0, 5], [3, 2]])
 индексы = np.unravel_index (np.argsort (a, axis = None), a.shape)
 индексы
 a [индексы] # то же, что и np.sort (a, axis = None)
  Выход: 
(массив ([0, 1, 1, 0], dtype = int64), array ([0, 1, 0, 1], dtype = int64))
массив ([0, 2, 3, 5])
 
  В приведенном выше коде 
 Мы импортировали numpy с псевдонимом np.
 Мы создали двумерный массив «a» с помощью функции np.array ().
 Мы объявили переменную index и присвоили возвращаемое значение функции np.unravel_index ().
 Мы передали функцию np.argsort () и форму массива 'a'.
 Мы передали двумерный массив 'a' и ось как 1 в функции argsort ().
 Затем мы попытались вывести значение индексов и [индексы].
 На выходе был показан N-D массив с отсортированными элементами.
 Пример 7: Сортировка с помощью ключей 
 импортировать numpy как np
 a = np.array ([(0, 5), (3, 2)], dtype = [('x', '
  Выход: 
array ([(0, 5), (3, 2)], dtype = [('x', '
  В приведенном выше коде 
 Мы импортировали numpy с псевдонимом np.
 Мы создали двумерный массив 'a' с помощью функции np.array () с dtype = [('x', '
 Мы объявили переменные 'b' и 'c' и присвоили возвращаемое значение функции np.argsort ().
 Мы передали в функцию массив 'a' и порядок в качестве аргумента.
 Наконец, мы попытались вывести значение «b» и «c».
 В выводе был показан отсортированный массив с dtype = [('x', '
 Python NumPy для вашей бабушки - 4.6 Сортировка 
 
 В этом разделе мы увидим, как вы можете использовать функцию NumPy  sort ()  для сортировки элементов массива.
  sort ()  принимает три основных параметра:
 массив, который вы хотите отсортировать
 ось для сортировки - по умолчанию -1, сортировка по последней оси
, который вы хотите реализовать в NumPy. По умолчанию NumPy реализует быструю сортировку.
 Например, здесь мы создаем 1d-массив,  foo , а затем сортируем его в порядке возрастания.
  импортировать numpy как np

foo = np.array ([1, 7, 3, 9, 0, 9, 1])
np.sort (foo)
## массив ([0, 1, 1, 3, 7, 9, 9])
  
 Обратите внимание, что исходный массив остается без изменений.
  печать (foo)
## [1 7 3 9 0 9 1]
  
 Если вы хотите отсортировать значения  foo  «на месте», используйте метод  .sort ()  объекта массива. Другими словами, если вы выполните  foo.sort () , на этот раз  foo  обновит свои значения в отсортированном порядке.
  foo.sort ()
печать (foo)
## [0 1 1 3 7 9 9]
  
 Если у вас есть массив с  нан  значений, подобных этому,  sort ()  перемещает их в конец массива.
  bar = np.array ([5, np.nan, 3, 11])
np.sort (бар)
## массив ([3., 5., 11., nan])
  
 К сожалению, в NumPy нет простого и прямого способа сортировки массивов в порядке убывания. Однако, немного подумав, мы можем что-нибудь придумать. Особо выделяются два метода.
 Первый - отсортировать массив в порядке возрастания, а затем обратить результат.
  np.sort (bar) [:: - 1]
## array ([nan, 11., 5., 3.])
  
 Второй - отрицание значений массива, сортировка их в порядке возрастания, а затем отрицание этого результата.
  -np.sort (-bar)
## массив ([11., 5., 3., nan])
  
 Основное различие между этими методами состоит в том, что 1-й метод выталкивает  нан  значений на передний план массива, а второй метод перемещает  нан  с на задний план.Кроме того, второй метод не будет работать со строками, так как вы не можете отрицать строку.
 Что, если вы хотите отсортировать многомерный массив вот так?
  boo = np.array ([
    [55, 10, 12],
    [20, 0, 33],
    [55, 92, 3]
])
  
 В этом случае вы можете использовать параметр  axis  функции  sort () , чтобы указать, по какой оси выполнять сортировку. Например, если мы выполняем  np.sort (boo, axis = 0) , он сортирует  boo  по оси 0.Другими словами, он сортирует каждый столбец  boo .
  np.sort (boo, axis = 0)
## массив ([[20, 0, 3],
## [55, 10, 12],
## [55, 92, 33]])
  
 И если мы выполняем  np.sort (boo, axis = 1) , он сортирует  boo  по оси 1. Другими словами, он сортирует каждую строку из  boo .
  np.sort (boo, axis = 1)
## массив ([[10, 12, 55],
## [0, 20, 33],
## [3, 55, 92]])
  
 Мы также можем установить  axis = -1 , чтобы указать NumPy, что нужно отсортировать последнюю ось массива.В этом случае это будет похоже на сортировку  boo  по оси 1.
  np.sort (a = boo, axis = -1)
## массив ([[10, 12, 55],
## [0, 20, 33],
## [3, 55, 92]])
  
 Круто, но что, если бы мы хотели отсортировать строки  boo  в соответствии, скажем, со значениями в 1-м столбце? Если бы у нас было что-то, что могло бы дать нам массив  [1, 0, 2] , мы могли бы вставить это в индекс строки и получить обратно желаемый отсортированный массив.
  бу [[1, 0, 2]]
## массив ([[20, 0, 33],
## [55, 10, 12],
## [55, 92, 3]])
  
 Нам нужен инструмент  argsort () . argsort ()  работает так же, как  sort () , за исключением того, что возвращает массив из  индексов , указывающих позицию, в которую будет отображаться каждое значение массива в отсортированном случае.
 Например, если у вас есть массив  [3, 0, 10, 5]  и вы вызвали для него  argsort () , вы вернете массив  [1, 0, 3, 2] , поскольку наименьший элемент имеет индекс 1, второй наименьший элемент имеет индекс 0 и так далее. Если бы вы использовали этот массив для индексации исходного массива, вы бы вернули отсортированный массив, как если бы вы вызвали  np.Сортировка () .
  goo = np.array ([3, 0, 10, 5]) # [3, 0, 10, 5]
np.argsort (goo) # [1, 0, 3, 2]
## массив ([1, 0, 3, 2])
goo [np.argsort (goo)] # [0, 3, 5 10]
## массив ([0, 3, 5, 10])
  
 Итак, если вы хотите отсортировать строки двухмерного массива на основе определенного столбца, вам просто нужно вызвать  argsort ()  для значений этого столбца и использовать результат для выбора строк из исходного массива.
 Оглядываясь на наш двумерный массив  boo , мы можем отсортировать его строки по 1-му столбцу в порядке возрастания.
  бу [np.argsort (boo [:, 0])]
## массив ([[20, 0, 33],
## [55, 10, 12],
## [55, 92, 3]])
  
 Возникает важный вопрос. Если в нашем массиве есть повторяющиеся значения, например 55 в данном случае, как мы можем гарантировать, что их сортировка не изменит порядок, в котором они появляются в исходном массиве? Например, обе эти матрицы являются допустимыми типами  boo  по первому столбцу, но только первая матрица не смешивает порядок 55.
  печать (бу [[1, 0, 2]])
## [[20 0 33]
## [55 10 12]
## [55 92 3]]
печать (бу [[1, 2, 0]])
## [[20 0 33]
## [55 92 3]
## [55 10 12]]
  
 Это так называемый стабильный алгоритм сортировки  .По умолчанию  np.sort ()  и  np.argsort  не используют стабильный алгоритм сортировки, но вы можете принудительно использовать его, установив  kind = стабильный .
 Учебный план курса 
  Введение  
 1.1 Введение
  Базовый материал для массива  
 2.1 Мотивация для массива NumPy 
 2.2 Основы работы с массивами NumPy 
 2.3 Создание массивов NumPy 
 2.4 Индексирование одномерных массивов 
 2.5 Индексирование многомерных массивов 
 2.6 Базовые математические вычисления для массивов 
 2.Вызов 7: воссоединение средней школы 
 2.8 Вызов: золотоискатель 
 2.9 Вызов: Chic-fil-A
  Intermediate Array Stuff  
 3.1 Broadcasting 
 3.2 newaxis 
 3.3  reshape ()  
 3.4 Логическое индексирование 
 3.5 nan 
 3.6 infinity 
 3.7 random 
 3.8 Challenge: Love Distance 
 3.9 Challenge: Professor Prick 
 3.10 Challenge: Psycho Parent
  Общие операции  
 4.1  где ()  
 4.2 Математические функции 
 4.3  все ()  и  любые ()  
 4,4  concatenate ()  
 4,5 Стекирование 
 4,6 Сортировка 
 4,7  уникальных ()  
 4,8 Задача: рейтинг фильмов 
 4,9 Задача: Big Fish 
 4,10 Задача: Taco Truck
  Advanced Array Stuff  
 5.1 Advanced Array Indexing 
 5.2 View vs Copy 
 5.3 Challenge: Population Verification 
 5.4 Challenge: Prime Locations 
 5.5 Challenge: The Game of Doors 
 5.6 Challenge: Peanut Butter
  Финальный босс  
 6.1  as_strided ()  
 6.2  einsum ()  
 6.3 Задача: One-Hot-Encoding 
 6.4 Задача: Суммарное количество осадков 
 6.5 Задача: Настольный теннис 
 6.6 Задача: Где Уолдо 
 6.7 Задача: Внешний продукт
 3 простых метода сортировки в NumPy 
 Привет, читатели! В этой статье мы подробно остановимся на методах сортировки  3 в NumPy .
 Итак, приступим! 🙂
  Библиотека Python NumPy  предлагает нам различные функции для создания массива и управления элементами аналогичного типа в структуре массива.Наряду с этим NumPy предлагает нам различные функции, которые могут позволить нам сортировать элементы, присутствующие в структуре массива.
 Методы сортировки в NumPy 
 Мы изучим нижеприведенные методы сортировки в NumPy.
  Функция NumPy sort () 
  Функция NumPy argsort () 
  Функция NumPy lexsort () 
 Итак, приступим!
 1. Функция NumPy sort () 
 Для сортировки различных элементов, присутствующих в структуре массива, NumPy предоставляет нам функцию  sort () .С помощью функции sort () мы можем сортировать элементы и разделять их в порядке возрастания и убывания соответственно.
 Обратите внимание на синтаксис ниже!
  Синтаксис: 
 Параметр «ось» указывает способ, которым должна выполняться сортировка. Поэтому, когда мы устанавливаем axis = NONE, сортировка происходит традиционным образом, и результирующий массив представляет собой одну строку элементов. С другой стороны, если мы устанавливаем axis = 1, сортировка происходит построчно, то есть каждая строка сортируется индивидуально.
  Пример 1: 
 В этом примере мы создали массив, далее мы отсортировали массив с помощью функции sort () и с осью  = NONE , т.е. он сортирует элементы в порядке возрастания.
импортировать numpy как np
data = np.array ([[22, 55], [0, 10]])
res = np.sort (данные, ось = Нет)
print ("Данные перед сортировкой:", data)
print ("Данные после сортировки:", res)
 
  Выход: 
Данные до сортировки: [[22 55]
 [0 10]]
Данные после сортировки: [0 10 22 55]
 
  Пример 2: 
 В этом примере мы создали массив и отсортировали его с помощью функции sort (), здесь мы установили axis = 1 i.е. Выполнена построчная сортировка.
импортировать numpy как np
data = np.array ([[66, 55, 22], [0, 10, -1]])
res = np.sort (данные, ось = 1)
print ("Данные перед сортировкой:", data)
print ("Сортировка по строкам:", res)
 
  Выход: 
Данные до сортировки: [[66 55 22]
 [0 10 -1]]
Сортировка по строкам: [[22 55 66]
 [-1 0 10]]
 
 2. NumPy argsort () 
 Помимо метода sort (), у нас также есть функция  argsort () , которая используется в качестве методов сортировки в NumPy, которая возвращает массив из  индексов  отсортированных элементов.Из этих отсортированных значений индекса мы можем получить отсортированные элементы массива в порядке возрастания.
 Таким образом, с помощью функции argsort () мы можем отсортировать значения массива и получить значения индексов того же самого, что и отдельный массив.
  Пример: 
импортировать numpy как np
data = np.array ([66, 55, 22,11, -1,0,10])
res_index = np.argsort (данные)
print ("Данные перед сортировкой:", data)
print ("Отсортированные значения индекса массива:", res_index)

x = np.zeros (len (res_index), dtype = int)
для i в диапазоне (0, len (x)):
    x [i] = данные [res_index [i]]
print ('Отсортированный массив из индексов:', x)
 
  Вывод: 
 В приведенном выше примере мы выполнили функцию argsort () для значений данных и получили отсортированные значения индексов элементов.Кроме того, мы использовали те же значения индекса массива, чтобы получить отсортированные элементы массива.
Данные до сортировки: [66 55 22 11 -1 0 10]
Отсортированные значения индекса массива: [4 5 6 3 2 1 0]
Отсортированный массив по индексам: [-1 0 10 11 22 55 66]
 
 3. Функция lexsort () NumPy 
 Функция lexsort () позволяет нам сортировать значения данных, используя последовательность ключей, то есть по столбцам. С помощью функции  lexsort ()  мы сортируем два массива, принимая во внимание по одному.В результате получаем значения индексов отсортированных элементов.
импортировать numpy как np
data = np.array ([66, 55, 22,11, -1,0,10])
data1 = np.array ([1,2,3,4,5,0, -1])
res_index = np.lexsort ((данные1, данные))
print ("Отсортированные значения индекса массива:", res_index)
 
  Выход: 
Отсортированные значения индекса массива: [4 5 6 3 2 1 0]
 
 Заключение 
 Не стесняйтесь комментировать ниже, если у вас возникнут какие-либо вопросы. Чтобы увидеть больше таких сообщений, связанных с программированием на Python, оставайтесь с нами.
 До тех пор, удачного обучения !!
 Окончательное введение в сортировку в NumPy 
 Представьте, что вам нужно найти книгу на своей книжной полке. Какую ситуацию вы бы предпочли: A) ваша книжная полка содержит все ваши книги в произвольном порядке, или B) ваша книжная полка содержит все книги, отсортированные в алфавитном порядке по названию.
 Конечно, вариант Б) сэкономит вам много времени, особенно если вы обращаетесь к своей книжной полке несколько раз. Эта статья покажет вам, как использовать сортировку в одной строке Python с помощью библиотеки NumPy.Статья удаленно основана на главах из моей книги «Coffee Break NumPy» и моей будущей книги «Python One-liners». 😊
 Основы 
 Сортировка лежит в основе более сложных приложений, таких как коммерческие вычисления, обход графов или алгоритмы поиска. К счастью, NumPy предоставляет различные алгоритмы поиска - алгоритм поиска по умолчанию является популярным алгоритмом «Быстрая сортировка». Однако для этого однострочника мы используем подход более высокого уровня, рассматривая функцию сортировки как «черный ящик», куда мы можем поместить массив NumPy и получить отсортированный массив NumPy.
 на рисунке показано, как алгоритм преобразует несортированный массив [10, 6, 8, 2, 5, 4,
 9, 1] в отсортированный массив [1, 2, 4, 5, 6, 8, 9, 10]. Это цель
 Функция sort () в NumPy.
 Но
 зачастую важно не только отсортировать сам массив, но и получить
 массив индексов, который преобразует несортированный массив в отсортированный
 множество. Например, элемент массива «1» несортированного массива имеет индекс «7». С
 элемент массива «1» - это первый элемент отсортированного массива, его индекс «7»
 - первый элемент отсортированных индексов.Это цель argsort () в NumPy.
 функция.
 Этот небольшой фрагмент кода демонстрирует, как использовать sort () и argsort () в NumPy:
 import numpy as np


a = np.array ([10, 6, 8, 2, 5, 4, 9, 1])

печать (np.sort (a))
# [1 2 4 5 6 8 9 10]

печать (np.argsort (a))
# [7 3 5 4 1 2 6 0] 
 Вы можете спросить: чем функция sort () в NumPy отличается от функции sorted () в Python? Ответ прост: вы также можете использовать NumPy для сортировки многомерных массивов!
 На рисунке показаны два способа использования функции сортировки для сортировки двумерного массива.Сортируемый массив имеет две оси: ось 0 (строки) и ось 1 (столбцы). Теперь вы можете выполнять сортировку по оси 0 (сортировка по вертикали) или по оси 1 (сортировка по горизонтали). В общем, ключевое слово axis определяет направление, в котором вы выполняете операцию NumPy. Вот фрагмент кода, который технически показывает, как это сделать:
 import numpy as np


a = np.array ([[1, 6, 2],
              [5, 1, 1],
              [8, 0, 1]])

print (np.sort (a, ось = 0))
"" "
[[1 0 1]
 [5 1 1]
 [8 6 2]]
"" "

печать (нп.sort (a, axis = 1))
"" "
[[1 2 6]
 [1 1 5]
 [0 1 8]]
"" "
 
 пример показывает, что необязательный аргумент оси помогает вам отсортировать массив NumPy
 по фиксированному направлению. Это основная сила функции sort () NumPy по сравнению с
 к встроенной функции Python sorted ().
 Код 
 Однострочник решает следующую задачу: «Найти имена трех лучших учащихся с наивысшими баллами по SAT». Обратите внимание, что простая сортировка массива результатов SAT не решает проблему, потому что в задаче запрашиваются имена учащихся.Сначала посмотрите данные, а затем попробуйте самостоятельно найти однострочное решение.
 ## Зависимости
импортировать numpy как np


## Данные: результаты SAT для разных студентов
sat_scores = np.array ([1100, 1256, 1543, 1043, 989, 1412, 1343])
student = np.array ([«Джон», «Боб», «Алиса», «Джо», «Джейн», «Фрэнк», «Карл»])


## Один лайнер
top_3 = студенты [np.argsort (sat_scores)] [: 3: -1]


## Результат
печать (top_3)
 
 Что выводит этот фрагмент кода?
 Результат 
 Первоначально код определяет данные
 состоящий из результатов SAT студентов в виде одномерного массива данных, как
 а также имена этих студентов.Например, ученик «Джон» сдал SAT.
 оценка «1100», в то время как «Франк» получил оценку SAT «1343».
 Вопрос в том, чтобы найти имена
 трое самых успешных студентов. Однострочник достигает этой цели - не за счет
 просто сортировка результатов SAT - но с помощью функции argsort (). Отзывать
 что функция argsort () возвращает массив индексов, такой что
 соответствующие элементы массива данных будут отсортированы.
 Вот результат функции argsort оценок SAT:
 print (np.argsort (sat_scores))
# [4 3 0 1 6 5 2]
 
 Почему индекс «4» стоит на первом
 положение выхода? Потому что у студентки «Джейн» самый низкий балл по SAT - 989
 точки. Обратите внимание, что как sort (), так и argsort () сортируются по возрастанию от
 от самых низких до самых высоких значений.
 У вас есть отсортированные индексы, но что теперь? Идея состоит в том, чтобы получить имена соответствующих студентов. Теперь этого можно достичь, используя простую индексацию в массиве имен учащихся:
 print (student [np.argsort (sat_scores)])
# ['Джейн' Джо 'Джон' Боб 'Карл' Фрэнк 'Алиса']
 
 Вы уже знаете, что у «Джейн» самый низкий балл за SAT, а у «Алисы» самый высокий балл за SAT.Осталось только переупорядочить этот список (от самого высокого до самого низкого) и извлечь трех лучших учеников, используя простую срезку:
 ## Однострочный
top_3 = студенты [np.argsort (sat_scores)] [: 3: -1]


## Результат
печать (top_3)
# ['Alice' 'Frank' 'Carl'] 
 Алиса, Фрэнк и Карл - студенты с наивысшими баллами SAT 1543, 1412 и 1343 соответственно.
 Что делать дальше? 
 Чтобы помочь вам стать лучшим программистом (и преодолеть свое слабое «я»), я создал свой курс электронной почты для постоянного совершенствования Python.Мои книги «Python для кофе-брейков» и «Coffee Break NumPy» основаны на этой философии небольших непрерывных улучшений (Кайдзен) с использованием подхода к обучению, основанного на головоломках. Это весело!
 Работая исследователем распределенных систем, доктор Кристиан Майер обнаружил свою любовь к обучению студентов, изучающих информатику.
 Чтобы помочь студентам достичь более высокого уровня успеха в Python, он основал веб-сайт по обучению программированию Finxter.com. Он является автором популярной книги по программированию Python One-Liners (NoStarch 2020), соавтором серии самоизданных книг о Python для кофе-брейков, энтузиаст информатики, фрилансер и владелец одного из 10 крупнейших блогов Python по всему миру.
No related posts.