Предисловие переводчика Продолжаем переводить статью про numpy на python. Для тех, кто не читал первую часть, вот она: Часть 1 .
Всем остальным приятного чтения.
- Часть 3
- Часть 4
- Оригинал
Функции нулей и единиц создают новые массивы указанного размера, заполненные этими значениями.>>> np.arange(5, dtype=float) array([ 0., 1., 2., 3., 4.]) >>> np.arange(1, 6, 2, dtype=int) array([1, 3, 5])
Вероятно, это самые простые в использовании функции для создания массивов: >>> np.ones((2,3), dtype=float)
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
>>> np.zeros(7, dtype=int)
array([0, 0, 0, 0, 0, 0, 0])
Функции «zeros_like» и «ones_like» могут преобразовывать уже созданный массив, заполняя его нулями и единицами соответственно: >>> a = np.array([[1, 2, 3], [4, 5, 6]], float)
>>> np.zeros_like(a)
array([[ 0., 0., 0.],
[ 0., 0., 0.]])
>>> np.ones_like(a)
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
Также имеется ряд функций для создания специальных матриц.
Чтобы создать квадратную матрицу с главной диагональю, заполненной единицами, мы воспользуемся методом тождества: >>> np.identity(4, dtype=float)
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
Функция глаза возвращает матрицу с единицами на k-й диагонали: >>> np.eye(4, k=1, dtype=float)
array([[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.],
[ 0., 0., 0., 0.]])
Математические операции с массивами
Когда мы используем стандартные математические операции над массивами, необходимо соблюдать принцип: элемент-элемент. Это означает, что массивы должны быть одинакового размера при сложении, вычитании и подобных операциях: >>> a = np.array([1,2,3], float)
>>> b = np.array([5,2,6], float)
>>> a + b
array([6., 4., 9.])
>>> a – b
array([-4., 0., -3.])
>>> a * b
array([5., 4., 18.])
>>> b / a
array([5., 1., 2.])
>>> a % b
array([1., 0., 3.])
>>> b**a
array([5., 4., 216.])
Для двумерных массивов умножение остается поэлементным и не соответствует умножению матрицы.
Для этого есть специальные функции, которые мы изучим позже.
>>> a = np.array([[1,2], [3,4]], float)
>>> b = np.array([[2,0], [1,3]], float)
>>> a * b
array([[2., 0.], [3., 12.]])
При несоответствии размеров выдаются ошибки: >>> a = np.array([1,2,3], float)
>>> b = np.array([4,5], float)
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,) (2,)
Однако если размеры массивов не совпадают, они будут преобразованы для выполнения математических операций.
Это часто означает, что меньший массив будет использоваться несколько раз для завершения операций.
Рассмотрим этот пример: >>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> b = np.array([-1, 3], float)
>>> a
array([[ 1., 2.],
[ 3., 4.],
[ 5., 6.]])
>>> b
array([-1., 3.])
>>> a + b
array([[ 0., 5.],
[ 2., 7.],
[ 4., 9.]])
Здесь одномерный массив b был преобразован в двумерный массив, размер которого соответствует размеру массива a. По сути, b повторялось несколько раз для каждой «строки» a. В противном случае это можно представить так: array([[-1., 3.],
[-1., 3.],
[-1., 3.]])
В этом случае Python автоматически преобразует массивы.
Однако иногда, когда преобразование играет роль, мы можем использовать константу newaxis, чтобы изменить преобразование: >>> a = np.zeros((2,2), float)
>>> b = np.array([-1., 3.], float)
>>> a
array([[ 0., 0.],
[0., 0.]])
>>> b
array([-1., 3.])
>>> a + b
array([[-1., 3.],
[-1., 3.]])
>>> a + b[np.newaxis,:]
array([[-1., 3.],
[-1., 3.]])
>>> a + b[:,np.newaxis]
array([[-1., -1.],
[ 3., 3.]])
Помимо стандартных операторов, numpy включает библиотеку стандартных математических функций, которые можно применять к массивам поэлементно.
Фактические функции: abs, знак, sqrt, log, log10, exp, sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh и arctanh. >>> a = np.array([1, 4, 9], float)
>>> np.sqrt(a)
array([ 1., 2., 3.])
Функцииfloor, ceil и rint возвращают нижнее, верхнее или ближайшее (округленное) значение: >>> a = np.array([1.1, 1.5, 1.9], float)
>>> np.floor(a)
array([ 1., 1., 1.])
>>> np.ceil(a)
array([ 2., 2., 2.])
>>> np.rint(a)
array([ 1., 2., 2.])
Numpy также включает в себя две важные математические константы: >>> np.pi
3.1415926535897931
>>> np.e
2.7182818284590451
Перебор элементов массива
Вы можете перебирать массивы аналогично спискам: >>> a = np.array([1, 4, 5], int)
>>> for x in a:
.
print x
1
4
5
Для многомерных массивов итерация будет проходить вдоль первой оси, так что каждый проход цикла будет возвращать «строку» массива: >>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> for x in a:
.
print x
[ 1. 2.]
[ 3. 4.]
[ 5. 6.]
Множественное присваивание также доступно при итерации: >>> a = np.array([[1, 2], [3, 4], [5, 6]], float)
>>> for (x, y) in a:
.
print x * y
2.0
12.0
30.0
Основные операции с массивами
Существует множество функций для получения любых свойств массивов.
?Элементы можно суммировать или умножать: >>> a = np.array([2, 4, 3], float)
>>> a.sum()
9.0
>>> a.prod()
24.0
В этом примере использовались функции массива.
Вы также можете использовать собственные функции numpy: >>> np.sum(a)
9.0
>>> np.prod(a)
24.0
В большинстве случаев можно использовать оба варианта.
Некоторые функции позволяют работать со статистическими данными.
Это функции среднего (среднего арифметического), вариации и отклонения: >>> a = np.array([2, 1, 9], float)
>>> a.mean()
4.0
>>>
a.var()
12.666666666666666
>>> a.std()
3.5590260840104371
Вы можете найти минимум и максимум в массиве: >>> a = np.array([2, 1, 9], float)
>>> a.min()
1.0
>>> a.max()
9.0
Функции argmin и argmax возвращают индекс минимального или максимального элемента: >>> a = np.array([2, 1, 9], float)
>>> a.argmin()
1
>>> a.argmax()
2
Для многомерных массивов каждая из функций может принимать дополнительную ось-аргумент и в зависимости от ее значения выполнять функции вдоль определенной оси, помещая результаты выполнения в массив: >>> a = np.array([[0, 2], [3, -1], [3, 5]], float)
>>> a.mean(axis=0)
array([ 2., 2.])
>>> a.mean(axis=1)
array([ 1., 1., 4.])
>>> a.min(axis=1)
array([ 0., -1., 3.])
>>> a.max(axis=0)
array([ 3., 5.])
Как и списки, массивы можно сортировать: >>> a = np.array([6, 2, 5, -1, 0], float)
>>> sorted(a)
[-1.0, 0.0, 2.0, 5.0, 6.0]
>>> a.sort()
>>> a
array([-1., 0., 2., 5., 6.])
Значения в массиве можно «обрезать», чтобы они поместились в заданный диапазон.
Это то же самое, что применить min(max(x, minval), maxval) к каждому элементу x: >>> a = np.array([6, 2, 5, -1, 0], float)
>>> a.clip(0, 5)
array([ 5., 2., 5., 0., 0.])
Уникальные элементы можно извлечь следующим образом: >>> a = np.array([1, 1, 4, 5, 5, 5, 7], float)
>>> np.unique(a)
array([ 1., 4., 5., 7.])
Для двумерных массивов диагональ можно получить так: >>> a = np.array([[1, 2], [3, 4]], float)
>>> a.diagonal()
array([ 1., 4.])
Вот и подошла к концу вторая статья.
Спасибо за внимание и удачи в ваших начинаниях! До скорой встречи.
Теги: #перевод с английского #python3 #Numpy #Массивы #python
-
Дизайн Роботов В Planet Of The Eyes
19 Oct, 24 -
Коитераторы По Таймерам
19 Oct, 24 -
Mp3-Файл "Protect" На Amazon.com
19 Oct, 24 -
Создание Uml Из Существующего Кода Php
19 Oct, 24
