Условия и булевы массивы, размерность матрицы / np 5
До этого момента индексы и срезы использовать для извлечения подмножеств. В этих методах используются числовые значения. Но есть альтернативный путь получения элементов — с помощью условий и булевых операторов.
Предположим, что нужно выбрать все значения меньше 0,5 в матрице размером 4х4, которая содержит случайные значения между 0 и 1.
>>> A = np.random.random((4, 4)) >>> A array([[ 0.03536295, 0.0035115 , 0.54742404, 0.68960999], [ 0.21264709, 0.17121982, 0.81090212, 0.43408927], [ 0.77116263, 0.04523647, 0.84632378, 0.54450749], [ 0.86964585, 0.6470581 , 0.42582897, 0.22286282]]) Когда матрица из случайных значений определена, можно применить оператор условия. Результатом будет матрица из булевых значений: True , если элемент соответствовал условию и False — если нет. В этом примере можно видеть все элементы со значениями меньше 0,5.
>>> A 0.5 array([[ True, True, False, False], [ True, True, False, True], [False, True, False, False], [False, False, True, True]], dtype=bool) На самом деле, булевы массивы используются для неявного извлечения частей массивов. Добавив прошлое условие в квадратные скобки, можно получить новый массив, который будет включать все элементы меньше 0,5 из предыдущего.
>>> A[A 0.5] array([ 0.03536295, 0.0035115 , 0.21264709, 0.17121982, 0.43408927, 0.04523647, 0.42582897, 0.22286282]) Управление размерностью
Вы уже видели, как можно превращать одномерный массив в матрицу с помощью функции reshape() .
>>> a = np.random.random(12) >>> a array([ 0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705, 0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692, 0.41894881, 0.73581471]) >>> A = a.reshape(3, 4) >>> A array([[ 0.77841574, 0.39654203, 0.38188665, 0.26704305], [ 0.27519705, 0.78115866, 0.96019214, 0.59328414], [ 0.52008642, 0.10862692, 0.41894881, 0.73581471]]) Функция reshape() возвращает новый массив и таким образом может создавать новые объекты. Но если необходимо изменить объект, поменяв его форму, нужно присвоить кортеж с новыми размерностями атрибуту shape массива.
>>> a.shape = (3, 4) >>> a array([[ 0.77841574, 0.39654203, 0.38188665, 0.26704305], [ 0.27519705, 0.78115866, 0.96019214, 0.59328414], [ 0.52008642, 0.10862692, 0.41894881, 0.73581471]]) Как видно на примере, в этот раз оригинальный массив изменил форму, и ничего не возвращается. Обратная операция также возможна. Можно конвертировать двухмерный массив в одномерный с помощью функции ravel() .
>>> a = a.ravel() array([ 0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705, 0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692, 0.41894881, 0.73581471]) Или прямо повлиять на атрибут shape самого массива.
>>> a.shape = (12) >>> a array([ 0.77841574, 0.39654203, 0.38188665, 0.26704305, 0.27519705, 0.78115866, 0.96019214, 0.59328414, 0.52008642, 0.10862692, 0.41894881, 0.73581471]) Еще одна важная операция — транспонирование матрицы. Это инверсия колонок и рядов. NumPy предоставляет такую функциональность в функции transpose() .
>>> A.transpose() array([[ 0.77841574, 0.27519705, 0.52008642], [ 0.39654203, 0.78115866, 0.10862692], [ 0.38188665, 0.96019214, 0.41894881], [ 0.26704305, 0.59328414, 0.73581471]]) Как определить размеры матрицы после ввода ее с клавиатуры
ну вам же какой-то разделитель всё равно нужен, ну можно сделать так:
row = list(map(int, input().split())) можно получить список чисел введённых через пробел
а дальше выработать критерии выхода из цикла ввода строк матрицы, например если кол-во цифр текущего ряда не равно кол-ву цифр предыдущего ряда
matrix = [] while True: # считать строку матрицы row = list(map(int, input().split())) # если введено только одно значение и оно '0' # или если кол-во чисел текущего ряда отличается от ряда в матрице - выйти if len(row) == 1 and row[0] == 0 or len(matrix) > 0 and len(matrix[0]) != len(row): break # добавить строку в матрицу matrix.append(row) # вывести размер матрицы print(f'matrix size: x') Библиотека Numpy. Расчет статистик по данным в массиве
Библиотека Numpy предоставляет функции для расчета простых статистик: среднее значение, медиана, стандартное отклонение и т.п. Вопросу использования данных функций посвящен этот урок.
- Введение
- Размерность массива
- Общие правила при работе с массивами Numpy
-
- Вызов функции расчета статистики
- Расчет статистик по строкам или столбцам массива
Введение
Импортируйте библиотеку Numpy , если вы еще этого не сделали.
>>> import numpy as np
Для начала создадим матрицу, которая нам понадобится в работе.
>>> m = np.matrix('1 2 3 4; 5 6 7 8; 9 1 5 7') >>> print(m) [[1 2 3 4] [5 6 7 8] [9 1 5 7]]В этом случае будет создан объект типа matrix .
>>> type(m)
Если вы уже работали с Numpy , это может для вас быть чем-то новым. В Numpy , как правило, приходится работать с объектами класса ndarray . Мы выбрали matrix из-за удобства объявления массива, т.к. matrix позволяет использование Matlab -подобный стиль, и, наверное, вам будет интересно познакомиться с чем-то новым. Для задач, рассматриваемых в рамках данной статьи, объекты matrix и ndarray одинаково хорошо подходят. Matix можно превратить в ndarray вот так:
>>> m = np.array(m) >>> type(m)
В любом случае наша таблица чисел будет выглядеть следующим образом.
Размерность массива
Для определения размерности массива Numpy используйте атрибут shape .
>>> m.shape (3, 4)
В результате мы получим кортеж из двух элементов, первый из них – это количество строк, второй – столбцов.
Общие правила при работе с массивами Numpy
Перед тем, как перейти к описанию функций расчета статистик необходимо, чтобы вы запомнили несколько важных вещей, касательно функций и массивов Numpy .
Вызов функции расчета статистики
Для расчета той или иной статистики, соответствующую функцию можно вызвать как метод объекта, с которым вы работаете. Для нашего массива это будет выглядеть так.
>>> m.max() 9
Тот же результат можно получить вызвав библиотечную функцию с соответствующим именем, передав ей в качестве аргумента массив.
>>> np.max(m) 9
Расчет статистик по строкам или столбцам массива
Вызовем функцию вычисления статистики (максимальный элемент) без аргументов.
>>> m.max() 9
В этом случает будут обработаны все элементы массива.
Если необходимо найти максимальный элемент в каждой строке, то для этого нужно передать в качестве аргумента параметр axis=1 .
>>> m.max(axis=1) matrix([[4], [8], [9]])
Для вычисления статистики по столбцам, передайте в качестве параметра аргумент axis=0 .
>>> m.max(axis=0) matrix([[9, 6, 7, 8]])
Функции (методы) для расчета статистик в Numpy
Ниже, в таблице, приведены методы объекта ndarray (или matrix ), которые, как мы помним из раздела выше, могут быть также вызваны как функции библиотеки Numpy , для расчета статистик по данным массива.
Имя метода Описание argmax Индексы элементов с максимальным значением (по осям) argmin Индексы элементов с минимальным значением (по осям) max Максимальные значения элементов (по осям) min Минимальные значения элементов (по осям) mean Средние значения элементов (по осям) prod Произведение всех элементов (по осям) std Стандартное отклонение (по осям) sum Сумма всех элементов (по осям) var Дисперсия (по осям) Вычислим некоторые из представленных выше статистик.
>>> m.mean() 4.833333333333333 >>> m.mean(axis=1) matrix([[2.5], [6.5], [5.5]]) >>> m.sum() 58 >>> m.sum(axis=0) matrix([[15, 9, 15, 19]])
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
>>
Переформатирование, изменение формы — Python: Numpy-массивы
Часто разработчикам приходится изменять размеры массивов. Например, переформатировать исходные данные, чтобы разделить их на подмассивы. В некоторых случаях требуется еще и объединять многомерные данные в единый массив значений. Чтобы решать такие задачи, массивы numpy.ndarray предоставляют набор методов, самым популярным из которых является метод reshape() .
В этом уроке разберем, как работать с размерами массивов numpy.ndarray и как получать их производные. Еще поговорим об ограничениях размерности и узнаем, как они помогают оптимизировать работу.
Как изменить размер массива
Представим, что нам нужно увеличить размер массива numpy.ndarray . Для этого будем идти по следующим шагам:
- Узнаем размер массива и индексы вдоль оси
- Изменим размер массива
Рассмотрим каждый этап подробнее.
Как узнать размер массива и индексы вдоль оси
Чтобы изменить размер numpy.ndarray , нужно узнать его значение. Для этого используют атрибут shape :
import numpy as np one_dimension_array = np.array( [0,1,2,3,4,5,6,7,8,9,10,11] ) print(one_dimension_array.shape) # => (12,) two_dimensions_array = np.array( [ [0,1,2], [3,4,5], [6,7,8], [9,10,11] ] ) print(two_dimensions_array.shape) # => (4, 3) three_dimensions_array = np.array( [ [ [0,1], [2,3], ], [ [4,5], [6,7], ], [ [8,9], [10,11] ] ] ) print(three_dimensions_array.shape) # => (3, 2, 2)В примере выше атрибут shape возвращает кортеж целых чисел. Длина кортежа указывает на размерность массива:
- (12,) — одномерный массив
- (4, 3) — двумерный массив
- (3, 2, 2) — трехмерный массив
Числа в кортеже означают количество элементов по конкретной оси индексов:
- (12,) — 12 значений
- (4, 3) — четыре блока значений по три значения в каждом
- (3, 2, 2) — три блока значений, каждый из которых состоит из двух блоков по два значения
Название ось индексов отсылает к декартовой системе координат. Вспомним ее основные правила:
- Чтобы построить отрезок или другой одномерный объект, достаточно одной координатной оси
- Чтобы построить квадрат или другой двумерный объект, необходима координатная плоскость из двух перпендикулярных осей
- Чтобы построить куб или другой трехмерный объект, нужно три ортогональные оси координат
Теперь, когда мы знаем размер исходного массива, можно изменять его форму. Для этого используем метод reshape() .
Как изменить размер массива с помощью метода reshape()
В Python используется метод reshape() , с помощью которого можно получить двухмерный и трехмерный массив из одномерного. Этот обязательный параметр ожидает новый размер данных, к которому нужно переформатировать исходный массив.
Попробуем получить двумерный массив two_dimensions_array из одномерного массива one_dimension_array . Для этого используем метод reshape() с новым размером данных (4, 3) :
print(one_dimension_array.reshape((4, 3))) # => [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]]Чтобы получить трехмерный массив three_dimensions_array , достаточно также указать нужный размер:
print(one_dimension_array.reshape((3, 2, 2))) # => [[[ 0 1] # [ 2 3]] # [[ 4 5] # [ 6 7]] # [[ 8 9] # [10 11]]]Изменять форму массива можно не только от данных меньшей размерности к данным большей размерности. Это можно делать и в обратную сторону.
Попробуем получить исходный одномерный массив one_dimension_array из двумерного массива two_dimensions_array :
print(two_dimensions_array.reshape((12,))) # => [ 0 1 2 3 4 5 6 7 8 9 10 11]А тут переформатируем three_dimensions_array в two_dimensions_array :
print(three_dimensions_array.reshape((4,3))) # => [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]]Необязательно уменьшать размер последовательно. Например, можно из трехмерного массива получить сразу одномерный:
print(three_dimensions_array.reshape((12,))) # => [ 0 1 2 3 4 5 6 7 8 9 10 11]С помощью атрибута shape можно узнать размерность массива numpy.ndarray . А метод reshape поможет ее уменьшить или увеличить. Однако у этого массива есть ограничения по размеру данных — его нужно соблюдать, чтобы оптимизировать выполнения методов над массивами.
Какие размеры массива допустимы
У массива numpy.ndarray есть ограничения по размеру данных — по осям индексов должны быть данные одного размера. Это ограничение позволяет оптимизировать выполнения методов над массивами. Рассмотрим на примере.
Допустим, нам нужно сконвертировать список из списков длиной три и два:
np.array( [ [0,1,2], [3,4,], ] ) # => [list([0, 1, 2]) list([3, 4])]На первый взгляд у нас получился массив numpy.ndarray . Но если внимательно посмотреть на элементы, мы увидим, что получились списки, а не ожидаемые целочисленные массивы. Это ограничит дальнейшую работу с данными, потому что поведение многих методов меняется.
Попробуем найти в данном массиве максимальный элемент 4 . Это приведет к такому результату:
print(np.array( [ [0,1,2], [3,4,], ] ).max()) # => [3, 4]В этом примере мы получили не тот результат, которого ожидали.
Numpy старается предотвращать некорректные действия — для этого в нем есть система предупреждений и подсказок. Но это не значит, что не нужно следить за размером массива. Он играет важную роль в реализации методов библиотеки Numpy, поэтому рекомендуем обращать внимание на этот момент.
В случае с методом reshape() Numpy вообще не дает совершить некорректную конвертацию массива из 12 элементов в массив из 15 элементов — три блока по пять значений. В этом случае он вызывает исключение:
one_dimension_array.reshape(3,5) # => ValueError: cannot reshape array of size 12 into shape (3,5)Ограничения по размеру могут добавить неудобств, когда мы увеличиваем или уменьшаем размерность массива. При этом они позволяют не указывать некоторые значения размера, когда мы хотим его изменить.
Как сделать автоматический расчет размера массива
Ограничения на размер массива позволяют не указывать некоторые размеры в методе reshape() . Это можно оставить на автоматический расчет. Для этого нужное значение размерности поменяем на -1 :
print(one_dimension_array.reshape((4,3))) print(one_dimension_array.reshape(((4, -1)))) print(one_dimension_array.reshape(((-1, 3)))) # => [[ 0 1 2] # [ 3 4 5] # [ 6 7 8] # [ 9 10 11]]Все преобразования в примере выше дают одинаковый результат. Необходимый размер рассчитывается автоматически, исходя из количества элементов.
Для массивов большей размерности это работает по такому же принципу:
print(one_dimension_array.reshape((3, 2, 2))) print(one_dimension_array.reshape((-1, 2, 2))) print(one_dimension_array.reshape((3, -1, 2))) print(one_dimension_array.reshape((3, 2, -1))) # => [[[ 0 1] # [ 2 3]] # [[ 4 5] # [ 6 7]] # [[ 8 9] # [10 11]]]Чтобы получить одномерный массив и использовать автоматический расчет, не нужно находить количество элементов. Строки в примере ниже дают одинаковый результат:
print(three_dimensions_array.reshape((12,))) print(three_dimensions_array.reshape((-1,))) # => [ 0 1 2 3 4 5 6 7 8 9 10 11]Теперь вы знаете, как определять размерность массива. Вы умеете изменять размер и рассчитывать его автоматически. Чтобы закрепить знания на практике, рассмотрим еще один пример.
Как размер массива меняется на практике
Изменение формы массива помогает подготовить исходные данные — после такой обработки их будет удобнее анализировать и преобразовывать.
Представим сервис платформы продаж, который логирует данные по сетевым магазинам в конце рабочего дня в определенном порядке. Аналитики выгрузили данные из закрытого контура платформы. Так они получили 24 значения недельных продаж сети:
orders = [7, 1, 7, 8, 4, 2, 4, 5, 3, 5, 2, 3, 8, 12, 8, 7, 15, 11, 13, 9, 21, 18, 17, 21, 25, 16, 25, 17,] shops_number = 4 orders_matrix = np.array(orders) orders_matrix = orders_matrix.reshape(-1, shops_number) print(orders_matrix) # => [[ 7 1 7 8] # [ 4 2 4 5] # [ 3 5 2 3] # [ 8 12 8 7] # [15 11 13 9] # [21 18 17 21] # [25 16 25 17]] print(orders_matrix.shape) # => (7, 4)Полученный массив данных можно визуализировать в виде такой таблицы:
День Магазин №1 Магазин №2 Магазин №3 Магазин №4 0 7 1 7 8 1 4 2 4 5 2 3 5 2 3 3 8 12 8 7 4 15 11 13 9 5 21 18 17 21 6 25 16 25 17 Выводы
Метод shape — важный атрибут для структурного описания массива numpy.ndarray . Он помогает узнать размер вдоль каждой оси.
Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях:
-