Numerical Python
реклама
ВОСТОКОВА ЕЛИЗАВЕТА 222 ГР.
это расширение языка Python, добавляющее
поддержку больших многомерных массивов и матриц,
вместе с большой библиотекой математических
функций для операций с этими массивами.
Numeric – был создан в 1995 году
медленно работает на больших
массивах
(рабочий, но устаревший)
Numarray – новая версия Numeric
(сейчас так же устаревший)
NumPy – объединение Numeric и Numarray
Последняя версия NumPy version 1.3.0,
выпущена 5 Апреля 2009 года и поддерживает
Python 2.6
Содержит элементы только одного типа
Может быть многомерным
Операции с массивами в NumPy выполняются
поэлементно
Массивы работают быстрее
Более функциональны
Массив вложенных массивов:
from numarray import *
pyarr = [[1,2,3], [4,5,6], [7,8,9]]
print pyarr
#[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
pyarr [1] [1] = 0
print pyarr
#[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
from numarray import *
numarr = array(pyarr)
print numarr
#[[1 2 3]
# [4 0 6]
# [7 8 9]]
Поэлементные операции:
numarr2 = numarr * 2
print numarr2
#[[ 2 4 6]
#[ 8 0 12]
#[14 16 18]]
print numarr2 + numarr
#[[ 3 6 9]
#[12 0 18]
#[21 24 27]]
Изменение «формы» массива:
numarr2.shape = (9,)
print numarr2
#[ 2 4 6 8 0 12 14 16 18]
numpy.arccos()
from numpy import *
arccos(array([0, 1]))
#array([ 1.57079633, 0.
])
numpy.arcsin(...)
from numpy import *
arcsin(array([0, 1]))
#array([ 0.
, 1.57079633])
tan(), sin()
Возвращает строковое представление
массива:
x = np.array([1e-16,1,2,3])
print np.array2string(x, precision=2,
separator=',', suppress_small=True)
#[ 0., 1., 2., 3.]
array_repr() == array_str() == array2string()
Сравнение массивов (поэлементное).
Возвращает значения True or False.
np.array_equal([1,2],[1,2])
#True
np.array_equal([1,2],[1,2,3])
#False
np.array_equal([1,2],[1,4])
#False
Разбивает массив на несколько равных
частей
x = np.arange(8.0)
np.array_split(x, 3)
#[array([ 0., 1., 2.]), array([ 3., 4., 5.]),
# array([ 6., 7.])]
Возвращает массив со значениями Float
np.asfarray([2, 3])
#array([ 2., 3.])
np.asfarray([2, 3], dtype='float')
#array([ 2., 3.])
Возвращает числу комплексно сопряженное ему.
np.conjugate(1+2j)
#(1-2j)
Преобразовывает углы из радиан в
градусы
np.degrees(np.pi/2)
#90.0
Преобразовывает углы из градусов в
радианы
np.radians(180)
#3.1415926535897931
Выписывает диагональные элементы массива
(матрицы):
from numpy import *
a = arange(12).reshape(4,3)
print a
#[[ 0 1 2]
#[ 3 4 5]
#[ 6 7 8]
#[ 9 10 11]]
print diag(a,k=0)
#[0 4 8]
print diag(a,k=1)
#[1 5]
Сворачивает любой массив в одномерный
from numpy import *
a = array([[[1,2]],[[3,4]]])
print a
#[[[1 2]]
#[[3 4]]]
b = a.flatten()
# b - одномерный
print b
#[1 2 3 4]
Разворачивает каждую строку массива
from numpy import *
a = arange(12).reshape(4,3)
print a
#array([[ 0, 1, 2],
#[ 3, 4, 5],
#[ 6, 7, 8],
#[ 9, 10, 11]])
fliplr(a)
# flip left-right
#array([[ 2, 1, 0],
#[ 5, 4, 3],
#[ 8, 7, 6],
#[11, 10, 9]])
Разворачивает массив сверху вниз
from numpy import *
a = arange(12).reshape(4,3)
print a
#array([[ 0, 1, 2],
#[ 3, 4, 5],
#[ 6, 7, 8],
#[ 9, 10, 11]])
flipud(a)
# flip up-down
#array([[ 9, 10, 11],
#[ 6, 7, 8],
#[ 3, 4, 5],
#[ 0, 1, 2]])
Возвращает массив с единицами на главной
диагонали
from numpy import *
identity(3,float)
#array([[ 1., 0., 0.],
#[ 0., 1., 0.],
#[ 0., 0., 1.]])
Вычисляет обратную матрицу
from numpy import *
from numpy.linalg import inv
a = array([[3,1,5],[1,0,8],[2,1,4]])
print a
#[[3 1 5]
#[1 0 8]
#[2 1 4]]
inva = inv(a)
# Обращает матрицу
print inva
#[[ 1.14285714 -0.14285714 -1.14285714]
#[-1.71428571 -0.28571429 2.71428571]
#[-0.14285714 0.14285714 0.14285714]]
dot(a, inva)
# Проверяет результат
#array([[ 1.00000000e-00, 2.77555756e-17, 3.60822483e-16],
#[ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00],
#[ -1.11022302e-16, 0.00000000e+00, 1.00000000e+00]])
Операции выполняются поэлементно.
from numpy import *
logical_and(array([0,0,1,1]), array([0,1,0,1]))
#array([False, False, False, True], dtype=bool)
x = np.arange(5)
np.logical_not(x<3)
#array([False, False, False, True, True],
dtype=bool)
x = np.arange(5)
np.logical_or(x < 1, x > 3)
#array([ True, False, False, False, True],
dtype=bool)
Возвращает максимальное (минимальное) значение массива
from numpy import *
a = array([10,20,30])
a.max()
#30
a = array([[10,50,30],[60,20,40]])
a.max()
#60
a.max(axis=0)
# находит максимум в каждом столбце
#array([60, 50, 40])
a.max(axis=1)
# находит максимум в каждой строке
#array([50, 60])
Возвращает произвольные целые значения в
заданной области
from numpy import *
from numpy.random import *
random_integers(-1,5,(2,2))
#array([[ 3, -1],
#[-1, 0]])
Так же есть random_sample(), которая
возвращает произвольные значения в
промежутке от 0 до 1.
При возвращении сортируются уникальные
элементы массива или последовательности
from numpy import *
x = array([2,3,2,1,0,3,4,0])
unique(x)
# remove double values
#array([0, 1, 2, 3, 4])
Создается нулевой массив
from numpy import *
zeros(5)
#array([ 0., 0., 0., 0., 0.])
zeros((2,3), int)
#array([[0, 0, 0],
#[0, 0, 0]])
Это открытая библиотека
высококачественных научных инструментов
для языка программирования Python.
Содержит модули для:
Оптимизации
Интегрирования
Специальных функций
Обработки сигналов
Обработки изображений
Генетических алгоритмов
Решения обыкновенных дифференциальных
уравнений
И других задач
Основной структурой данный в SciPy
является многомерный массив
реализованный модулем NumPy.
scipy.array(alist): создаёт n-мерный массив из
списка
Пример:
a = scipy.array([[1,2,3],[4,5,6]])
b = scipy.array([i*i for i in range(100) if i%2==1])
c = b.tolist() # конвертирует массив обратно в
список
scipy.zeros(shape, dtype=float): создаёт nмерный массив заданной формы,
заполненный нулями заданного типа
a = scipy.zeros(100) # 100 элементный
массив нулей, тип float
b = scipy.zeros((2,8), int) # массив нулей
размера 2x8 типа int
c = scipy.zeros((N,M,L), complex) # массив
нулей NxMxL тип complex
scipy.ones(shape, dtype=float): создаёт nмерный массив заданной формы,
заполнены единицами заданного типа
a = scipy.ones(10, int) # 10 элементный
массив единиц типа int
b = scipy.pi * scipy.ones((5,5)) # хороший
способ заполнить массив заданным
значением
scipy.eye(shape, dtype=float)
id = scipy.eye(10,10) # 10x10 единичная
матрица (единицы по диагонали)
offdiag = scipy.eye(10,10,1)+scipy.eye(10,10,-1)
# единицы по сдвинутой от центра диагонали
scipy.transpose(a) # транспонирует массив
b = scipy.transpose(a) # заменяет строки на
столбцы для двумерной матрицы
(транспонирование), и заменяет оси друг
на друга для размерностей больше 2х.
b = a.T # эквивалентно scipy.transpose(a)
c = scipy.swapaxes(a, axis1, axis2) # меняет
местами заданные оси
scipy.random создание случайного массива
a = scipy.random.random((100,100)) # массив
размера 100x100 содержащий значения типа float
равномерно распределенные на интервале [0.,1.)
b = scipy.random.randint(0,10, (100,)) # 100 значений
формата int равномерно распределённых на
интервале [0, 10), то есть не включающем верхней
границы - 10
c = scipy.random.standard_normal((5,5,5)) #
стандартное нормальное распределение
(среднее=0, стандартное отклонение =1) в массиве
5x5x5
Многомерное индексирование
elem = a[i, j, k] # эквивалентно a[i][j][k] но
более эффективно
"Отрицательное" индексирование
(начинается с конца массива)
last_elem = a[-1] # последний элемент
массива
i = scipy.array([0,1,2,1]) # массив индексов
для первой оси
j = scipy.array([1,2,3,4]) # массив индексов
для второй оси
a[i, j] # возвращает массив ([a[0,1], a[1,2],
a[2,3], a[1,4]])
b = scipy.array([True, False, True, False])
a[b] # возвращает массив ([a[0], a[2]])
поскольку только b[0] и b[2] являются True
Срез определенного подблока:
section = a[10:20, 30:40] # 10x10 подблок
начинающийся в [10,30]
Захватить все до начала/конца массива:
asection = a[10:, 30:] # отсутствие
завершающего индекса подразумевает "до
конца массива"
bsection = b[:10, :30] # отсутствие стартового
индекса подразумевает "до начала массива"
Захватить всю колонку(ки)
x = a[:, 0] # взять все значения из нулевой колонки
(нет ни начала ни конца, то есть берем все строки)
y = a[:, 1] # взять все значения из первой колонки
(соответственно все строки)
Срезать хвост массива
tail = a[-10:] # получить последние 10 элементов
массива
slab = b[:, -10:] # получить блок шириной 10 с "боку"
массива
interior = c[1:-1, 1:-1, 1:-1] # вырезать все кроме
внешней "оболочки"
c = a + b # сложить a и b поэлементно
d = e * f # перемножить e и f поэлементно
g = -h # меняет знак каждого элемента h
y = (x+1)%2 # меняет местами нули и
единицы в бинарном массиве x
y = scipy.sin(x) # синус каждого элемента x
z = scipy.exp((0.+1.j) * theta) # exp(i * theta)
где i = sqrt(-1) = 0.+1.j
s = scipy.sum(a) # сумма всех элементов a,
возвращает скаляр
s0 = scipy.sum(a, axis=0) # сумма элементов
вдоль определенной оси (=0), возвращает
массив оставшейся формы
например:
a = scipy.ones((10,20,30))
s0 = scipy.sum(a, axis=0) # s0 имеет форму
(20,30)
m = scipy.mean(a, axis) # вычисляет
среднее вдоль определенной оси (если
axis = None, осреднение происходит по
всему массиву)
scipy.any(a): возвращает True если любой из элементов a
является True
scipy.all(a): возвращает True если все элементы a являются True
scipy.alltrue(a, axis): применяет ЛОГИЧЕСКОЕ И вдоль
заданной оси a
scipy.append(a, values, axis): добавляет значения к a вдоль
заданной оси
scipy.concatenate((a1, a2, ...), axis): объединяет кортеж
массивов вдоль определенной оси
scipy.min(a, axis=None), scipy.max(a, axis=None): выдает
min/max значения вдоль определенной оси (по всему массиву
если axis=None)
scipy.argmin(a, axis=None), scipy.argmax(a, axis=None): выдает
индексы значений min/max массива a вдоль определенной оси
(для всего массива если axis=None)
scipy.reshape(a, newshape): изменяет форму
массива (общее количество элементов массива
должно сохраняться)
scipy.matrix(a): создает матрицу из двухмерного
массива a (в матрицах реализовано матричное
умножение вместо поэлементного умножения)
scipy.around(a, decimals=0): округляет элементы
массива до определенного количества знаков
после запятой
scipy.sign(a): возвращает массив такой же формы
как a, с -1 где a < 0, 0 где a = 0, и +1 где a > 0
scipy.fliplr(a): перевернуть массив слева на
право
scipy.flipud(a): перевернуть массив сверху
вниз
a = a[:,:,:,::-1] - перевернуть одну из осей
массива любой размерности
from scipy import optimize, special
from numpy import *
from pylab import *
x = arange(0,10,0.01)
for k in arange(0.5,5.5):
y = special.jv(k, x)
plot(x, y)
f = lambda x: -special.jv(k, x)
x_max = optimize.fminbound(f,0,6)
plot([x_max], [special.jv(k, x_max)], 'ro')
title('Different Bessel functions and their local maxima')
show()
constants: Физические константы и коэффициенты пересчёта (с
версии 0.7.0[1])
cluster: Векторное квантование
fftpack: Дискретные алгоритмы преобразования Фурье
integrate: Инструменты для интегрирования
interpolate: Инструменты для интерполяции
io: Ввод/вывод данных
lib: Врапперы Python для внешних библиотек
linalg: Линейная алгебра
misc: Разные утилиты
optimize: Средства оптимизации
sandbox: Экспериментальный код
signal: Обработка сигналов
sparse: Поддержка разреженных матриц
special: Специальные функции
stats: Статистические функции
weave: Позволяет включение кода C/C++ внутри кода Python
Графика.
Оптимизация.
Продвинутый анализ данных.
База данных.
Интерактивная оболочка.
Символьная математика.
http://www.scipy.org/more_about_SciPy
http://www.scipy.org/SciPy
http://www.rexx.com/~dkuhlman/scipy_course_
01.html
http://ru.wikipedia.org/wiki/SciPy
http://ru.wikipedia.org/wiki/NumPy
http://www.lassp.cornell.edu/sethna/DM/Docum
entation/numpy.pdf
http://www.python.ru/files/book-ods.pdf
http://pages.physics.cornell.edu/~myers/teachin
g/ComputationalMethods/python/arrays.html
