Основные типы данных. создание массивов функцией array()

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

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

>>> import numpy as np
>>> a = np.array()
>>> a
array()
>>> type(a)
<class 'numpy.ndarray'>

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

>>> b = np.array(, 4, 5, 6]])
>>> b
array(,
       ])

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

>>> b = np.array(, 4, 5, 6]], dtype=np.complex)
>>> b
array(,
       ])

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

Функция zeros() создает массив из нулей, а функция ones() — массив из единиц. Обе функции принимают кортеж с размерами, и аргумент dtype:

>>> np.zeros((3, 5))
array(,
       ,
       ])
>>> np.ones((2, 2, 2))
array(,
        ],

       ,
        ]])

Функция eye() создаёт единичную матрицу (двумерный массив)

>>> np.eye(5)
array(,
       ,
       ,
       ,
       ])

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

>>> np.empty((3, 3))
array(,
       ,
       ])
>>> np.empty((3, 3))
array(,
       ,
       ])

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

>>> np.arange(10, 30, 5)
array()
>>> np.arange(, 1, 0.1)
array()

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

>>> np.linspace(, 2, 9)  # 9 чисел от 0 до 2 включительно
array()

fromfunction(): применяет функцию ко всем комбинациям индексов

Операции с матрицами

Выше мы привели пример сложение, умножение матриц и транспонирование матрицы. Мы использовали вложенные списки, прежде чем создавать эти программы. Рассмотрим, как выполнить ту же задачу, используя массив NumPy.

Сложение двух матриц или сумма элементов массива Python

Мы используем оператор +, чтобы сложить соответствующие элементы двух матриц NumPy.

import numpy as np

A = np.array(, ])
B = np.array(, ])
C = A + B      # сложение соответствующих элементов
print(C)

''' 
Вывод:

 ]
 '''

Умножение двух матриц Python

Чтобы умножить две матрицы, мы используем метод dot(). Узнайте больше о том, как работает numpy.dot .

Примечание: * используется для умножения массива (умножения соответствующих элементов двух массивов), а не умножения матрицы.

import numpy as np

A = np.array(, ])
B = np.array(, , ])
C = a.dot(B)
print(C)

''' 
Вывод:

 ]
'''

Транспонирование матрицы питон

Мы используем numpy.transpose для вычисления транспонирования матрицы.

import numpy as np

A = np.array(, , ])
print(A.transpose())

''' 
Вывод:

 ]
'''

Как видите, NumPy значительно упростил нашу задачу.

Транспонирование и изменение формы матриц в numpy

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

Некоторые более сложные ситуации требуют возможности переключения между размерностями рассматриваемой матрицы. Это типично для приложений с машинным обучением, где некая модель может запросить определенную форму вывода, которая является отличной от формы начального набора данных. В таких ситуациях пригодится метод из NumPy. Здесь от вас требуется только передать новые размерности для матрицы. Для размерности вы можете передать , и NumPy выведет ее верное значение, опираясь на данные рассматриваемой матрицы:

Еще больше размерностей NumPy

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

В большинстве случаев для указания новой размерности требуется просто добавить запятую к параметрам функции NumPy:

Shell

array(,
,
],

,
,
],

,
,
],

,
,
]])

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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.)

Add array element

You can add a NumPy array element by using the append() method of the NumPy module.

The syntax of append is as follows:

numpy.append(array, value, axis)

The values will be appended at the end of the array and a new ndarray will be returned with new and old values as shown above.

The axis is an optional integer along which define how the array is going to be displayed. If the axis is not specified, the array structure will be flattened as you will see later.

Consider the following example where an array is declared first and then we used the append method to add more values to the array:

import numpy

a = numpy.array()

newArray = numpy.append (a, )

print(newArray)

The output will be like the following:

1.2. Заполнение данными

Создает массив NumPy.

Преобразует последовательность в массив NumPy.

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

Возвращает непрерывный массив в памяти с организацией порядка элементов в С-стиле.

Интерпретирует входные данные как матрицу.

Возвращает копию массива.

Преобразует буфер в одномерный массив.

Создает массив из текстового или двоичного файла.

Создает массив с выполнением указанной функции над каждым элементом.

Создает одномерный массив из итерируемого объекта.

Создает одномерный массив из строки.

Создает массив из данных в текстовом файле.

1.4.1.7. Fancy indexing¶

Tip

NumPy arrays can be indexed with slices, but also with boolean or
integer arrays (masks). This method is called fancy indexing.
It creates copies not views.

Using boolean masks

>>> np.random.seed(3)
>>> a = np.random.randint(, 21, 15)
>>> a
array()
>>> (a % 3 == )
array()
>>> mask = (a % 3 == )
>>> extract_from_a = amask # or,  a
>>> extract_from_a           # extract a sub-array with the mask
array()

Indexing with a mask can be very useful to assign a new value to a sub-array:

>>> aa % 3 ==  = -1
>>> a
array()

Indexing with an array of integers

>>> a = np.arange(, 100, 10)
>>> a
array()

Indexing can be done with an array of integers, where the same index is repeated
several time:

>>> a]  # note:  is a Python list
array()

New values can be assigned with this kind of indexing:

>>> a] = -100
>>> a
array()

Tip

When a new array is created by indexing with an array of integers, the
new array has the same shape as the array of integers:

>>> a = np.arange(10)
>>> idx = np.array(, 9, 7]])
>>> idx.shape
(2, 2)
>>> aidx
array(,
       ])

The image below illustrates various fancy indexing applications

Exercise: Fancy indexing

• Again, reproduce the fancy indexing shown in the diagram above.
• Use fancy indexing on the left and array creation on the right to assign
  values into an array, for instance by setting parts of the array in
  the diagram above to zero.

Добро пожаловать в 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)

Выход:

Python Numpy array Slicing

First, we declare a single or one-dimensional array and slice that array. Python slicing accepts an index position of start and endpoint of an array. The syntax of this is array_name.

Both the start and end position has default values as 0 and n-1(maximum array length). For example, arr1 means starts at index position 1 and ends at position 5. arr1 starts at 0 and ends at index position 7.

This time, we declared a two-dimensional array and slicing the same using index values.

From the above arrays, let me use the negative values as the start and end positions.

Reverse Numpy array in Python

Using the negative index value, you can reverse rows and column position of values, which is called Python Numpy array reverse.

Create an Array from existing Array

This example shows how to create an array from an existing array in Python. For this, we are using the Python Numpy array slicing concept.

7.5. Дискретное преобразование Фурье

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

Одномерное дискретное преобразование Фурье:

Двумерное дискретное преобразование Фурье:

Очень часто при спектральном анализе используются оконные функции (оконное преобразование Фурье), некоторые из которых так же представлены в NumPy

Numpy Median : np.median()

The numpy median function helps in finding the middle value of a sorted array.

Syntax

numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=False)

a : array-like – Input array or object that can be converted to an array, values of this array will be used for finding the median.

axis : int or sequence of int or None (optional) – Axis or axes along which the medians are computed. The default is to compute the median along a flattened version of the array.

out : ndarray (optional) – This is the alternate output array in which to place the result. The default is None; if provided, it must have the same shape as the expected output

overwrite_input : bool (optional) – If True, then allow use of memory of input array a for calculations. The default value is false.

keepdims – bool (optional) – If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the original arr.

Numpy median function returns a new array holding the result. If the input contains integers or floats smaller than float64, then the output data-type is np.float64. Otherwise, the data-type of the output is the same as that of the input.

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

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

>>> import numpy as np
>>> a = np.array()
>>> b = np.arange(4)
>>> a + b
array()
>>> a - b
array()
>>> a * b
array()
>>> a  b  # При делении на 0 возвращается inf (бесконечность)
array()
<string>:1: RuntimeWarning: divide by zero encountered in true_divide
>>> a ** b
array()
>>> a % b  # При взятии остатка от деления на 0 возвращается 0
<string>:1: RuntimeWarning: divide by zero encountered in remainder
array()

Для этого, естественно, массивы должны быть одинаковых размеров.

>>> c = np.array(, 4, 5, 6]])
>>> d = np.array(, 3, 4], 5, 6]])
>>> c + d
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

Также можно производить математические операции между массивом и числом. В этом случае к каждому элементу прибавляется (или что вы там делаете) это число.

>>> a + 1
array()
>>> a ** 3
array()
>>> a < 35  # И фильтрацию можно проводить
array(, dtype=bool)

NumPy также предоставляет множество математических операций для обработки массивов:

>>> np.cos(a)
array()
>>> np.arctan(a)
array()
>>> np.sinh(a)
array()

Полный список можно посмотреть здесь.

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

>>> a = np.array(, 4, 5, 6]])
>>> np.sum(a)
21
>>> a.sum()
21
>>> a.min()
1
>>> a.max()
6

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

1.4.1.6. Copies and views¶

A slicing operation creates a view on the original array, which is
just a way of accessing array data. Thus the original array is not
copied in memory. You can use to check if two arrays
share the same memory block. Note however, that this uses heuristics and may
give you false positives.

When modifying the view, the original array is modified as well:

>>> a = np.arange(10)
>>> a
array()
>>> b = a)
>>> np.may_share_memory(a, b)
True
>>> b = 12
>>> b
array()
>>> a   # (!)
array()

>>> a = np.arange(10)
>>> c = a)

>>> np.may_share_memory(a, c)
False

This behavior can be surprising at first sight… but it allows to save both
memory and time.

Создание массивов с помощью функции array

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

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

np.array( (1, 2, 3) )

Или можно
сформировать список с использованием инструмента listcomprehensions:

def getList():
    for i in range(10):
        yield i
 
a = np.array( x for x in getList() )
print(a)

Здесь в качестве
итератора используется функция-итератор getList(). Но если
передать строку:

np.array( "Hello" )

то получим массив
из одного элемента:

array(‘Hello’,
dtype='<U5′)

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

Объявление многомерных массивов

Теперь давайте
посмотрим, как можно создавать массивы больших размерностей. И начнем с
двумерных. Предположим, требуется определить матрицу, размерностью 3×2 элемента. Это
можно сделать так:

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

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

array(,

      
,

      ])

Но, если указать
не прямоугольный двумерный список, например, так:

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

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

Далее, если
требуется объявить трехмерную матрицу, то это будет выглядеть уже так:

b = np.array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

И при ее выводе
в консоли увидим следующее:

array(,

],

,

],

,

]])

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

Расположение осей многомерного массива

И здесь главный
вопрос: как располагаются оси многомерных массивов?Ответ вполне очевиден. Вдоль
первой оси (axis0) для
трехмерного массива будут располагаться двумерные срезы (матрицы), а остальные
две оси (axis1 и axis2) будут
определять строки и столбцы этих двумерных матриц:

Например, выполнив
в консоли команду

b

увидим первый
двумерный срез трехмерного массива:

array(,

])

Если указать
первые два индекса:

b, 

то увидим первую
строку первого среза:

array()

Наконец, указав
все три индекса:

b, , 

получим первый
элемент трехмерной матрицы:

1

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

(x1, x3, x3, …, xN)

где
местоположение каждого числа определяет ось, по которой берется тот или иной
индекс.

Итак, на этом
занятии мы с вами познакомились с базовыми типами данных
пакета NumPy и узнали как
создавать различные массивы с помощью функции array(). Если вам все
это понятно, значит цель этого занятия достигнута.

Видео по теме

#1. Пакет numpy — установка и первое знакомство | NumPy уроки

#2. Основные типы данных. Создание массивов функцией array() | NumPy уроки

#3. Функции автозаполнения, создания матриц и числовых диапазонов | NumPy уроки

#4. Свойства и представления массивов, создание их копий | NumPy уроки

#5. Изменение формы массивов, добавление и удаление осей | NumPy уроки

#6. Объединение и разделение массивов | NumPy уроки

#7. Индексация, срезы, итерирование массивов | NumPy уроки

#8. Базовые математические операции над массивами | NumPy уроки

#9. Булевы операции и функции, значения inf и nan | NumPy уроки

#10. Базовые математические функции | NumPy уроки

#11. Произведение матриц и векторов, элементы линейной алгебры | NumPy уроки

#12. Множества (unique) и операции над ними | NumPy уроки

#13. Транслирование массивов | NumPy уроки

max/ min:

Next, we have some more operations in numpy such as to find the minimum, maximum as well the sum of the numpy array. Let’s go ahead in python numpy tutorial and execute it practically.

import numpy as npa= np.array()print(a.min())print(a.max())print(a.sum())Output - 1 3 6

You must be finding these pretty basic, but with the help of this knowledge, you can perform a lot bigger tasks as well. Now, let’s understand the concept of axis in python numpy.

As you can see in the figure, we have a numpy array 2*3. Here the rows are called as axis 1 and the columns are called as axis 0. Now you must be wondering what is the use of these axis?

Suppose you want to calculate the sum of all the columns, then you can make use of axis. Let me show you practically, how you can implement axis in your PyCharm:

a= np.array()print(a.sum(axis=0))Output - 

Therefore, the sum of all the columns are added where 1+3=4, 2+4=6 and 3+5=8. Similarly, if you replace the axis by 1, then it will print where all the rows get added.

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

Существует много способов выбора подмножества данных или элементов
массива. Одномерные массивы — это просто, на первый взгляд они
аналогичны спискам 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: Срезы двумерного массива

7.4. Генерация случайных значений

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

Получение простых случайных данных:

Перестановки:

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

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

The NumPy Array object

To declare a numpy array object, we first import the library, following which we instantiate our newly created array using the library function.

The below snippet declares a simple 1-Dimensional numpy array:

>>> import numpy as np
>>> a = np.array()
>>> print(a)

Each array has the following attributes :

•  (the number of dimensions)
•  (the size of each dimension)
•  (the total size of the array)
• (the datatype of the array)

NumPy array elements have the same data type, unlike Python lists. We cannot make a single numpy array hold multiple different data types as a result.

To declare a higher dimensional array, it is similar to declaring a higher dimensional array in any other language, using the appropriate matrix that represents the entire array.

# Declare a 2-Dimensional numpy array
b = np.array(, ])
print("b -> ndim:", b.ndim)
print("b -> shape:", b.shape)
print("b -> size:", b.size)
print("b -> dtype:", b.dtype)

Output:

b -> ndim: 2
b -> shape: (2, 3)
b -> size: 6
b -> dtype: dtype('int64')

1.4.1.1. What are NumPy and NumPy arrays?¶

NumPy arrays

Python objects:	high-level number objects: integers, floating point containers: lists (costless insertion and append), dictionaries (fast lookup)
NumPy provides:	extension package to Python for multi-dimensional arrays closer to hardware (efficiency) designed for scientific computation (convenience) Also known as array oriented computing

>>> import numpy as np
>>> a = np.array()
>>> a
array()

Tip

For example, An array containing:

• values of an experiment/simulation at discrete time steps
• signal recorded by a measurement device, e.g. sound wave
• pixels of an image, grey-level or colour
• 3-D data measured at different X-Y-Z positions, e.g. MRI scan
• …

Why it is useful: Memory-efficient container that provides fast numerical
operations.

In : L = range(1000)

In : %timeit i**2 for i in L
1000 loops, best of 3: 403 us per loop

In : a = np.arange(1000)

In : %timeit a**2
100000 loops, best of 3: 12.7 us per loop

NumPy Reference documentation

• On the web: https://numpy.org/doc/

• Interactive help:

  In : np.array?
  String Form:<built-in function array>
  Docstring:
  array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0, ...
  

• Looking for something:

  >>> np.lookfor('create array') 
  Search results for 'create array'
  ---------------------------------
  numpy.array
      Create an array.
  numpy.memmap
      Create a memory-map to an array stored in a *binary* file on disk.
  

  In : np.con*?
  np.concatenate
  np.conj
  np.conjugate
  np.convolve
  

7.3. Статистика

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

Элементарные статистические функции:

Средние значения элементов массива и их отклонения:

Корреляционные коэфициенты и ковариационные матрицы величин:

Так же NumPy предоставляет функции для вычисления гистограмм наборов данных различной размерности и некоторые другие статистичские функции.