LeoMat Jun 10 2011 at 17:48

NumPy, пособие для новичков. Часть 1

19 min

241K

Translation

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

Первая часть учебника рассказывает об основах работы с NumPy: создании массивов, их атрибутах, базовых операциях, поэлементном применении функций, индексах, срезах, итерировании. Рассматриваются различные манипуляции с преобразованием формы массива, объединение массивов из нескольких и наоборот — разбиение одного на несколько более мелких. В конце мы обсудим поверхностное и глубокое копирование.

Основы

Если вы еще не устанавливали NumPy, то взять его можно здесь. Используемая версия Python — 2.6.

Основным объектом NumPy является однородный многомерный массив. Это таблица элементов (обычно чисел), всех одного типа, индексированных последовательностями натуральных чисел.

Под «многомерностью» массива мы понимаем то, что у него может быть несколько измерений или осей. Поскольку слово «измерение» является неоднозначным, вместо него мы чаще будем использовать слова «ось» (axis) и «оси» (axes). Число осей называется рангом (rank).

Например, координаты точки в трехмерном пространстве [1, 2, 1] это массив ранга 1 у него есть только одна ось. Длина этой оси — 3. Другой пример, массив

[[ 1., 0., 0.],

 [ 0., 1., 2.]]

представляет массив ранга 2 (то есть это двухмерный массив). Длина первого измерения (оси) — 2, длина второй оси — 3. Для получения дополнительной информации смотрите глоссарий Numpy.

Класс многомерных массивов называется ndarray. Заметим, что это не то же самое, что класс array стандартной библиотеки Python, который используется только для одномерных массивов. Наиболее важные атрибуты объектов ndarray:

ndarray.ndim — число осей (измерений) массива. Как уже было сказано, в мире Python число измерений часто называют рангом.

ndarray.shape — размеры массива, его форма. Это кортеж натуральных чисел, показывающий длину массива по каждой оси. Для матрицы из n строк и m столбов, shape будет (n,m). Число элементов кортежа shape равно рангу массива, то есть ndim.

ndarray.size — число всех элементов массива. Равно произведению всех элементов атрибута shape.

ndarray.dtype — объект, описывающий тип элементов массива. Можно определить dtype, используя стандартные типы данных Python. NumPy здесь предоставляет целый букет возможностей, например:

bool_, character, int_, int8, int16, int32, int64, float_, float8, float16, float32, float64, complex_, complex64, object_

.

ndarray.itemsize — размер каждого элемента массива в байтах. Например, для массива из элементов типа float64 значение itemsize равно 8 (=64/8), а для complex32 этот атрибут равен 4 (=32/8).

ndarray.data — буфер, содержащий фактические элементы массива. Обычно нам не будет нужно использовать этот атрибут, потому как мы будем обращаться к элементам массива с помощью индексов.

Пример

Определим следующий массив:

Copy Source | Copy HTML >>> from numpy import * >>> a = arange(10).reshape(2,5) >>> a array([[ 0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]) 

Мы только что создали объект массива с именем a. У массива a есть несколько атрибутов или свойств. В Python атрибуты отдельного объекта обозначаются как name_of_object.attribute. В нашем случае:

a.shape это (2,5)
a.ndim это 2 (что равно длине a.shape)
a.size это 10
a.dtype.name это int32
a.itemsize это 4, что означает, что int32 занимает 4 байта памяти.

Вы можете проверить все эти атрибуты, просто набрав их в интерактивном режиме:

Copy Source | Copy HTML >>> a.shape (2, 5) >>> a.dtype.name 'int32' 

И так далее.

Создание массивов

Есть много способов для того, чтобы создать массив. Например, вы можете создать массив из обычных списков или кортежей Python, используя функцию array():

Copy Source | Copy HTML >>> from numpy import * >>> a = array( [2,3,4] ) >>> a array([2, 3, 4]) >>> type(a) <type 'numpy.ndarray'> 

Функция array() трансформирует вложенные последовательности в многомерные массивы. Тип массива зависит от типа элементов исходной последовательности.

Copy Source | Copy HTML >>> b = array( [ (1.5,2,3), (4,5,6) ] ) # это станет массивом float элементов >>> b array([[ 1.5, 2. , 3. ], [ 4. , 5. , 6. ]]) 

Раз у нас есть массив, мы можем взглянуть на его атрибуты:

Copy Source | Copy HTML >>> b.ndim # число осей 2 >>> b.shape # размеры (2, 3) >>> b.dtype # тип (8-байтовый float) dtype('float64') >>> b.itemsize # размер элемента данного типа 8 

Тип массива может быть явно указан в момент создания:

Copy Source | Copy HTML >>> c = array( [ [1,2], [3,4] ], dtype=complex ) >>> c array([[ 1.+ 0.j, 2.+ 0.j], [ 3.+ 0.j, 4.+ 0.j]]) 

Часто встречающаяся ошибка состоит в вызове функции array() с множеством числовых аргументов вместо предполагаемого единственного аргумента в виде списка чисел:

Copy Source | Copy HTML >>> a = array(1,2,3,4) # WRONG >>> a = array([1,2,3,4]) # RIGHT 

Функция array() не единственная функция для создания массивов. Обычно элементы массива вначале неизвестны, а массив, в котором они будут храниться уже нужен. Поэтому имеется несколько функций для того, чтобы создавать массивы с каким-то исходным содержимым. По умолчанию тип создаваемого массива — float64.

Функция zeros() создает массив нулей, а функция ones() — массив единиц:

Copy Source | Copy HTML >>> zeros( (3,4) ) # аргумент задает форму массива array([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.]]) >>> ones( (2,3,4), dtype=int16 ) # то есть также может быть задан dtype array([[[ 1, 1, 1, 1], [ 1, 1, 1, 1], [ 1, 1, 1, 1]], [[ 1, 1, 1, 1], [ 1, 1, 1, 1], [ 1, 1, 1, 1]]], dtype=int16)

Функция empty() создает массив без его заполнения. Исходное содержимое случайно и зависит от состояния памяти на момент создания массива (то есть от того мусора, что в ней хранится):

Copy Source | Copy HTML >>> empty( (2,3) ) array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260], [ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]]) >>> empty( (2,3) ) # содержимое меняется при новом вызове array([[ 3.14678735e-307, 6.02658058e-154, 6.55490914e-260], [ 5.30498948e-313, 3.73603967e-262, 8.70018275e-313]]) 

Для создания последовательностей чисел, в NumPy имеется функция, аналогичная range(), только вместо списков она возвращает массивы:

Copy Source | Copy HTML >> arange( 10, 30, 5 ) array([10, 15, 20, 25]) >>> arange( 0, 2, 0.3 ) array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8]) 

При использовании arange() с аргументами типа float, сложно быть уверенным в том, сколько элементов будет получено (из-за ограничения точности чисел с плавающей запятой). Поэтому, в таких случаях обычно лучше использовать функцию linspace() которая вместо шага в качестве одного из аргументов принимает число, равное количеству нужных элементов:

Copy Source | Copy HTML >>> linspace( 0, 2, 9 ) # 9 чисел от 0 до 2 array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ]) >>> x = linspace( 0, 2*pi, 100 ) # полезно для вычисления значений функции в множестве точек >>> f = sin(x) 

Печать массивов

Когда вы печатаете массив, NumPy показывает их схожим с вложенными списками образом, но размещает немного иначе:

последняя ось печатается слева направо,
предпоследняя — сверху вниз,
и оставшиеся — также сверху вниз, разделяя пустой строкй.

Одномерные массивы выводятся как строки, двухмерные — как матрицы, а трехмерные — как списки матриц.

Copy Source | Copy HTML >>> a = arange(6) # 1d array >>> print a [0 1 2 3 4 5] >>> >>> b = arange(12).reshape(4,3) # 2d array >>> print b [[ 0 1 2] [ 3 4 5] [ 6 7 8] [ 9 10 11]] >>> >>> c = arange(24).reshape(2,3,4) # 3d array >>> print c [[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]] 

Если массив слишком большой, чтобы его печатать, NumPy автоматически скрывает центральную часть массива и выводит только его уголки:

Copy Source | Copy HTML >>> print arange(10000) [ 0 1 2 ..., 9997 9998 9999] >>> >>> print arange(10000).reshape(100,100) [[ 0 1 2 ..., 97 98 99] [ 100 101 102 ..., 197 198 199] [ 200 201 202 ..., 297 298 299] ..., [9700 9701 9702 ..., 9797 9798 9799] [9800 9801 9802 ..., 9897 9898 9899] [9900 9901 9902 ..., 9997 9998 9999]] 

Если вам действительно нужно увидеть все, что происходит в большом массиве, выведя его полностью, используйте функцию установки печати set_printoptions():

Copy Source | Copy HTML >>> set_printoptions(threshold=nan) 

Базовые операции

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

Copy Source | Copy HTML >>> a = array( [20,30,40,50] ) >>> b = arange( 4 ) >>> c = a-b >>> c array([20, 29, 38, 47]) >>> b**2 array([ 0, 1, 4, 9]) >>> 10*sin(a) array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854]) >>> a<35 array([True, True, False, False], dtype=bool) 

В отличие от матричного подхода, оператор произведения * в массивах NumPy работает также поэлементно. Матричное произведение может быть осуществлено либо функцией dot(), либо созданием объектов матриц, которое будет рассмотрено далее (во второй части пособия).

Copy Source | Copy HTML >>> A = array( [[1,1], ... [ 0,1]] ) >>> B = array( [[2, 0], ... [3,4]] ) >>> A*B # поэлементное произведение array([[2, 0], [ 0, 4]]) >>> dot(A,B) # матричное произведение array([[5, 4], [3, 4]]) 

Некоторые операции делаются «на месте», без создания нового массива.

Copy Source | Copy HTML >>> a = ones((2,3), dtype=int) >>> b = random.random((2,3)) >>> a *= 3 >>> a array([[3, 3, 3], [3, 3, 3]]) >>> b += a >>> b array([[ 3.69092703, 3.8324276 , 3.0114541 ], [ 3.18679111, 3.3039349 , 3.37600289]]) >>> a += b # b конвертируется к типу int >>> a array([[6, 6, 6], [6, 6, 6]]) 

При работе с массивами разных типов, тип результирующего массива соответствует более общему или более точному типу.

Copy Source | Copy HTML >>> a = ones(3, dtype=int32) >>> b = linspace( 0,pi,3) >>> b.dtype.name 'float64' >>> c = a+b >>> c array([ 1. , 2.57079633, 4.14159265]) >>> c.dtype.name 'float64' >>> d = exp(c*1j) >>> d array([ 0.54030231+ 0.84147098j, - 0.84147098+ 0.54030231j, - 0.54030231- 0.84147098j]) >>> d.dtype.name 'complex128' 

Многие унарные операции, такие как вычисление суммы всех элементов массива, представлены в виде методов класса ndarray.

Copy Source | Copy HTML >>> a = random.random((2,3)) >>> a array([[ 0.6903007 , 0.39168346, 0.16524769], [ 0.48819875, 0.77188505, 0.94792155]]) >>> a.sum() 3.4552372100521485 >>> a.min() 0.16524768654743593 >>> a.max() 0.9479215542670073 

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

Copy Source | Copy HTML >>> b = arange(12).reshape(3,4) >>> b array([[ 0, 1, 2, 3], [ 4, 5, 6, 7], [ 8, 9, 10, 11]]) >>> >>> b.sum(axis= 0) # сумма в каждом столбце array([12, 15, 18, 21]) >>> >>> b.min(axis=1) # наименьшее число в каждой строке array([ 0, 4, 8]) >>> >>> b.cumsum(axis=1) # накопительная сумма каждой строки array([[ 0, 1, 3, 6], [ 4, 9, 15, 22], [ 8, 17, 27, 38]])

Универсальные функции

NumPy обеспечивает работу с известными математическими функциями sin, cos, exp и так далее. Но в NumPy эти функции называются универсальными (ufunc). Причина присвоения такого имени кроется в том, что в NumPy эти функции работают с массивами также поэлементно, и на выходе получается массив значений.

Copy Source | Copy HTML >>> B = arange(3) >>> B array([ 0, 1, 2]) >>> exp(B) array([ 1. , 2.71828183, 7.3890561 ]) >>> sqrt(B) array([ 0. , 1. , 1.41421356]) >>> C = array([2., -1., 4.]) >>> add(B, C) array([ 2., 0., 6.]) 

Индексы, срезы, итерации

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

Copy Source | Copy HTML >>> a = arange(10)**3 >>> a array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729]) >>> a[2] 8 >>> a[2:5] array([ 8, 27, 64]) >>> a[:6:2] = -1000 # изменить элементы в a >>> a array([-1000, 1, -1000, 27. -1000, 125, 216, 343, 512, 729]) >>> a[::-1] # перевернуть a array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000]) >>> for i in a: ... print i**(1/3.), ... nan 1. 0 nan 3. 0 nan 5.0 6.0 7.0 8.0 9. 0

У многомерных массивов на каждую ось приходится один индекс. Индексы передаются в виде последовательности чисел, разделенных запятыми:

Copy Source | Copy HTML >>> def f(x,y): ... return 10*x+y ... >>> b = fromfunction(f,(5,4),dtype=int) >>> b array([[ 0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33], [40, 41, 42, 43]]) >>> b[2,3] 23 >>> b[:,1] # второй столбец массива b array([ 1, 11, 21, 31, 41]) >>> b[1:3,:] # вторая и третья строки массива b array([[10, 11, 12, 13], [20, 21, 22, 23]])

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

Copy Source | Copy HTML >>> b[-1] # последняя строка. Эквивалентно b[-1,:] array([40, 41, 42, 43]) 

b[i] можно читать как b[i, <столько символов ':', сколько нужно>]. В NumPy это также может быть записано с помощью точек, как b[i, ...].

Например, если x имеет ранг 5 (то есть у него 5 осей), тогда

x[1, 2, ...] эквивалентно x[1, 2, :, :, :],
x[... , 3] то же самое, что x[:, :, :, :, 3] и
x[4, ... , 5, :] это x[4, :, :, 5, :].

Copy Source | Copy HTML >>> c = array( [ [[ 0, 1, 2], # 3d array ... [ 10, 12, 13]], ... ... [[100,101,102], ... [110,112,113]] ] ) >>> c.shape (2, 2, 3) >>> c[1,...] # то же, что c[1,:,:] или c[1] array([[100, 101, 102], [110, 112, 113]]) >>> c[...,2] # то же, что c[:,:,2] array([[ 2, 13], [102, 113]]) 

Итерирование многомерных массивов начинается с первой оси:

Copy Source | Copy HTML >>> for row in b: ... print row ... [0 1 2 3] [10 11 12 13] [20 21 22 23] [30 31 32 33] [40 41 42 43] 

Однако, если нужно перебрать поэлементно весь массив, как если бы он был одномерным, для этого можно использовать атрибут flat:

Copy Source | Copy HTML >>> for element in b.flat: ... print element, ... 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43 

Манипуляции с формой

Как уже говорилось, у массива есть форма (shape), определяемая числом элементов вдоль каждой оси:

Copy Source | Copy HTML >>> a = floor(10*random.random((3,4))) >>> a array([[ 7., 5., 9., 3.], [ 7., 2., 7., 8.], [ 6., 8., 3., 2.]]) >>> a.shape (3, 4) 

Форма массива может быть изменена с помощью различных команд:

Copy Source | Copy HTML >>> a.ravel() # делает массив плоским array([ 7., 5., 9., 3., 7., 2., 7., 8., 6., 8., 3., 2.]) >>> a.shape = (6, 2) >>> a.transpose() array([[ 7., 9., 7., 7., 6., 3.], [ 5., 3., 2., 8., 8., 2.]]) 

Порядок элементов в массиве в результате функции ravel() соответствует обычному «C-стилю», то есть, чем правее индекс, тем он «быстрее изменяется»: за элементом a[0,0] следует a[0,1]. Если одна форма массива была изменена на другую, массив переформировывается также в «C-стиле». В таком порядке NumPy обычно и создает массивы, так что для функции ravel() обычно не требуется копировать аргумент, но если массив был создан из срезов другого массива, копия может потребоваться. Функции ravel() и reshape() также могут работать (при использовании дополнительного аргумента) в FORTRAN-стиле, в котором быстрее изменяется более левый индекс.

Функция reshape() возвращает ее аргумент с измененной формой, в то время как метод resize() изменяет сам массив:

Copy Source | Copy HTML >>> a array([[ 7., 5.], [ 9., 3.], [ 7., 2.], [ 7., 8.], [ 6., 8.], [ 3., 2.]]) >>> a.resize((2,6)) >>> a array([[ 7., 5., 9., 3., 7., 2.], [ 7., 8., 6., 8., 3., 2.]]) 

Если при операции такой перестройки один из аргументов задается как -1, то он автоматически рассчитывается в соответствии с остальными заданными:

Copy Source | Copy HTML >>> a.reshape(3,-1) array([[ 7., 5., 9., 3.], [ 7., 2., 7., 8.], [ 6., 8., 3., 2.]]) 

Объединение массивов

Несколько массивов могут быть объединены вместе вдоль разных осей:

Copy Source | Copy HTML >>> a = floor(10*random.random((2,2))) >>> a array([[ 1., 1.], [ 5., 8.]]) >>> b = floor(10*random.random((2,2))) >>> b array([[ 3., 3.], [ 6., 0.]]) >>> vstack((a,b)) array([[ 1., 1.], [ 5., 8.], [ 3., 3.], [ 6., 0.]]) >>> hstack((a,b)) array([[ 1., 1., 3., 3.], [ 5., 8., 6., 0.]]) 

Функция column_stack() объединяет одномерные массивы в качестве столбцов двумерного массива:

Copy Source | Copy HTML >>> column_stack((a,b)) array([[ 1., 1., 3., 3.], [ 5., 8., 6., 0.]]) >>> a=array([4.,2.]) >>> b=array([2.,8.]) >>> a[:,newaxis] # Это дает нам 2D-ветор array([[ 4.], [ 2.]]) >>> column_stack((a[:,newaxis],b[:,newaxis])) array([[ 4., 2.], [ 2., 8.]]) >>> vstack((a[:,newaxis],b[:,newaxis])) # Поведение vstack другое array([[ 4.], [ 2.], [ 2.], [ 8.]])

Аналогично для строк имеется функция row_stack(). Для массивов с более, чем двумя осями, hstack() объединяет массивы по первым осям, vstack() — по последним, дополнительные аргументы позволяют задать число осей по которым должно произойти объединение.

В сложных случаях, могут быть полезны r_[] и с_[], позволяющие создавать одномерные массивы, с помощью последовательностей чисел вдоль одной оси. В них также имеется возможность использовать ":" для задания диапазона литералов:

Copy Source | Copy HTML >>> r_[1:4, 0,4] array([1, 2, 3, 0, 4]) 

Разделение одного массива на несколько более мелких

Используя hsplit() вы можете разбить массив вдоль горизонтальной оси, указав либо число возвращаемых массивов одинаковой формы, либо номера столбцов, после которых массив разрезается ножницами:

Copy Source | Copy HTML >>> a = floor(10*random.random((2,12))) >>> a array([[ 8., 8., 3., 9., 0., 4., 3., 0., 0., 6., 4., 4.], [ 0., 3., 2., 9., 6., 0., 4., 5., 7., 5., 1., 4.]]) >>> hsplit(a,3) # Разбить на 3 массива [array([[ 8., 8., 3., 9.], [ 0., 3., 2., 9.]]), array([[ 0., 4., 3., 0.], [ 6., 0., 4., 5.]]), array([[ 0., 6., 4., 4.], [ 7., 5., 1., 4.]])] >>> hsplit(a,(3,4)) # Разрезать a после третьего и четвертого столбца [array([[ 8., 8., 3.], [ 0., 3., 2.]]), array([[ 9.], [ 9.]]), array([[ 0., 4., 3., 0., 0., 6., 4., 4.], [ 6., 0., 4., 5., 7., 5., 1., 4.]])]

Функция vsplit() разбивает массив вдоль вертикальной оси, а array_split() позволяет указать оси, вдоль которых произойдет разбиение.

Копии и представления

При работе с массивами, их данные иногда необходимо копировать в другой массив, а иногда нет. Это часто является источником путаницы среди новичков. Возможно всего три случая:

Вообще никаких копий

Простое присваивание не создает ни копии массива, ни копии его данных:

Copy Source | Copy HTML >>> a = arange(12) >>> b = a # никакого нового объекта создано не было >>> b is a # a и b это два имени для одного объекта ndarray True >>> b.shape = 3,4 # изменит форму a >>> a.shape (3, 4) 

Python передает изменяемые объекты как ссылки, поэтому вызовы функций также не создают копий:

Copy Source | Copy HTML >>> def f(x): ... print id(x) ... >>> id(a) 148293216 >>> f(a) 148293216 

Представление или поверхностная копия

Разные объекты массивов могут использовать одни и те же данные. Метод view() создает новый объект массива, являющийся представлением тех же данных.

Copy Source | Copy HTML >>> c = a.view() >>> c is a False >>> c.base is a # c это представление данных, принадлежащих a True >>> c.flags.owndata False >>> >>> c.shape = 2,6 # форма а не поменяется >>> a.shape (3, 4) >>> c[ 0,4] = 1234 # данные а изменятся >>> a array([[ 0, 1, 2, 3], [1234, 5, 6, 7], [ 8, 9, 10, 11]])

Срез массива это представление:

Copy Source | Copy HTML >>> s = a[:,1:3] >>> s[:] = 10 # s[:] это представление s. Заметьте разницу между s=10 и s[:]=10 >>> a array([[ 0, 10, 10, 3], [1234, 10, 10, 7], [ 8, 10, 10, 11]]) 

Глубокая копия

Метод copy() создает настоящую копию массива и его данных:

Copy Source | Copy HTML >>> d = a.copy() # создается новый объект массива с новыми данными >>> d is a False >>> d.base is a # d не имеет ничего общего с а False >>> d[ 0, 0] = 9999 >>> a array([[ 0, 10, 10, 3], [1234, 10, 10, 7], [ 8, 10, 10, 11]]) 

В заключение

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

Tags:

Hubs:

Python

If this publication inspired you and you want to support the author, do not hesitate to click on the button