Как использовать функцию reshape() библиотеки numpy в python

Нормализовать массив Numpy

Как будто теперь мы покрыли массив Numpy. Теперь мы можем генерировать массивы в соответствии с вашими предпочтениями и потребностями. В этом разделе мы сосредоточимся на нормализации этих массивов. Как уже упоминалось ранее, нормализация-это процедура приведения значений, измеренных в другой шкале, к общей шкале. Чтобы нормализовать массив 1-й, нам нужно найти нормальное значение массива. После чего нам нужно разделить массив на его нормальное значение, чтобы получить нормализованный массив.

Чтобы вычислить нормальное значение массива, мы используем именно этот синтаксис.

numpy.linalg.norm()

Теперь, когда мы закончили со всем разделом теории. Давайте посмотрим на его применение на примере.

import numpy as ppool.array(,
               )
print(a).linalg.norm(a)
print(b)/b
print(norm)

Выход:

В приведенном выше примере мы использовали тот же массив, что и сгенерированный выше. Теперь сначала мы вычислили нормальное значение массива. После вычисления нормального значения мы разделили каждый член массива на нормальное значение. Следовательно, мы получаем нормализованный массив NumPy.

Indexing NumPy arrays

Indexing is very important for accessing and retrieving the elements of a NumPy array.

Recall what I wrote at the beginning of the blog post:

A NumPy array is like a container with many compartments. Each of the compartments inside of a NumPy array have an “address.” We call that address an “index.”

Notice again that the index of the first value is 0.

We can use the index to retrieve specific values in the NumPy array. Let’s take a look at how to do that.

First, let’s create a NumPy array using the function .

np.random.seed(72)
simple_array = np.random.randint(low = 0, high = 100, size=5)

You can print out the array with the following code:

print(simple_array)

And you can see that the array has 5 integers.

For the sake of clarity tough, here’s a visual representation of . Looking at this will help you understand array indexing:

In this visual representation, you can see the values stored in the array, . But, I’ve also shown you the index values associated with each of those elements.

These indexes enable us to retrieve values in specific locations.

Let’s take a look at how to do that.

Indexing a single element

The simplest form of indexing is retrieving a single value from the array.

To retrieve a single value from particular location in the NumPy array, you need to provide the “index” of that location.

Syntactically, you need to use bracket notation and provide the index inside of the brackets.

Let me show you an example. Above, we created the NumPy array .

To get the value at index 1 from , you can use the following syntax:

# Retrieve the value at index 1
simple_array

Which returns the value .

Visually though, we can represent this indexing action like this:

Essentially, we’re using a particular index (i.e., the “address” of a particular location in the array) to retrieve the value stored at that location.

So the code is basically saying, “give me the value that’s at index location 1.” The result is … is the value at that index.

Negative index values

NumPy also supports negative index values. Using a negative index allows you to retrieve or reference locations starting from the end of the array.

Here’s an example:

simple_array

This retrieves the value at the very end of the array.

We could also retrieve this value by using the index (both will work). But sometimes you won’t know exactly how long the array is. This is a convenient way to reference items at the end of a NumPy array.

Indexing multiple elements: AKA array slicing

I just showed you simple examples of array indexing, but array indexing can be quite complex.

It’s actually possible to retrieve multiple elements from a NumPy array.

To do this, we still use bracket notation, but we can use a colon to specify a range of values. Here’s an example:

simple_array

This code is saying, “retrieve the values stored from index 2, up to but excluding index 4.”

Visually, we can represent this as follows:

Indexing in 2-dimensional NumPy arrays

Now that you’ve learned how to use indexes in 1-dimensional NumPy arrays, lets review how to use indexes in 2-dimensional NumPy arrays.

Working with 2-d NumPy arrays is very similar to working with 1-d arrays. The major difference (with regard to indexes) is that 2-d arrays have 2 indexes, a row index and a column index.

To retrieve a value from a 2-d array, you need to provide the specific row and column indexes.

Here’s an example. We’ll create a 2-d NumPy array, and then we’ll retrieve a value.

np.random.seed(72)
square_array = np.random.randint(low = 0, high = 100, size = 25).reshape()

square_array

Here, we’re essentially retrieving the value at row index 2 and column index 1. The value at that position is .

This is fairly straightforward. The major challenge is that you need to remember that the row index is first and the column index is second.

Slicing 2-d NumPy arrays

Finally, let’s review how to retrieve slices from 2-d NumPy arrays. Slicing 2-d arrays is very similar to slicing 1-d arrays. The major difference is that you need to provide 2 ranges, one for the rows and one for the columns.

np.random.seed(72)
square_array = np.random.randint(low = 0, high = 100, size = 25).reshape()

square_array

Let’s break this down.

We’ve again created a 5×5 square NumPy array called .

Then, we took a slice of that array. The slice included the rows from index 1 up-to-and-excluding index 3. It also included the columns from index 1 up-to-and-excluding index 4.

This might seem a little confusing if you’re a true beginner. In that case, I recommend working with 1-d arrays first, until you get the hang of them. Then, start working with relatively small 2-d NumPy arrays until you build your intuition about indexing works with 2-d arrays.

Основы индексирования и срезы

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

In : arr = np.arange(10)

In : arr
Out: array()

In : arr
Out: 5

In : arr
Out: array()

In : arr = 12

In : arr
Out: array()

Как видно, если присвоить скалярное значение срезу, как например,
, значение присваивается всем элементам среза. Первым
важным отличием от списков Python заключается в том, что срезы массива
являются представлениями исходного массива. Это означает, что данные
не копируются и любые изменения в представлении будут отражены в
исходном массиве.

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

In : arr_slice = arr

In : arr_slice
Out: array()

Теперь, если мы изменим значения в массиве , то они
отразятся в исходном массиве :

In : arr_slice = 12345

In : arr
Out: 
array()

«Голый» срез присвоит все значения в массиве:

In : arr_slice = 64

In : arr
Out: array()

Поскольку NumPy был разработан для работы с очень большими массивами,
вы можете представить себе проблемы с производительностью и памятью,
если NumPy будет настаивать на постоянном копировании данных.

Замечание

Если вы захотите скопировать срез в массив вместо отображения, нужно
явно скопировать массив, например, .

С массивами более высокой размерности существует больше вариантов. В
двумерных массивах каждый элемент это уже не скаляр, а одномерный
массив.

In : arr2d = np.array(, , ])

In : arr2d
Out: array()

Таким образом, к отдельному элементу можно получить доступ
рекурсивно, либо передать разделенный запятыми список
индексов. Например, следующие два примера эквивалентны:

In : arr2d
Out: array()

In : arr2d[]
Out: 3

Если в многомерном массиве опустить последние индексы, то возвращаемый
объект будет массивом меньшей размерности. Например, создадим массив
размерности \( 2 \times 2 \times 3 \):

In : arr3d = np.array(, ], , ]])

In : arr3d
Out: 
array(,
        ],

       ,
        ]])

При этом — массив размерности \( 2 \times 3 \):

In : arr3d[]
Out: 
array(,
       ])

Можно присваивать как скаляр, так и массивы:

In : old_values = arr3d[].copy()

In : arr3d[] = 42

In : arr3d
Out: 
array(,
        ],

       ,
        ]])

In : arr3d[] = old_values

In : arr3d
Out: 
array(,
        ],

       ,
        ]])

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

In : arr3d
Out: array()

Это выражение такое же, как если бы мы проиндексировали в два этапа:

In : x = arr3d

In : x
Out: 
array(,
       ])

In : x[]
Out: array()

Индексирование с помощью срезов

Как одномерные объекты, такие как списки, можно получать срезы
массивов посредством знакомого синтаксиса:

In : arr
Out: array()

In : arr
Out: array()

Рассмотрим введенный выше двумерный массив . Получение срезов
этого массива немного отличается от одномерного:

In : arr2d
Out: 
array(,
       ,
       ])

In : arr2d
Out: 
array(,
       ])

Как видно, мы получили срез вдоль оси 0, первой оси. Срез, таким
образом, выбирает диапазон элементов вдоль оси. Выражение
можно прочитать как «выбираем первые две строки массива ».

Можно передавать несколько срезов:

In : arr2d
Out: 
array(,
       ])

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

In : arr2d
Out: array()

In : arr2d
Out: array()

Смотрите рис. .

Рисунок 1: Срезы двумерного массива

Синтаксис

Эта функция принимает массив типа numpy (например, массив целых и логических значений NumPy).

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

Например, условие может принимать значение массива (]), который является логическим массивом типа numpy. (По умолчанию NumPy поддерживает только числовые значения, но мы также можем преобразовать их в bool).

Например, если условием является массив (]), а наш массив – a = ndarray (]), при применении условия к массиву (a ), мы получим массив ndarray (`1 2`).

import numpy as np

a = np.arange(10)
print(a) # Will only capture elements <= 2 and ignore others

Вывод:

array()

ПРИМЕЧАНИЕ. То же условие условия также может быть представлено как <= 2. Это рекомендуемый формат для массива условий, так как записывать его как логический массив очень утомительно.

Но что, если мы хотим сохранить размерность результата и не потерять элементы из нашего исходного массива? Для этого мы можем использовать numpy.where().

numpy.where(condition )

У нас есть еще два параметра x и y. Что это? По сути, это означает, что если условие выполняется для некоторого элемента в нашем массиве, новый массив будет выбирать элементы из x.

В противном случае, если это false, будут взяты элементы из y.

При этом наш окончательный выходной массив будет массивом с элементами из x, если условие = True, и элементами из y, если условие = False.

Обратите внимание, что хотя x и y необязательны, если вы указываете x, вы также ДОЛЖНЫ указать y. Это потому, что в этом случае форма выходного массива должна быть такой же, как и входной массив

ПРИМЕЧАНИЕ. Та же логика применима как для одномерных, так и для многомерных массивов. В обоих случаях мы выполняем фильтрацию по условию. Также помните, что формы x, y и условия передаются вместе.

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

Using fliplr() function

• In this example, we can easily use the fliplr() function to reverse an original array.
• The np.fliplr() method flips the array in left-right direction. The numpy. flipr() function always accepts a given array as a parameter and returns the same array and flip in the left-right direction.
• It reverses the order of elements on the given axis as 1 (left/right).

Syntax:

Here is the Syntax of fliplr() function

• It consists of few parameters
  • arr: input array
  • Returns: It returns an output numpy array with the columns reversed. Since the function is returned the operation.

Example:

Let’s take an example to check how to implement a reverse NumPy array by using the fliplr() function.

Here is the Screenshot of the following given code

Python reverse numpy array fliplr method

Добро пожаловать в NumPy!

NumPy (NumericalPython) — это библиотека Python с открытым исходным кодом, которая используется практически во всех областях науки и техники. Это универсальный стандарт для работы с числовыми данными в Python, и он лежит в основе научных экосистем Python и PyData. В число пользователей NumPy входят все — от начинающих программистов до опытных исследователей, занимающихся самыми современными научными и промышленными исследованиями и разработками. API-интерфейс NumPy широко используется в пакетах Pandas, SciPy, Matplotlib, scikit-learn, scikit-image и в большинстве других научных и научных пакетов Python.

Библиотека NumPy содержит многомерный массив и матричные структуры данных (дополнительную информацию об этом вы найдете в следующих разделах). Он предоставляет ndarray, однородный объект n-мерного массива, с методами для эффективной работы с ним. NumPy может использоваться для выполнения самых разнообразных математических операций над массивами. Он добавляет мощные структуры данных в Python, которые гарантируют эффективные вычисления с массивами и матрицами, и предоставляет огромную библиотеку математических функций высокого уровня, которые работают с этими массивами и матрицами.

Узнайте больше о NumPy здесь!

GIF черезgiphy

Установка NumPy

Чтобы установить NumPy, я настоятельно рекомендую использовать научный дистрибутив Python. Если вам нужны полные инструкции по установке NumPy в вашей операционной системе, вы можетенайти все детали здесь,

Если у вас уже есть Python, вы можете установить NumPy с помощью

conda install numpy

или

pip install numpy

Если у вас еще нет Python, вы можете рассмотреть возможность использованияанаконда, Это самый простой способ начать. Преимущество этого дистрибутива в том, что вам не нужно слишком беспокоиться об отдельной установке NumPy или каких-либо основных пакетов, которые вы будете использовать для анализа данных, таких как pandas, Scikit-Learn и т. Д.

Если вам нужна более подробная информация об установке, вы можете найти всю информацию об установке наscipy.org,

фотоАдриеннотPexels

Если у вас возникли проблемы с установкой Anaconda, вы можете ознакомиться с этой статьей:

Как импортировать NumPy

Каждый раз, когда вы хотите использовать пакет или библиотеку в своем коде, вам сначала нужно сделать его доступным.

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

import numpy as np

(Мы сокращаем «numpy» до «np», чтобы сэкономить время и сохранить стандартизированный код, чтобы любой, кто работает с вашим кодом, мог легко его понять и запустить.)

В чем разница между списком Python и массивом NumPy?

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

Зачем использовать NumPy?

фотоPixabayотPexels

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

Что такое массив?

Массив является центральной структурой данных библиотеки NumPy. Это таблица значений, которая содержит информацию о необработанных данных, о том, как найти элемент и как интерпретировать элемент. Он имеет сетку элементов, которые можно проиндексировать в Все элементы имеют одинаковый тип, называемыймассив dtype(тип данных).

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

Одним из способов инициализации массивов NumPy является использование вложенных списков Python.

a = np.array(, , ])

Мы можем получить доступ к элементам в массиве, используя квадратные скобки. Когда вы получаете доступ к элементам, помните, чтоиндексирование в NumPy начинается с 0, Это означает, что если вы хотите получить доступ к первому элементу в вашем массиве, вы получите доступ к элементу «0».

print(a)

Выход:

Проверьте, пуст ли массив NumPy

Мы можем использовать метод size, который возвращает общее количество элементов в массиве.

В следующем примере у нас есть оператор if, который проверяет наличие элементов в массиве с помощью ndarray.size, где ndarray-это любой заданный массив NumPy:

импорт numpy

a.массив()

если(a.размер):

print("The given Array is empty")

ещё:

print("The array = ", a)

Результат выглядит следующим образом:

В приведенном выше коде есть три элемента, поэтому он не пуст, и условие вернет false.

Если элементов нет, условие if станет истинным, и оно напечатает пустое сообщение.

Если наш массив равен:

a.массив([])

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

Фундаментальный элемент NumPy – массив (array)

Отлично,
сложнейший этап установки и импорта пакета позади. Пришло время сделать первые
шаги и вначале познакомиться с его фундаментальным элементом – однородным
многомерным массивом. В NumPy элементы массива имеют единый тип
данных. Их индексы описываются кортежем целых неотрицательных чисел.
Размерность кортежа – это ранг массива (то есть, размерность массива), а каждое
число в кортеже представляет свою отдельную ось:

Как создать
массив в NumPy? Существует много
способов, но базовый реализуется через функцию:

numpy.array(object,
dtype=None, …)

Здесь в качестве
первого параметра object может выступать список или кортеж, а также функция или объект, возвращающий список или
кортеж. Второй параметр dtype – это тип элементов массива. Если
указано значение None, то тип будет определяться автоматически на основе
переданных данных. Подробнее об этой функции можно, как всегда, почитать на
странице официальной документации:

Итак, в самом
простом варианте можно создать одномерный массив так:

a = np.array(1, 2, 3, 4)

В результате
получим объект типа array с элементами 1, 2, 3, 4:

array()

Какой будет тип
у этих элементов? Мы можем его посмотреть с помощью атрибута dtype, выполнив в
консоли строчку:

a.dtype

Увидим:

dtype(‘int32’)

То есть,
автоматически был применен целочисленный тип размерностью 32 бит. Ну, хорошо, а
что если попробовать создать массив с разными типами его элементов, например,
так:

a = np.array(1, 2, "3", True)

В результате
увидим, следующее содержимое:

array(, dtype='<U11′)

Все элементы
стали строкового типа. Этот пример показывает, что в массивах NumPy используется
единый тип данных его элементов: или все целочисленные, или строковые, или
вещественные и так далее. Смешение типов в рамках одного массива не
допускается.

Отлично, это мы
сделали. Как теперь можно обращаться к отдельным элементам массива? Для этого
используется общий синтаксис:

<имя массива>

Например, для
нашего одномерного случая, мы можем взять первый элемент из массива a, следующим
образом:

a

Увидим значение ‘1’.
Обратите внимание, первый элемент имеет индекс 0, а не 1. Единица – это уже
второй элемент:

a1 # возвращает 2-й элемент со значением ‘2’

Для изменения
значения элемента, достаточно присвоить ему новое значение, например:

a1 = '123'

в результате
получим массив:

array(, dtype='<U11′)

А что будет,
если мы попробуем присвоить значение другого типа данных, например, число:

a1 = 234

Ошибки не будет,
а значение автоматически будет преобразовано в строку:

array(, dtype='<U11′)

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

1.4.1.5. Indexing and slicing¶

The items of an array can be accessed and assigned to the same way as
other Python sequences (e.g. lists):

>>> a = np.arange(10)
>>> a
array()
>>> a], a2], a-1
(0, 2, 9)

Warning

Indices begin at 0, like other Python sequences (and C/C++).
In contrast, in Fortran or Matlab, indices begin at 1.

The usual python idiom for reversing a sequence is supported:

>>> a)

For multidimensional arrays, indices are tuples of integers:

>>> a = np.diag(np.arange(3))
>>> a
array(,
       ,
       ])
>>> a1, 1
1
>>> a2, 1 = 10 # third line, second column
>>> a
array(,
       ,
       ])
>>> a1
array()

Note

• In 2D, the first dimension corresponds to rows, the second
  to columns.
• for multidimensional , is interpreted by
  taking all elements in the unspecified dimensions.

Slicing: Arrays, like other Python sequences can also be sliced:

>>> a = np.arange(10)
>>> a
array()
>>> a293 # 
array()

Note that the last index is not included! :

>>> a)

All three slice components are not required: by default, start is 0,
end is the last and step is 1:

>>> a13
array()
>>> a)
>>> a3:]
array()

A small illustrated summary of NumPy indexing and slicing…

You can also combine assignment and slicing:

>>> a = np.arange(10)
>>> a5:] = 10
>>> a
array()
>>> b = np.arange(5)
>>> a5:] = b)

Exercise: Indexing and slicing

• Try the different flavours of slicing, using , and
  : starting from a linspace, try to obtain odd numbers
  counting backwards, and even numbers counting forwards.

• Reproduce the slices in the diagram above. You may
  use the following expression to create the array:

  >>> np.arange(6) + np.arange(, 51, 10),
         ,
         ,
         ,
         ,
         ])
  

Exercise: Array creation

Create the following arrays (with correct data types):

,
 1, 1, 1, 1],
 1, 1, 1, 2],
 1, 6, 1, 1]]

,
 2., , , , ],
 , 3., , , ],
 , , 4., , ],
 , , , 5., ],
 , , , , 6.]]

Par on course: 3 statements for each

Hint: Individual array elements can be accessed similarly to a list,
e.g. or .

Hint: Examine the docstring for .

Using reverse() function

• In this method, we can easily use the function reverse() to reverse an original array.
• The reversed() method always returns the reversed iterator of the given sequence.
• It reverses an array at its original position, hence it doesn’t require any extra space for containing the results.
• It is an inbuilt function in the Python programming language that reverses elements of the list in place.

Example:

Let’s take an example to check how to implement a reverse NumPy array by using the reverse() function.

In the above code, we will import a numpy array library and then create an original array and pass array as a parameter

Here is the Screenshot of the following given code

Python reverse numpy array reverse method

Python numpy invert array

• In this section, we will discuss Python numpy invert array. Here we can easily use the function numpy.invert().
• This method is used to compute the bitwise inversion of a given array element-wise.
• It Originates the bitwise NOT of the binary number representation of the integers in the input arrays.

Syntax:

Here is the Syntax of numpy.invert()

• It consists of few parameters
  • X: input array (Only integer value and boolean expression are handled).
  • Out: It is an optional parameter. A position into which the result is stored. If provided, it should have a shape function that the inputs broadcast.
  • Where: This condition is provided over the input. At a position where the condition is boolean, the out numpy array will be set to the ufunc result.

Example:

Let’s take an example to check how to implement a numpy invert array

Here is the Screenshot of the following given code

Python numpy invert array

Ось Numpy для конкатенации двух массивов

Параметр axis, который мы используем с функцией numpy concatenate (), определяет ось, вдоль которой мы складываем массивы. Мы получаем различные типы сцепленных массивов в зависимости от того, установлено ли значение параметра оси равным 0 или 1. Кроме того, чтобы иметь более четкое представление о том, что говорится, обратитесь к приведенным ниже примерам.

Конкатенация Np массивов с осью 0

import numpy as np

#arrays defined.array(,]).array(,])

print(np_array_1)
print(np_array_2)
.concatenate(,)

print(a)

Выход:

array(,
       ])

array(,
       ])

array(,
       ,
       ,
       ])

Объяснение:

Как уже упоминалось, параметр axis в функции ‘concatenate()’ подразумевает укладку массивов. Поэтому, когда мы устанавливаем ось в 0, функция concatenate складывает два массива вдоль строк. Мы указываем, что хотим конкатенации массивов. Конкатенация выполняется вдоль оси 0, то есть вдоль направления строк. Таким образом, мы получаем результат в виде сложенного массива. И два составных массива вдоль рядов.

Конкатенация массивов Numpy с осью 1

import numpy as np

#arrays defined.array(,]).array(,])

print(np_array_1)
print(np_array_2)
.concatenate(,)

print(a)

Выход:

array(,
       ])

array(,
       ])

array(,
       ])

Объяснение:

В приведенном выше примере параметр axis имеет значение 1. Например, мы знаем, что ось 1 определяет направление вместе со столбцами. Прежде всего это подразумевает функцию numpy concatenate() для объединения двух входных данных href=”https://en.wikipedia.org/wiki/Array_data_structure”>массивы. После этого конкатенация выполняется горизонтально вместе со столбцами. href=”https://en.wikipedia.org/wiki/Array_data_structure”>массивы. После этого конкатенация выполняется горизонтально вместе со столбцами.

What is a NumPy array?

A NumPy array is a collection of elements that have the same data type.

You can think of it like a container that has several compartments that hold data, as long as the data is of the same data type.

Visually, we can represent a simple NumPy array sort of like this:

Let’s break this down.

We have a set of integers: 88, 19, 46, 74, 94. These values are all integers; they are all of the same type. You can see that these values are stored in “compartments” of a larger structure. The overall structure is the NumPy array.

Very quickly, I’ll explain a little more about some of the properties of a NumPy array.

NumPy arrays must contain data all of the same type

As I mentioned above, NumPy arrays must contain data all of the same type.

That means that if your NumPy array contains integers, all of the values must be integers. If it contains floating point numbers, all of the values must be floats.

I won’t write extensively about data types and NumPy data types here. There is a section below in this blog post about how to create a NumPy array of a particular type. Having said that, if you want to learn a lot more about the various data types that are available in NumPy, then (as the saying goes) read the f*cking manual.

NumPy arrays have an index

Each of the compartments inside of a NumPy array have an “address.” We call that address an “index.”

If you’re familiar with computing in general, and Python specifically, you’re probably familiar with indexes. Many data structures in Python have indexes, and the indexes of a NumPy array essentially work the same.

If you’re not familiar with indexes though, let me explain. Again, an index is sort of like an address. These indexes enable you to reference a specific value. We call this indexing.

Index values start at zero

Just like other Python structures that have indexes, the indexes of a NumPy array begin at zero:

So if you want to reference the value in the very first location, you need to reference location “0”. In the example shown here, the value at index 0 is .

I’ll explain how exactly to use these indexes syntactically, but to do that, I want to give you working examples. To give you working examples, I’ll need to explain how to actually create NumPy arrays in Python.

1.4.1.4. Basic visualization¶

Now that we have our first data arrays, we are going to visualize them.

Start by launching IPython:

$ ipython # or ipython3 depending on your install

Or the notebook:

$ jupyter notebook

Once IPython has started, enable interactive plots:

>>> %matplotlib  

Or, from the notebook, enable plots in the notebook:

>>> %matplotlib inline 

The is important for the notebook, so that plots are displayed in
the notebook and not in a new window.

Matplotlib is a 2D plotting package. We can import its functions as below:

>>> import matplotlib.pyplot as plt  # the tidy way

And then use (note that you have to use explicitly if you have not enabled interactive plots with ):

>>> plt.plot(x, y)       # line plot    
>>> plt.show()           # <-- shows the plot (not needed with interactive plots) 

Or, if you have enabled interactive plots with :

>>> plt.plot(x, y)       # line plot    

1D plotting:

>>> x = np.linspace(, 3, 20)
>>> y = np.linspace(, 9, 20)
>>> plt.plot(x, y)       # line plot    

>>> plt.plot(x, y, 'o')  # dot plot    

2D arrays (such as images):

>>> image = np.random.rand(30, 30)
>>> plt.imshow(image, cmap=plt.cm.hot)    
<matplotlib.image.AxesImage object at ...>
>>> plt.colorbar()    
<matplotlib.colorbar.Colorbar object at ...>

See also

More in the: