Содержание

В чем разница между ndarray и array в numpy?



В чем разница между ndarray и array в Numpy? И где я могу найти реализации в исходном коде numpy?

python arrays numpy multidimensional-array numpy-ndarray
Поделиться Источник flxb     08 апреля 2013 в 12:41

5 ответов


  • В чем разница между dtype= и .astype() в numpy?

    Контекст: я хотел бы использовать numpy ndarrays с float32 вместо float64 . Edit: дополнительный контекст-Я обеспокоен тем, как numpy выполняет эти вызовы, потому что они будут повторяться неоднократно как часть процедуры обратного распространения в нейронной сети. Я хотел бы, чтобы сеть выполнила…

  • в чем разница между серией/dataframe и ndarray?

    Leaving that they are from two different binaries. Я знаю, что series/dataframe может содержать любой тип данных, и ndarray также является гетерогенными данными.

    А также все операции нарезки numpy применимы к сериям. Есть ли между ними еще какая-то разница?



229

numpy.array -это просто удобная функция для создания ndarray ; это не сам класс.

Вы также можете создать массив с помощью numpy.ndarray,но это не рекомендуется. С строкой документации от numpy.ndarray :

Массивы должны быть построены с использованием array, zeros или empty … приведенные здесь параметры относятся к низкоуровневому методу ( ndarray(...) ) для создания экземпляра массива.

Большая часть мяса реализации находится в коде C, здесь в multiarray , но вы можете начать смотреть на интерфейсы ndarray здесь:

https://github.com/numpy/numpy/blob/master/numpy/core/numeric.py

Поделиться wim     08 апреля 2013 в 12:51



50

numpy. array -это функция, которая возвращает numpy.ndarray . Нет объекта типа numpy.array.

Поделиться Ramón J Romero y Vigil     08 апреля 2013 в 12:46



33

Всего несколько строк примера кода, чтобы показать разницу между numpy.array и numpy.ndarray

Шаг разминки: составьте список

a = [1,2,3]

Проверьте тип

print(type(a))

Вы получите

<class 'list'>

Постройте массив (из списка) с помощью np.array

a = np.array(a)

Или, вы можете пропустить шаг разминки, непосредственно иметь

a = np.array([1,2,3])

Проверьте тип

print(type(a))

Вы получите

<class 'numpy. ndarray'>

что говорит вам о том, что тип массива numpy — это numpy.ndarray

Вы также можете проверить тип по

isinstance(a, (np.ndarray))

и вы получите

True

Любая из следующих двух строк выдаст вам сообщение об ошибке

np.ndarray(a)                # should be np.array(a)
isinstance(a, (np.array))    # should be isinstance(a, (np.ndarray))

Поделиться Ying     21 декабря 2017 в 03:25


  • В чем разница между Array (0) и array = []

    В чем разница между созданием массива с помощью Array (0) и array = []? Насколько мне известно, оба они являются пустыми объектами массива. array >>> [] Array(0) >>> [] Но когда я сравниваю их, они возвращают ‘false’. var array = [] array === Array(0) >>> false Что здесь…

  • В чем разница между «import numpy as np» и «from numpy import array»?

    Обычно, когда я создаю массивы в Numpy, я просто делаю это import numpy as np Какая разница, если я это сделаю?- from numpy import array



5

numpy. ndarray() -это класс, а numpy.array() -это метод / функция для создания ndarray .

В numpy docs если вы хотите создать массив из класса ndarray , вы можете сделать это двумя способами, как указано в кавычках:

1-Использование методов array(), zeros() или empty() : Массивы должны быть построены с использованием массива, нулей или пустых (см. Также раздел ниже). Приведенные здесь параметры относятся к низкоуровневому методу ( ndarray(…) ) для создания экземпляра массива.

2-непосредственно из класса ndarray : Существует два способа создания массива с использованием __new__ : Если буфер отсутствует, то используются только shape, dtype и order. Если buffer-это объект, предоставляющий интерфейс buffer, то интерпретируются все ключевые слова.

Приведенный ниже пример дает случайный массив, потому что мы не назначили значение буфера:

np. ndarray(shape=(2,2), dtype=float, order='F', buffer=None)

array([[ -1.13698227e+002,   4.25087011e-303],
       [  2.88528414e-306,   3.27025015e-309]])         #random

Другим примером является назначение объекта array для примера buffer:

>>> np.ndarray((2,), buffer=np.array([1,2,3]),
...            offset=np.int_().itemsize,
...            dtype=int) # offset = 1*itemsize, i.e. skip first element
array([2, 3])

из приведенного выше примера мы замечаем, что не можем назначить список «buffer», и нам пришлось использовать numpy.array() для возврата объекта ndarray для буфера

Вывод: используйте numpy.array() , если вы хотите сделать объект numpy.ndarray() «

Поделиться Mahmoud Elshahat     23 сентября 2018 в 16:02



0

Я думаю, что с np. array() вы можете создать только C, как если бы вы упомянули порядок, когда вы проверяете с помощью np.isfortran() , он говорит ложь. но с np.ndarrray() , когда вы указываете заказ, он создает его на основе предоставленного заказа.

Поделиться Sujith Rao     30 августа 2018 в 20:09


Похожие вопросы:


В чем разница между IEnumerable и Array, IList и List?

В чем разница между IEnumerable и Array ? В чем разница между IList и List ? Они, похоже, выполняют одну и ту же функцию.


Как построить ndarray из массива numpy? python

Я не могу преобразовать его в ndarray в numpy, я прочитал http:/ / docs.scipy.org/doc/numpy / reference/generated/numpy.ndarray.html, но он не показал мне, как я могу преобразовать свои входные…


В чем разница между функциями Numpy array() и asarray()?

В чем разница между функциями Numpy array() и asarray() ? Когда вы должны использовать один, а не другой? Они, кажется, генерируют идентичный выход для всех входов, которые я могу придумать.


В чем разница между dtype= и .astype() в numpy?

Контекст: я хотел бы использовать numpy ndarrays с float32 вместо float64 . Edit: дополнительный контекст-Я обеспокоен тем, как numpy выполняет эти вызовы, потому что они будут повторяться…


в чем разница между серией/dataframe и ndarray?

Leaving that they are from two different binaries. Я знаю, что series/dataframe может содержать любой тип данных, и ndarray также является гетерогенными данными. А также все операции нарезки numpy…


В чем разница между Array (0) и array = []

В чем разница между созданием массива с помощью Array (0) и array = []? Насколько мне известно, оба они являются пустыми объектами массива. array >>> [] Array(0) >>> [] Но когда я…


В чем разница между «import numpy as np» и «from numpy import array»?

Обычно, когда я создаю массивы в Numpy, я просто делаю это import numpy as np Какая разница, если я это сделаю?- from numpy import array


Numpy форма ndarray с 3 параметрами

Я смущен тем, что такое форма ndarray, когда предусмотрены 3 параметра: Например, в чем разница между: np. zeros((2, 1, 3)) array([[[ 0., 0., 0.]], [[ 0., 0., 0.]]]) и: np.zeros((1, 2, 3)) array([[[…


Разница между numpy подпрограммами и методами ndarray?

При использовании numpy часто можно выбрать между вызовом функции из numpy API и вызовом функции из ndarray , например: >>> import numpy as np >>> array_ = np.array([True, False,…


В чем разница между array ([array ([]), array ([])]) и array([[],[]])?

В чем разница между этими двумя массивами numpy? array([array([1,2,3]),array([4,5,6])]) и array([[1,2,3],[4,5,6]]) Как мы можем обратить одно в другое?

Автостопом по Python NumPy Arrays

Дата публикации Aug 3, 2018

Если вы используете python для науки о данных, либо вы использовали NumPy, либо, должно быть, слышали об этом. Большая часть статистического анализа, который требует хранения данных в памяти, использует Numpy.

Могут быть заданы вопросы, почему NumPy? Разве списки Python или другие структуры данных не могут делать то же самое?

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

NumPy обеспечивает эффективное хранение и лучшие способы обработки данных для математических операций

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

numpy_arr = np.array([1,2,"Hello",3,"World"], dtype=np.int32)  # Error

Однако для списков Python это правильный код

py_arr = [1,2,"Hello",3,"World"]  # Valid Code

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

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

1. NumPy использует гораздо меньше памяти для хранения данных

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

Например, мы можем создать простой массив из шести элементов, используя список Python, а также используяnumpy.array(...)Разница в количестве занятой памяти весьма поразительна. Смотрите пример ниже

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

В приведенном выше примере NumPy по умолчанию считает эти числа8 Bytesцелые числа, однако, мы можем предоставить типы данных с массивами NumPy, если мы знаем максимальный диапазон данных. Например, мы можем использовать1 Byteцелое число для хранения чисел до255а также2 Bytesцелое число для чисел до65535

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

Аналогично, массивы NumPy обеспечивают значительную экономию при хранении значений с плавающей запятой.

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


2. Использование NumPy для создания массивов n-измерения

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

Вот список того, что мы можем сделать с n-мерными массивами NumPy, что иначе сложно сделать.


Размеры массива могут быть изменены во время выполнения, если коэффициент кратности дает одинаковое количество элементов. Например, матрицу 2 * 5 можно преобразовать в 5 * 2, а 1 * 4 — в 2 * 2. Это можно сделать, вызвав NumPy..reshape(...)функция на массивах


NumPy также может генерировать предопределенный набор чисел для массива. Предопределенный набор чисел с шагами (включая десятичные шаги может быть создан с использованиемnumpy.arange(...)функция. Результатом этой функции всегда будет набор чисел с одним измерением. Тем не менее, мы можем использовать reshape для этого вывода, чтобы создать измерение по нашему выбору.


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

По умолчанию NumPy использует плавающую точкуfloat64тип данных для создания единиц и нулей, однако тип данных может быть изменен на целое число с помощьюdtypeвариант как показано ниже


Как.reshape(x,y)может преобразовать массив в многомерный массив, аналогично, возможно создать одномерный массив из любого любого многомерного массива, используя функцию.ravel()


3. Математические операции на NumPy n-мерных массивах

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

NumPy n-мерные массивы позволяют чрезвычайно легко выполнять математические операции над ним.

Это основной USP NumPy, из-за которого он широко используется в сообществе аналитиков данных. Списки Python далеко не то, что он может сделать. Например, рассмотрим умножение списка питонов на 2. Вот что мы получим

py_arr = [1,2,3] * 2
# Generates [1,2,3,1,2,3]

Принимая во внимание, что пустой массив производит вывод, который каждый элемент массива умножается на 2

np_arr = np.array([1,2,3]) * 2
# Generates [2,4,6]

Точно так же мы можем также выполнять другие математические операции над массивами-пустышками, такие как сложение, вычитание и деление

np_arr = np.array([1,2,3]) + 2
# Generates [3,4,5]

Многомерные матричные операции так же просты, как мы используем два числа

np_arr1 = np.array([[1,2,3],[4,5,6]])
np_arr2 = np.array([[1,2,3],[4,5,6]])np_arr3 = np_arr1 * np_arr2
#Generates
# [[ 1 4 9]
# [16 25 36]]np_arr3 = np_arr1 + np_arr2
#Generates
# [[ 2 4 6]
# [ 8 10 12]]

Встроенные математические функции NumPy также позволяют нам выполнять сложные математические операции, такие как sqrt, mean и median.

np.sqrt(np_arr1)
#generates
# [1. 1.41421356 1.73205081]
# [2. 2.23606798 2.44948974]]np.mean(np_arr1) #generates 3.5
np.median(np_arr1) #generates 3.5

Есть дополнительные встроенные функции-члены для получения более подробной информации о массивах, в том числе sum, min и max.

np_arr1.sum()  # 21
np_arr1.min() # 1
np_arr1.max() # 6

4. Поиск элементов в массиве NumPy

При работе с наборами данных будут моменты, когда нам нужно будет найти конкретные данные из доступного набора данных. Хотя NumPy предоставляет несколько функций для одного и того же, три из них будут использоваться чаще, чем другие. Они естьwhere, nonzeroа такжеcount_nonzero

Whereа такжеnonzeroфункции возвращает индекс, связанный с оператором True. например

np_arr = np.array([1,2,0,4,5])
find = np.where(np_arr > 2)
#returns [3,4]

а также

np_arr = np. array([1,2,0,4,5])
find = np.nonzero(np_arr)
# return [0,1,3,4]

И, наконец, можно подсчитать количество ненулевых элементов в массиве с помощьюcount_nonzero(...)функция

n_arr = np.array([1,2,3,0,3,0,2,0,0,2])
np.count_nonzero(n_arr)
# returns 6

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

Последний метод, который имеет свое применение в машинном обучении, — это найти форму массива NumPy. Это делается с помощью.shape, Например

n_arr = np.array([1,2,3,0,3,0,2,0,0,2])
n_arr.shape
# Generates => (10,)
n_arr = np.array([[1,2],[3,0]])
# Generates => (2,2)

5. Заключительные мысли

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

Это все для этого конкретного поста. Придумаем еще один набор интересных функций NumPy в другом посте

Спасибо за чтение …!!!

Дакш

Оригинальная статья

4 приема Python NumPy, которые должен знать каждый новичок

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

Помогая коллегам и друзьям с трудностями в NumPy, мы пришли к 4 приемам, которые должен знать каждый новичок Python. Эти фишки помогут вам написать более аккуратные и читаемые коды

1. Arg-функции — позиции

Для массива функции arr, np.argmax(arr), np.argmin(arr) и np.argwhere(condition(arr)) возвращают показатели максимальных значений, минимальных значений и значений, которые удовлетворяют определенным условиям пользователя соответственно. Хотя эти функции arg широко используются, мы часто игнорируем функцию np.argsort(), возвращающую показатели, которые сортируют массив.

Мы можем использовать np.argsort для сортировки значений массивов по другому массиву. Ниже представлен пример сортировки имен студентов с использованием их результатов экзамена. Отсортированный массив имен также можно преобразовать обратно в исходный порядок, используя np.argsort(np.argsort(score)).

1. score = np.array([70, 60, 50, 10, 90, 40, 80])
2. name = np.array(['Ada', 'Ben', 'Charlie', 'Danny', 'Eden', 'Fanny', 'George'])
3. sorted_name = name[np.argsort(score)] # an array of names in ascending order of their scores
4. print(sorted_name) # ['Danny' 'Fanny' 'Charlie' 'Ben' 'Ada' 'George' 'Eden']
5.
6. original_name = sorted_name[np.argsort(np.argsort(score))]
7. print(original_name) # ['Ada' 'Ben' 'Charlie' 'Danny' 'Eden' 'Fanny' 'George']
8.
9.
10. %timeit name[np.argsort(score)]
11. # 1.83 µs ± 182 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
12. %timeit sorted(zip(score, name))
13. # 3.2 µs ± 76.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Эффективность данной функции выше, нежели результат использования встроенной функции Python sorted(zip()). Кроме того, она, пожалуй, более читабельна.

2. Бродкастинг — формы

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

Например, вы можете использовать приращение всех значений в массиве на 1, используя arr + 1 независимо от измерения arr. Вы также можете проверить, все ли значения в массиве больше, чем 2, с помощью arr > 2.

Но как мы узнаем, совместимы ли два массива с бродкастинг?

Argument 1 (4D array): 7 × 5 × 3 × 1
Argument 2 (3D array): 1 × 3 × 9
Output (4D array): 7 × 5 × 3 × 9

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

3. Параметры Ellipsis и NewAxis

Синтаксис для нарезки массива numpy — это i:j где i, j — начальный индекс и индекс остановки соответственно. Например, для массива numpy arr = np.array(range(10)) команда arr[:3] дает [0, 1, 2]. 

При работе с массивами с более высокими размерностями мы используем  :  для выбора индекса по каждой оси. Мы также можем использовать … для выбора индексов по нескольким осям. Точное количество осей выводится

1. arr = np.array(range(1000)).reshape(2,5,2,10,-1)
2. print(arr[:,:,:,3,2] == arr[...,3,2])
3. # [[[ True, True],
4. # [ True, True],
5. # [ True, True],
6. # [ True, True],
7. # [ True, True]],
8. # [[ True, True],
9. # [ True, True],
10. # [ True, True],
11. # [ True, True],
12. # [ True, True]]])
13.
14. print(arr.shape) # (2, 5, 2, 10, 5)
15. print(arr[...,np.newaxis,:,:,:].shape) # (2, 5, 1, 2, 10, 5)

С другой стороны, использование, np. newaxis, как показано выше, вставляет новую ось в заданное пользователем положение оси. Эта операция расширяет форму массива на одну единицу измерения. Хотя это также можно сделать с помощью np.expand_dims(), использование np.newaxis гораздо более читабельно и, пожалуй, изящно. 

4. Замаскированный массив — селекция

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

У Numpy есть подмодуль numpy.ma, который поддерживает массивы данных с масками. Маскированный массив содержит обычный массив numpy и маску, которая указывает положение недопустимых записей

np.ma.MaskedArray(data=arr, mask=invalid_mask)

Недопустимые записи в массиве иногда помечаются с использованием отрицательных значений или строк. Если мы знаем замаскированное значение, скажем -999, мы можем также создать замаскированный массив, используя np. ma.masked_values(arr, value=-999). Любая операция numpy, принимающая замаскированный массив в качестве аргумента, автоматически игнорирует эти недействительные записи, как показано ниже.

1. import math
2. def is_prime(n):
3. assert n > 1, 'Input must be larger than 1'
4. if n % 2 == 0 and n > 2:
5. return False
6. return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))
7.
8. arr = np.array(range(2,100))
9. non_prime_mask = [not is_prime(n) for n in a]
10. prime_arr = np.ma.MaskedArray(data=arr, mask=non_prime_mask)
11. print(prime_arr)
12. # [2 3 -- 5 -- 7 -- -- -- 11 -- 13 -- -- -- 17 -- 19 -- -- -- 23 -- -- -- --
13. # -- 29 -- 31 -- -- -- -- -- 37 -- -- -- 41 -- 43 -- -- -- 47 -- -- -- --
14. # -- 53 -- -- -- -- -- 59 -- 61 -- -- -- -- -- 67 -- -- -- 71 -- 73 -- --
15. # -- -- -- 79 -- -- -- 83 -- -- -- -- -- 89 -- -- -- -- -- -- -- 97 -- --]
16.
17. arr = np.array(range(11))
18. print(arr.sum()) # 55
19.
20. arr[-1] = -999 # indicates missing value
21. masked_arr = np.ma.masked_values(arr, -999)
22. print(masked_arr.sum()) # 45
23.

Источник

Массивы Ndarray для начинающих. Создание, функции и типы данных

Основной элемент библиотеки NumPy — объект ndarray (что значит N-размерный массив). Этот объект является многомерным однородным массивом с заранее заданным количеством элементов. Однородный — потому что практически все объекты в нем одного размера или типа. На самом деле, тип данных определен другим объектом NumPy, который называется dtype (тип-данных). Каждый ndarray ассоциирован только с одним типом dtype.

Количество размерностей и объектов массива определяются его размерностью (shape), кортежем N-положительных целых чисел. Они указывают размер каждой размерности. Размерности определяются как оси, а количество осей — как ранг.

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

Простейший способ определить новый объект ndarray — использовать функцию array(), передав в качестве аргумента Python-список элементов.

>>> a = np.array([1, 2, 3]) 
>>> a 
array([1, 2, 3])

Можно легко проверить, что новый объект — это ndarray, передав его функции type().

>>> type(a)
<type 'numpy.ndarray'>

Чтобы узнать ассоциированный тип dtype, необходимо использовать атрибут dtype.

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

>>> a.dtype 
dtype('int64')

Только что созданный массив имеет одну ось, а его ранг равняется 1, то есть его форма — (3,1). Для получения этих значений из массива необходимо использовать следующие атрибуты: ndim — для осей, size — для длины массива, shape — для его формы.

>>> a.ndim
1
>>> a.size
3
>>> a.shape
(3,)

Это был пример простейшего одномерного массива. Но функциональность массивов может быть расширена и до нескольких размерностей. Например, при определении двумерного массива 2×2:

>>> b = np.array([[1.3, 2.4],[0.3, 4.1]])
>>> b.dtype
dtype('float64')
>>> b.ndim
2
>>> b.size
4
>>> b.shape
(2, 2)

Ранг этого массива — 2, поскольку у него 2 оси, длина каждой из которых также равняется 2.

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

>>> b.itemsize
8
>>> b.data
<read-write buffer for 0x0000000002D34DF0, size 32, offset 0 at
0x0000000002D5FEA0>

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

Есть несколько вариантов создания массива. Самый распространенный — список из списков, выступающий аргументом функции array().

>>> c = np.array([[1, 2, 3],[4, 5, 6]])
>>> c
array([[1, 2, 3],
       [4, 5, 6]])

Функция array() также может принимать кортежи и последовательности кортежей.

>>> d = np.array(((1, 2, 3),(4, 5, 6)))
>>> d
array([[1, 2, 3],
       [4, 5, 6]])

Она также может принимать последовательности кортежей и взаимосвязанных списков.

>>> e = np. array([(1, 2, 3), [4, 5, 6], (7, 8, 9)])
>>> e
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

Типы данных

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

Типы данных, поддерживаемые NumPy

Тип данных Описание
bool Булевы значения (True или False) хранятся в виде байтов
int Тип по умолчанию — целое число (то же, что long в C; обычно int64 или int32)
intc Идентичный int в C (обычно int32 или int64)
intp Целое число для использования в качестве индексов (то же, что и size_t в C, обычно int32 или int64)
int8 Байт (от — 128 до 127)
int16 Целое число (от -32768 до 32767)
int32 Целое число (от -2147483648 до 2147483647)
int64 Целое число (от -9223372036854775808 до 9223372036854775807)
uint8 Целое число без знака (от 0 до 255)
uint16 Целое число без знака (от 0 до 65535)
uint32 Целое число без знака (от 0 до 4294967295)
uint64 Целое число без знака (от 0 до 18446744073709551615)
float Обозначение float64
float16 Число с плавающей точкой половинной точности; бит на знак, 5-битная экспонента, 10-битная мантисса
float32 Число с плавающей точкой единичной точности; бит на знак, 8-битная экспонента, 23-битная мантисса
float64 Число с плавающей точкой двойной точности; бит на знак, 11-битная экспонента, 52-битная мантисса
complex Обозначение complex128
complex64 Комплексное число, представленное двумя 32-битными float (с действительной и мнимой частями)
complex128 Комплексное число, представленное двумя 64-битными float (с действительной и мнимой частями)

Параметр dtype

Функция array() не принимает один аргумент. На примерах видно, что каждый объект ndarray ассоциирован с объектом dtype, определяющим тип данных, которые будут в массиве. По умолчанию функция array() можно ассоциировать самый подходящий тип в соответствии со значениями в последовательностях списков или кортежей. Их можно определить явно с помощью параметра dtype в качестве аргумента.

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

>>> f = np.array([[1, 2, 3],[4, 5, 6]], dtype=complex)
>>> f
array([[ 1.+0.j, 2.+0.j, 3.+0.j],
       [ 4.+0.j, 5.+0.j, 6.+0.j]])

Функции генерации массива

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

Функция zeros(), например, создает полный массив нулей с размерностями, определенными аргументом shape. Например, для создания двумерного массива 3×3, можно использовать:

>>> np.zeros((3, 3))
array([[ 0., 0., 0.],
       [ 0., 0., 0.],
       [ 0., 0., 0.]])

А функция ones() создает массив, состоящий из единиц.

>>> np.ones((3, 3))
array([[ 1., 1., 1.],
       [ 1., 1., 1.],
       [ 1., 1., 1.]])

По умолчанию две функции создают массивы с типом данных float64. Полезная фишка — arrange(). Она генерирует массивы NumPy с числовыми последовательностями, которые соответствуют конкретным требованиям в зависимости от переданных аргументов. Например, для генерации последовательности значений между 0 и 10, нужно передать всего один аргумент — значение, которое закончит последовательность.

>>> np. arange(0, 10) 
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

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

>>> np.arange(4, 10) 
array([4, 5, 6, 7, 8, 9])

Также можно сгенерировать последовательность значений с точным интервалом между ними. Если определено и третье значение в arrange(), оно будет представлять собой промежуток между каждым элементом.

>>> np.arange(0, 12, 3) 
array([0, 3, 6, 9])

Оно может быть и числом с плавающей точкой.

>>> np.arange(0, 6, 0.6)
array([ 0. , 0.6, 1.2, 1.8, 2.4, 3. , 3.6, 4.2, 4.8, 5.4])

Пока что в примерах были только одномерные массивы. Для генерации двумерных массивов все еще можно использовать функцию arrange(), но вместе с reshape(). Она делит линейный массив на части способом, который указан в аргументе shape.

>>> np.arange(0, 12).reshape(3, 4)
array([[ 0, 1, 2, 3],
       [ 4, 5, 6, 7],
       [ 8, 9, 10, 11]])

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

>>> np.linspace(0,10,5)
array([ 0. , 2.5, 5. , 7.5, 10. ])

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

>>> np.random.random(3)
array([ 0.78610272, 0.90630642, 0.80007102])

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

>>> np.random.random((3,3))
array([[ 0.07878569, 0.7176506 , 0.05662501],
       [ 0.82919021, 0.80349121, 0.30254079],
       [ 0.93347404, 0.65868278, 0.37379618]]) 

numpy.array — NumPy v1.20 Руководство

объект array_like

Массив, любой объект, предоставляющий интерфейс массива, объект, чей Метод __array__ возвращает массив или любую (вложенную) последовательность.

dtype тип данных, необязательно

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

copy bool, необязательно

Если true (по умолчанию), объект копируется.В противном случае копия будет только если __array__ возвращает копию, если obj является вложенной последовательностью, или если копия необходима для удовлетворения любых других требований ( dtype , заказ и др. ).

заказ {‘K’, ‘A’, ‘C’, ‘F’}, необязательно

Укажите структуру памяти массива. Если объект не является массивом, вновь созданный массив будет в порядке C (основная строка), если ‘F’ не указан, и в этом случае он будет в порядке Fortran (основной столбец).Если объект является массивом, выполняется следующее.

заказ

нет копии

копия = True

‘K’

без изменений

Порядок F&C сохранен, в остальном наиболее похожий порядок

‘A’

без изменений

Заказ F, если ввод F, а не C, в противном случае заказ C

‘C’

C заказ

C заказ

‘F’

F заказ

F заказ

Если copy = False и копия сделана по другим причинам, результатом будет так же, как если бы copy = True , с некоторыми исключениями для A , см. Раздел примечаний.Порядок по умолчанию — «K».

subok bool, необязательно

Если True, то подклассы будут пропущены, в противном случае возвращаемый массив будет вынужден быть массивом базового класса (по умолчанию).

ndmin int, необязательно

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

как array_like

Ссылочный объект, позволяющий создавать массивы, которые не Массивы NumPy.Если подобный массиву передан как , например, поддерживает протокол __array_function__ , результат будет определен этим. В этом случае он обеспечивает создание объекта массива. совместим с тем, что передается через этот аргумент.

Примечание

Ключевое слово like — экспериментальная функция, ожидающая выполнения принятие НЭПа 35.

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


Создание объекта ndarray NumPy

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

Мы можем создать NumPy ndarray с помощью функции array () .

Пример

импортировать numpy как np

arr = np.array ([1, 2, 3, 4, 5])

print (arr)

print (тип (arr))

Попробуй сам »

type (): Эта встроенная функция Python сообщает нам тип переданного ей объекта. Как в приведенном выше коде это показывает, что arr — это число.ndarray типа.

Чтобы создать ndarray , мы можем передать список, кортеж или любой объект, подобный массиву, в массив array () метод, и он будет преобразован в ndarray :

Пример

Используйте кортеж для создания массива NumPy:

импортировать numpy как np

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

печать (arr)

Попробуй сам »

Размеры в массивах

Размерность в массивах — это один уровень глубины массива (вложенные массивы).

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


0-D Массивы

массивов 0-D, или Скаляры — это элементы массива. Каждое значение в массиве представляет собой массив 0-D.

Пример

Создайте массив 0-D со значением 42

импортировать numpy как np

arr = np.array (42)

print (arr)

Попробуй сам »

Одномерные массивы

Массив, в качестве элементов которого используются массивы 0-D, называется одномерным или одномерным массивом.

Это самые распространенные и базовые массивы.

Пример

Создайте одномерный массив, содержащий значения 1,2,3,4,5:

импортировать numpy как np

arr = np.array ([1, 2, 3, 4, 5])

print (arr)

Попробуй сам »

Двумерные массивы

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

Часто используются для представления матриц или тензоров 2-го порядка.

NumPy имеет целый подмодуль, предназначенный для матричных операций, называемых число.мат

Пример

Создайте двумерный массив, содержащий два массива со значениями 1,2,3 и 4,5,6:

импортировать numpy как np

arr = np.array ([[1, 2, 3], [4, 5, 6]])

print (arr)

Попробуй сам »

Трехмерные массивы

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

Они часто используются для представления тензора 3-го порядка.

Пример

Создайте трехмерный массив с двумя двумерными массивами, каждый из которых содержит два массива с значения 1,2,3 и 4,5,6:

импортировать numpy как np

arr = np.массив ([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]])

print (arr)

Попробуй сам »

Проверить количество размеров?

NumPy Arrays предоставляет атрибут ndim , который возвращает целое число, которое сообщает нам, сколько измерений имеет массив.

Пример

Проверьте, сколько измерений имеют массивы:

импортировать numpy как np

a = np.array (42)
b = np.array ([1, 2, 3, 4, 5])
c = np.array ([[1, 2, 3], [4, 5, 6]])
d = np.array ([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]])

печать (a.ndim)
печать (b.ndim)
оттиск (c.ndim)
print (d.ndim)

Попробуй сам »

Массивы более высоких измерений

Массив может иметь любое количество измерений.

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

Пример

Создайте массив с 5 измерениями и убедитесь, что он имеет 5 измерений:

импортировать numpy как np

arr = np.массив ([1, 2, 3, 4], ndmin = 5)

print (arr)
print (‘количество измерений:’, arr.ndim)

Попробуй сам »

В этом массиве самое внутреннее измерение (5-й размер) имеет 4 элемента, 4-й тусклый свет имеет 1 элемент, который является вектором, 3-й размер имеет 1 элемент, который является матрицей с вектором, 2-й размер имеет 1 элемент, который является трехмерным массивом, а 1-й размер имеет 1 элемент, который является 4-мерным массивом.



Индексирование массива NumPy


Элементы массива доступа

Индексирование массива аналогично доступу к элементу массива.

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

Индексы в массивах NumPy начинаются с 0, что означает, что первый элемент имеет индекс 0, а второй имеет индекс 1 и т. д.

Пример

Получить первый элемент из следующего массива:

импортировать numpy как np

arr = np.array ([1, 2, 3, 4])

print (arr [0])

Попробуй сам »

Пример

Получите второй элемент из следующего массива.

импортировать numpy как np

arr = np.array ([1, 2, 3, 4])

print (arr [1])

Попробуй сам »

Пример

Получите третий и четвертый элементы из следующего массива и сложите их.

импортировать numpy как np

arr = np.array ([1, 2, 3, 4])

print (arr [2] + обр [3])

Попробуй сам »

Доступ к двумерным массивам

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

Пример

Доступ ко 2-му элементу на 1-м освещении:

импортировать numpy как np

arr = np.array ([[1,2,3,4,5], [6,7,8,9,10]])

print (‘2-й элемент на 1-м dim:’, arr [0, 1])

Попробуй сам »

Пример

Доступ к 5-му элементу на 2-м освещении:

импортировать numpy как np

arr = np.array ([[1,2,3,4,5], [6,7,8,9,10]])

print (‘5-й элемент на 2-й размер: ‘, обр [1, 4])

Попробуй сам »

Доступ к трехмерным массивам

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

Пример

Доступ к третьему элементу второго массива первого массива:

импортировать numpy как np

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

print (arr [0, 1, 2])

Попробуй сам »

Объяснение примера

arr [0, 1, 2] печатает значение 6 .

И вот почему:

Первое число представляет первое измерение, которое содержит два массива:
[[1, 2, 3], [4, 5, 6]]
и:
[[7, 8, 9], [10, 11, 12]]
Поскольку мы выбрали 0 , у нас остается первый массив:
[[1, 2, 3], [4, 5, 6]]

Второе число представляет второе измерение, которое также содержит два массива:
[1, 2, 3]
и:
[4, 5, 6]
Поскольку мы выбрали 1 , у нас остается второй массив:
[4, 5, 6]

Третье число представляет третье измерение, которое содержит три значения:
4
5
6
Поскольку мы выбрали 2 , мы получаем третье значение:
6


Отрицательное индексирование

Используйте отрицательную индексацию для доступа к массиву с конца.

Пример

Вывести последний элемент из 2-го размера:

import numpy as np

arr = np.array ([[1,2,3,4,5], [6,7,8,9,10]])

print (‘Последний элемент из 2-й размер: ‘, обр [1, -1])

Попробуй сам »

Python NumPy array tutorial — Like Geeks

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

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

Зачем нужен NumPy

Модуль NumPy предоставляет объект ndarray, с помощью которого мы можем выполнять операции с массивом любого измерения. Ndarray означает N-мерный массив, где N — любое число. Это означает, что массив NumPy может иметь любое измерение.

NumPy имеет ряд преимуществ перед списками Python. Мы можем выполнять высокопроизводительные операции с массивами NumPy, например:

  1. Сортировка элементов массива
  2. Математические и логические операции
  3. Функции ввода / вывода
  4. Статистические операции и операции линейной алгебры

Как установить NumPy?

Для установки NumPy вам потребуются Python и Pip в вашей системе.

Выполните следующую команду в своей ОС Windows:

 pip install numpy 

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

 импортный номер 

Добавить элемент массива

Вы можете добавить элемент массива NumPy с помощью метода append () модуля NumPy.

Синтаксис добавления следующий:

 numpy.append (массив, значение, ось) 

Значения будут добавлены в конец массива, и будет возвращен новый ndarray с новым и старым значениями, как показано выше.

Ось — это необязательное целое число, вдоль которого определяется способ отображения массива. Если ось не указана, структура массива будет сглажена, как вы увидите позже.

Рассмотрим следующий пример, где сначала объявляется массив, а затем мы использовали метод добавления для добавления дополнительных значений в массив:

 импортный номер

a = numpy.array ([1, 2, 3])

newArray = numpy.append (a, [10, 11, 12])

печать (newArray) 

Результат будет примерно таким:

Добавить столбец

Мы можем использовать метод append () NumPy для вставки столбца.

Рассмотрим пример ниже, где мы создали двумерный массив и вставили два столбца:

 импортный номер

a = numpy.array ([[1, 2, 3], [4, 5, 6]])

b = numpy.array ([[400], [800]])

newArray = numpy.append (a, b, ось = 1)

печать (newArray) 

Вывод будет примерно таким:

Если атрибут оси не используется, вывод будет следующим:

Таким образом структура массива сглаживается.

В NumPy мы также можем использовать метод insert () для вставки элемента или столбца. Разница между методом insert () и методом append () заключается в том, что мы можем указать, по какому индексу мы хотим добавить элемент при использовании метода insert (), но метод append () добавляет значение в конец массива.

Рассмотрим пример ниже:

 импортный номер

a = numpy.array ([1, 2, 3])

newArray = numpy.insert (a, 1, 90)

печать (newArray) 

Результат будет следующим:

Здесь метод insert () добавляет элемент с индексом 1. Помните, что индекс массива начинается с 0.

Добавить строку

В этом разделе мы будем использовать метод append () для добавления строки в массив. Это так же просто, как добавить элемент в массив. Рассмотрим следующий пример:

 импортный номер

a = numpy.array ([[1, 2, 3], [4, 5, 6]])

newArray = numpy.append (a, [[50, 60, 70]], ось = 0)

печать (newArray) 

Результат будет следующим:

Удалить элемент

Вы можете удалить элемент массива NumPy, используя метод delete () модуля NumPy:

Это показано в примере ниже:

 импортный номер

а = numpy.массив ([1, 2, 3])

newArray = numpy.delete (a, 1, ось = 0)

печать (newArray) 

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

В приведенном выше примере у нас есть одномерный массив. Метод delete () удаляет элемент с индексом 1 из массива.

Удалить строку

Точно так же вы можете удалить строку с помощью метода delete ().

Рассмотрим следующий пример, где мы удалили строку из двумерного массива:

 импортный номер

а = numpy.массив ([[1, 2, 3], [4, 5, 6], [10, 20, 30]])

newArray = numpy.delete (a, 1, ось = 0)

печать (newArray) 

Результат будет следующим:

В методе delete () вы сначала указываете массив, а затем индекс элемента, который хотите удалить. В приведенном выше примере мы удалили второй элемент с индексом 1.

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

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

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

 импортный номер

a = numpy.array ([1, 2, 3])

если (a.size == 0):

    print ("Данный массив пуст")

еще:

    print ("Массив =", a) 

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

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

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

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

 a = numpy.array ([]) 

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

Найти индекс значения

Чтобы найти индекс значения, мы можем использовать метод where () модуля NumPy, как показано в примере. ниже:

 импортный номер

a = numpy.array ([1, 2, 3, 4, 5])

print ("5 найдено по индексу:", numpy.где (a == 5)) 

Результат будет следующим:

Метод where () также вернет тип данных. Если вы хотите просто получить индекс, используйте следующий код:

 импортный номер

a = numpy.array ([1, 2, 3, 4, 5])

index = numpy.where (a == 5)

print ("5 найдено по индексу:", index [0]) 

Тогда вывод будет:

Нарезка массива NumPy

Нарезка массива — это процесс извлечения подмножества из заданного массива.Вы можете разрезать массив с помощью оператора двоеточия (:) и указать начало и конец индекса массива, например:

 массив [от: до] 

Это выделено в примере ниже:

 импортный номер

a = numpy.array ([1, 2, 3, 4, 5, 6, 7, 8])

print ("Подмножество массива a =", a [2: 5]) 

Здесь мы извлекли элементы, начиная с индекса 2 и заканчивая индексом 5. Результатом будет:

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

 импортный номер

a = numpy.array ([1, 2, 3, 4, 5, 6, 7, 8])

print ("Подмножество массива a =", a [-3:]) 

Результатом будет:

Применить функцию ко всем элементам массива

В следующем примере мы собираемся создать лямбда-функцию, в которую мы передадим наш массив, чтобы применить ее ко всем элементам:

 импортный номер

сложение = лямбда x: x + 2

а = numpy.массив ([1, 2, 3, 4, 5, 6])

print ("Массив после функции сложения:", сложение (a)) 

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

В этом примере создается лямбда-функция, которая увеличивает каждый элемент на два.

Длина массива NumPy

Чтобы получить длину массива NumPy, вы можете использовать атрибут size модуля NumPy, как показано в следующем примере:

 импортный номер

a = numpy.array ([1, 2, 3, 4, 5, 6])

print ("Размер массива =", a.размер) 

Этот код сгенерирует следующий результат:

Создать массив NumPy из списка

Списки в Python — это количество элементов, заключенных в квадратные скобки.

Предположим, у вас есть список как:

 л = [1, 2, 3, 4, 5] 

Теперь, чтобы создать массив из этого списка, мы будем использовать метод array () модуля NumPy:

 импортный номер

l = [1, 2, 3, 4, 5]

a = numpy.array (l)

print ("Массив NumPy из списка Python =", a) 

Результат будет следующим:

Аналогично, используя метод array (), мы можем создать массив NumPy из кортежа.Кортеж содержит ряд элементов, заключенных в круглые скобки:

 импортный номер

т = (1, 2, 3, 4, 5)

a = numpy.array (t)

print ("Массив NumPy из Python Tuple =", a) 

Результатом будет:

Преобразовать массив NumPy в список

Чтобы преобразовать массив в список, мы можем использовать метод tolist () модуля NumPy.

Рассмотрим код ниже:

 импортный номер

а = numpy.массив ([1, 2, 3, 4, 5])

print ("Массив в список =", a.tolist ()) 

Результат будет следующим:

В этом коде мы просто вызвали метод tolist (), который преобразует массив в список. Затем мы выводим вновь созданный список на экран вывода.

Массив NumPy в CSV

Чтобы экспортировать массив в файл CSV, мы можем использовать метод savetxt () модуля NumPy, как показано в примере ниже:

 импортный номер

а = numpy.массив ([1, 2, 3, 4, 5])

numpy.savetxt ("myArray.csv", a) 

Этот код сгенерирует CSV-файл в том месте, где хранится наш файл кода Python. Вы также можете указать путь. Когда вы запустите сценарий, файл будет сгенерирован следующим образом:

Содержимое этого файла будет следующим:

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

 numpy.savetxt ("myArray.csv", a, fmt = '%. 2f') 

Сортировка массива NumPy

Вы можете отсортировать массив NumPy с помощью метода sort () модуля NumPy:

Функция sort () принимает необязательную ось (целое число), которая по умолчанию равна -1.Ось указывает, по какой оси мы хотим отсортировать массив. -1 означает, что массив будет отсортирован по последней оси.

Рассмотрим пример ниже:

 импортный номер

a = numpy.array ([16, 3, 2, 6, 8, 10, 1])

print ("Сортированный массив =", numpy.sort (a)) 

В этом примере мы вызвали метод sort () в операторе печати. Массив «a» передается функции сортировки. Результатом будет следующий:

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

Нормализация массива — это процесс приведения значений массива в некоторый определенный диапазон.Например, мы можем сказать, что хотим нормализовать массив от -1 до 1 и так далее.

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

 x = (x - xmin) / (xmax - xmin) 

Теперь применим эту формулу к нашему массиву, чтобы нормализовать его. Чтобы найти максимальный и минимальный элементы в массиве, мы будем использовать методы max () и min () NumPy соответственно.

 импортный номер

x = numpy.array ([400, 800, 200, 700, 1000, 2000, 300])

xmax = x.max ()

хмин = х.мин ()

х = (х - хмин) / (хмакс - хмин)

print ("После нормализации массив x = \ n", x) 

Результат будет следующим:

Индексирование массива

Средство индексирования относится к элементу массива. В следующих примерах мы также использовали индексацию в одномерных и двухмерных массивах:

 импортный номер

a = numpy.array ([20, 13, 42, 86, 81, 9, 11])

print ("Элемент с индексом 3 =", a [3]) 

Результат будет следующим:

Теперь индексация с помощью двумерного массива:

 импортный номер

а = numpy.массив ([[20, 13, 42], [86, 81, 9]])

print ("Элемент с индексом a [1] [2] =", a [1] [2]) 

Результатом будет:

Индекс [1] [2] означает вторую строку и третий столбец (поскольку индексирование начинается с 0). Следовательно, на экране вывода у нас 9.

Добавить массив NumPy к другому

Вы можете добавить массив NumPy к другому массиву NumPy с помощью метода append ().

Рассмотрим следующий пример:

 импортный номер

а = numpy.массив ([1, 2, 3, 4, 5])

b = numpy.array ([10, 20, 30, 40, 50])

newArray = numpy.append (a, b)

print ("Новый массив =", newArray) 

Результат будет следующим:

В этом примере создается массив NumPy «a», а затем создается другой массив с именем «b». Затем мы использовали метод append () и передали два массива. Поскольку массив «b» передается в качестве второго аргумента, он добавляется в конец массива «a».

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

Аиша Тарик (Ayesha Tariq) — программист полного цикла, веб-разработчик и энтузиаст-разработчик блокчейнов. Она обладает обширными знаниями C / C ++, Java, Kotlin, Python и многих других.

Numpy | Создание массива — GeeksforGeeks

} .numpy-table td {border: 1px solid # 5fb962; color: # 000; text-align: left! Important}

Создание массива с использованием списка: Массивы используются для хранения нескольких значений в одна-единственная переменная.Python не имеет встроенной поддержки массивов, но вместо этого можно использовать списки Python.
Пример:

arr = [1, 2, 3, 4, 5]
arr1 = ["гики", "для", "гики"]
 
# Программа Python для создания
# массив

# Создание массива с использованием списка
    arr = [1, 2, 3, 4, 5]
    для я в обр:
        печать (я)


 

Выход:

1
2
3
4
5
 


Создание массива с использованием функций массива:
массив (тип данных, список значений) Функция используется для создания массива с типом данных и списком значений, указанными в его аргументах.
Пример:

# Код Python для демонстрации работы
# множество()
 
# импорт "массива" для операций с массивом
импортный массив
 
# инициализация массива значениями массива
# инициализирует массив целыми числами со знаком
arr = array.array ('я', [1, 2, 3])

# печать исходного массива
print ("Новый созданный массив:", end = "")
для i в диапазоне (0,3):
    print (arr [i], end = "")

печать ("\ г")
 

Выход:

 Новый созданный массив: 1 2 3 1 5
 


Создание массива с использованием методов numpy:
NumPy предлагает несколько функций для создания массивов с начальным содержимым заполнителя.Это сводит к минимуму необходимость наращивания массивов — дорогостоящая операция. Например: np.zeros, np.empty и т. Д.

numpy.empty (shape, dtype = float, order = ‘C’): Возвращает новый массив заданной формы и типа со случайными значениями.

# Программирование на Python, иллюстрирующее
# numpy.empty метод

импортировать numpy как компьютерщик

b = geek.empty (2, dtype = int)
print ("Матрица b: \ n", b)

a = geek.empty ([2, 2], dtype = int)
print ("\ nМатрица a: \ n", a)

c = компьютерщик.пустой ([3, 3])
print ("\ nМатрица c: \ n", c)
 

Выход:


Матрица b:
 [0 1079574528]

Матрица а:
 [[0 0]
 [0 0]]

Матрица а:
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]] 

numpy.zeros (shape, dtype = None, order = ‘C’): Возвращает новый массив заданной формы и типа с нулями.

# Программа Python, иллюстрирующая
# numpy.zeros метод

импортировать numpy как компьютерщик

б = компьютерщик.нули (2, dtype = int)
print ("Матрица b: \ n", b)

a = geek.zeros ([2, 2], dtype = int)
print ("\ nМатрица a: \ n", a)

c = geek.zeros ([3, 3])
print ("\ nМатрица c: \ n", c)

 

Выход:

 Матрица b:
 [0 0]

Матрица а:
 [[0 0]
 [0 0]]

Матрица c:
 [[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
 


Изменение формы массива: Мы можем использовать метод reshape для изменения формы массива.Рассмотрим массив формы (a1, a2, a3,…, aN). Мы можем изменить его форму и преобразовать в другой массив с формой (b1, b2, b3,…, bM).
Единственное необходимое условие: a1 x a2 x a3… x aN = b1 x b2 x b3… x bM. (т.е. исходный размер массива остается неизменным.)

numpy.reshape (array, shape, order = ‘C’): Формирует массив без изменения данных массива.

# Программа Python, иллюстрирующая
# метод numpy.reshape ()

импортировать numpy как компьютерщик

массив = компьютерщик.апельсин (8)
print ("Исходный массив: \ n", массив)

# shape массив с 2 строками и 4 столбцами
массив = geek.arange (8) .reshape (2, 4)
print ("\ narray изменено с 2 строками и 4 столбцами: \ n", массив)

# shape массив с 2 строками и 4 столбцами
массив = geek.arange (8) .reshape (4, 2)
print ("\ narray изменено с 2 строками и 4 столбцами: \ n", массив)

# Строит 3D-массив
массив = geek.arange (8) .reshape (2, 2, 2)
print ("\ nОригинальный массив преобразован в 3D: \ n", массив)
 

Выход:

Исходный массив:
 [0 1 2 3 4 5 6 7]

массив, преобразованный в 2 строки и 4 столбца:
 [[0 1 2 3]
 [4 5 6 7]]

массив, преобразованный в 2 строки и 4 столбца:
 [[0 1]
 [2 3]
 [4 5]
 [6 7]]

Исходный массив преобразован в 3D:
 [[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
 

Для создания последовательностей чисел NumPy предоставляет функцию, аналогичную диапазону, которая возвращает массивы вместо списков.
arange возвращает равномерно распределенные значения в заданном интервале. шаг размер указан.
linspace возвращает равномерно распределенные значения в заданном интервале. № элементов возвращаются.

arange ([start,] stop [, step,] [, dtype]): Возвращает массив с равномерно расположенными элементами в соответствии с интервалом. Указанный интервал открыт наполовину, т.е. [Старт, Стоп)

# Программирование на Python, иллюстрирующее
# numpy.метод аранжировки

импортировать numpy как компьютерщик

print ("A \ n", geek.arange (4) .reshape (2, 2), "\ n")

print ("A \ n", geek.arange (4, 10), "\ n")

print ("A \ n", geek.arange (4, 20, 3), "\ n")
 

Выход:

А
 [[0 1]
 [2 3]]

А
 [4 5 6 7 8 9]

А
 [4 7 10 13 16 19]

 

numpy.linspace (start, stop, num = 50, endpoint = True, retstep = False, dtype = None): Возвращает числовые пробелы равномерно w.r.t интервал. Подобно диапазону, но вместо шага используется номер образца.

# Программирование на Python, иллюстрирующее
# numpy.linspace метод

импортировать numpy как компьютерщик

# restep установлен на True
print ("B \ n", geek.linspace (2.0, 3.0, num = 5, retstep = True), "\ n")

# Чтобы оценить sin () в большом диапазоне
х = geek.linspace (0, 2, 10)
print ("A \ n", geek.sin (x))

 

Выход:

B
 (массив ([2., 2.25, 2,5, 2,75, 3.]), 0,25)

А
 [0. 0,22039774 0,42995636 0,6183698 0,77637192 0,8961922
  0,9719379 0,99988386 0,9786557 0,743] 


Сглаживание массива: Мы можем использовать метод сглаживания, чтобы получить копию массива, свернутую в одно измерение. Он принимает аргумент заказа. Значение по умолчанию — «C» (для строкового порядка). Используйте «F» для определения основного порядка столбцов.

numpy.ndarray.flatten (order = ‘C’) : вернуть копию массива, свернутого в одно измерение.

# Программа Python, иллюстрирующая
# метод numpy.flatten ()

импортировать numpy как компьютерщик

array = geek.array ([[1, 2], [3, 4]])

# используя метод сглаживания
array.flatten ()
печать (массив)

# используя метод откорма
array.flatten ('F')
печать (массив)
 

Выход:

[1, 2, 3, 4]
[1, 3, 2, 4]
 

Методы создания массива в Numpy
900 57
Функция Описание
empty () Вернуть новый массив заданной формы и типа без инициализации записей
empty_like () Вернуть новый массив той же формы и типа, что и данный массив
eye () Вернуть двумерный массив с единицами на диагонали и нулями в другом месте.
identity () Вернуть массив идентификаторов
ones () Вернуть новый массив заданной формы и типа, заполненный единицами
ones_like () Возвращает массив единиц той же формы и типа, что и данный массив
zeros () Возвращает новый массив заданной формы и типа, заполненный нулями
zeros_like () Возвращает массив нулей той же формы и типа, что и данный массив
full_like () Возвращает полный массив той же формы и типа, что и данный массив.
array () Создание массива
asarray () Преобразование ввода в массив
asanyarray () Преобразование ввода в ndarray, но передать подклассы ndarray через
ascontiguousarray () Возвратить непрерывный массив в памяти (порядок C)
asmatrix () Интерпретировать ввод как матрицу
copy () Вернуть копию массива данного объекта
frombuffer () Интерпретировать буфер как одномерный массив
fromfile () Построить массив из данных в тексте или двоичный файл
fromfunction () Создайте массив, выполнив функцию по каждой координате
fromiter () Создание нового одномерного массива из итерируемого объекта
fromstring () Новый одномерный массив, инициализированный из текстовых данных в строке
loadtxt () Загрузить данные из текстового файла
arange () Возвращает равномерно распределенные значения в пределах заданного интервала
linspace () Возвращает равномерно распределенные числа в заданном интервале
logspace () Возвращает числа, равномерно распределенные в логарифмической шкале
geomspace () Возвращает числа, равномерно распределенные в логарифмической шкале (геометрическая прогрессия)
meshgrid ( ) Вернуть матрицы координат из векторов координат
mgrid () nd_grid instance который возвращает плотную многомерную сетку.
ogrid () экземпляр nd_grid, который возвращает открытую многомерную сетку.
diag () Извлечение диагонали или построение диагонального массива
diagflat () Создание двумерного массива со сглаженным входом в виде диагонали
tri () Массив с единицами на данной диагонали и ниже и нулями в другом месте
tril () Нижний треугольник массива
triu () Верхний треугольник массива
vander () Сгенерировать матрицу Вандермонда
mat () Интерпретировать ввод как матрицу
bmat () Построить матричный объект f из строки, вложенной последовательности или массива

Полное руководство по массивам NumPy

В этом уроке мы узнаем о массивах NumPy.

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

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

Массивы NumPy создаются путем вызова метода array () из библиотеки NumPy. Внутри метода вы должны передать список.

Пример базового массива NumPy показан ниже. Обратите внимание, что хотя я запускаю оператор import numpy as np в начале этого блока кода, он будет исключен из других блоков кода в этом уроке для краткости.

  импортировать numpy как np

sample_list = [1, 2, 3]

np.array (список_выборок)  

Последняя строка этого блока кода приведет к выводу, который выглядит следующим образом.

Оболочка array () указывает, что это больше не обычный список Python. Вместо этого это массив NumPy.

Два разных типа массивов NumPy

Существует два разных типа массивов NumPy: векторы и матрицы.

Векторы — это одномерные массивы NumPy и выглядят так:

  my_vector = np.array (['this', 'is', 'a', 'vector'])  
Матрицы

— это двумерные массивы, которые создаются путем передачи списка списков в метод np.array () . Пример ниже.

  my_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

np.array (my_matrix)  

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

Массивы NumPy: встроенные методы

Массивы

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

Как получить диапазон чисел в Python с помощью NumPy

NumPy имеет полезный метод под названием arange , который принимает два числа и дает вам массив целых чисел, которые больше или равны (> = ) первому числу и меньше ( <) второму числу.

Пример метода arange приведен ниже.

Вы также можете включить третью переменную в метод arange , который обеспечивает размер шага для возвращаемой функции. Передача 2 в качестве третьей переменной вернет каждое 2-е число в диапазоне, передача 5 в качестве третьей переменной вернет каждое 5-е число в диапазоне и т. Д.

Пример использования третьей переменной в методе arange приведен ниже.

Как сгенерировать единицы и нули в Python с помощью NumPy

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

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

Вы также можете сделать нечто подобное, используя двумерные массивы.Например, np.zeros (5, 5) создает матрицу 5x5, содержащую все нули.

Мы можем создавать массивы единиц, используя аналогичный метод под названием ones . Пример ниже.

Как равномерно разделить диапазон чисел в Python с помощью NumPy

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

  1. Начало интервала
  2. Конец интервала
  3. Количество подинтервалов, на которые нужно разделить интервал

Ниже приведен пример метода linspace .

Как создать матрицу идентичности в Python с помощью NumPy

Любой, кто изучал линейную алгебру, знаком с концепцией «единичной матрицы», которая представляет собой квадратную матрицу, диагональные значения которой равны 1 .NumPy имеет встроенную функцию, которая принимает один аргумент для построения матриц идентичности. Функция глаз .

Примеры ниже:

  НП. Глаз (1)



нп. глаз (2)



нп. глаз (50)

  

Как создавать случайные числа в Python с помощью NumPy

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

  нп.random.rand (размер_выборки)





np.random.randn (размер_элемента)





np.random.randint (низкий, высокий, размер_элемента)

  

Как изменить форму массивов NumPy

Очень часто бывает, что массив с определенными размерами преобразует этот массив в другую форму. Например, у вас может быть одномерный массив с 10 элементами и вы хотите переключить его на двумерный массив 2x5.

Пример ниже:

  arr = np.array ([0,1,2,3,4,5])

arr.reshape (2,3)  

Результат этой операции:

  массив ([[0, 1, 2],

       [3, 4, 5]])  

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

Если вам интересно узнать текущую форму массива NumPy, вы можете определить его форму, используя атрибут NumPy shape . Используя нашу предыдущую структуру переменных arr , ниже приведен пример вызова атрибута shape :

  arr = np.array ([0,1,2,3,4,5])

обр. форма



arr = arr.reshape (2,3)

обр. форма

  

Вы также можете комбинировать метод reshape с атрибутом shape в одной строке следующим образом:

Как найти максимальное и минимальное значение массива NumPy

В заключение этого урока давайте узнаем о четырех полезных методах определения максимального и минимального значений в массиве NumPy.Будем работать с этим массивом:

  simple_array = [1, 2, 3, 4]  

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

Мы также можем использовать метод argmax , чтобы найти индекс максимального значения в массиве NumPy. Это полезно, когда вы хотите найти местоположение максимального значения, но вам не обязательно заботиться о его значении.

Пример ниже.

Точно так же мы можем использовать методы min и argmin , чтобы найти значение и индекс минимального значения в массиве NumPy.

  simple_array.min ()



simple_array.argmin ()

  

Движение вперед

В этом уроке мы обсудили различные атрибуты и методы массивов NumPy. В следующем уроке мы продолжим работу с некоторыми практическими проблемами с массивами NumPy.

Нежное введение в массивы NumPy в Python

Последнее обновление 29 ноября 2019 г.

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

В Python массивы из библиотеки NumPy, называемые N-мерными массивами или ndarray, используются в качестве первичной структуры данных для представления данных.

В этом руководстве вы откроете для себя N-мерный массив в NumPy для представления числовых данных и управления данными в Python.

После прохождения этого руководства вы будете знать:

  • Что такое ndarray и как создавать и проверять массив в Python.
  • Ключевые функции для создания новых пустых массивов и массивов со значениями по умолчанию.
  • Как объединить существующие массивы для создания новых массивов.

Начните свой проект с моей новой книги «Линейная алгебра для машинного обучения», включающей пошаговых руководств и файлов исходного кода Python для всех примеров.

Приступим.

Нежное введение в N-мерные массивы в Python с помощью NumPy
Фото: patrickkavanagh, некоторые права защищены.

Обзор учебного пособия

Это руководство разделено на 3 части; их:

  1. NumPy N-мерный массив
  2. Функции для создания массивов
  3. Объединение массивов

Нужна помощь с линейной алгеброй для машинного обучения?

Пройдите мой бесплатный 7-дневный ускоренный курс по электронной почте (с образцом кода).

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

Загрузите БЕСПЛАТНЫЙ мини-курс

NumPy N-мерный массив

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

Основная структура данных в NumPy - ndarray, сокращенное имя N-мерного массива. При работе с NumPy данные в ndarray просто называются массивом.

Это массив фиксированного размера в памяти, который содержит данные одного и того же типа, например целые числа или значения с плавающей запятой.

Доступ к типу данных, поддерживаемому массивом, можно получить через атрибут «dtype» в массиве. Доступ к размерам массива можно получить с помощью атрибута shape, который возвращает кортеж, описывающий длину каждого измерения. Есть множество других атрибутов. Узнайте больше здесь:

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

В приведенном ниже примере создается список Python из 3 значений с плавающей запятой, затем создается ndarray из списка и осуществляется доступ к форме и типу данных массивов.

# создать массив из массива импорта numpy l = [1.0, 2.0, 3.0] а = массив (l) печать (а) печать (форма) print (a.dtype)

# создать массив

из массива импорта numpy

l = [1.0, 2.0, 3.0]

a = array (l)

print (a)

print (a.форма)

печать (тип a.d)

При выполнении примера печатается содержимое ndarray, фигура, которая представляет собой одномерный массив с 3 элементами, и тип данных, представляющий собой 64-битную плавающую точку.

Функции для создания массивов

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

Давайте рассмотрим лишь некоторые из них. Вы можете увидеть полный список здесь:

Пустой

Функция empty () создаст новый массив указанной формы.

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

В приведенном ниже примере создается пустой двумерный массив 3 × 3.

# создать пустой массив из numpy import пусто a = пусто ([3,3]) печать (а)

# создать пустой массив

из numpy import empty

a = empty ([3,3])

print (a)

При выполнении примера печатается содержимое пустого массива.Конкретное содержимое вашего массива будет отличаться.

[[0.00000000e + 000 0.00000000e + 000 2.20802703e-314] [2.20803350e-314 2.20803353e-314 2.20803356e-314] [2.20803359e-314 2.20803362e-314 2.20803366e-314]]

[[0.00000000e + 000 0.00000000e + 000 2.20802703e-314]

[2.20803350e-314 2.20803353e-314 2.20803356e-314]

[2.20803359e-314 2.20803362e-314-2.20433]

Нули

Функция zeros () создаст новый массив указанного размера с содержимым, заполненным нулевыми значениями.

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

В приведенном ниже примере создается нулевой двумерный массив 3 × 5.

# создать нулевой массив из numpy импортных нулей а = нули ([3,5]) печать (а)

# создать нулевой массив

из numpy import zeros

a = zeros ([3,5])

print (a)

При выполнении примера печатается содержимое созданного нулевого массива.

[[0. 0. 0. 0. 0.] [0. 0. 0. 0. 0.] [0. 0. 0. 0. 0.]]

[[0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0.]

[0. 0. 0. 0. 0.]]

Единицы

Функция ones () создаст новый массив указанного размера с содержимым, заполненным единичными значениями.

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

В приведенном ниже примере создается одномерный массив из 5 элементов.

# создать один массив из множества импортных а = единицы ([5]) печать (а)

# создать один массив

из numpy import ones

a = ones ([5])

print (a)

При выполнении примера печатается содержимое созданного массива.

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

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

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

Вертикальный стек

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

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

Это показано в примере ниже.

# vstack из массива импорта numpy из numpy import vstack a1 = массив ([1,2,3]) печать (a1) a2 = массив ([4,5,6]) печать (a2) a3 = vstack ((a1, a2)) печать (a3) печать (a3.форма)

# vstack

из массива импорта numpy

из массива импорта numpy vstack

a1 = array ([1,2,3])

print (a1)

a2 = array ([4,5,6])

печать (a2)

a3 = vstack ((a1, a2))

печать (a3) ​​

печать (a3.shape)

При выполнении примера сначала печатаются два отдельно определенных одномерных массива. Массивы укладываются вертикально, в результате получается новый массив 2 × 3, содержимое и форма которого печатаются.

[1 2 3] [4 5 6] [[1 2 3] [4 5 6]] (2, 3)

[1 2 3]

[4 5 6]

[[1 2 3]

[4 5 6]]

(2, 3)

Горизонтальный стек

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

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

Это показано в примере ниже.

# hstack из массива импорта numpy из numpy import hstack a1 = массив ([1,2,3]) печать (a1) a2 = массив ([4,5,6]) печать (a2) a3 = стек ((a1, a2)) печать (a3) печать (a3.shape)

# hstack

из массива импорта numpy

из массива импорта numpy

a1 = array ([1,2,3])

print (a1)

a2 = array ([4,5,6])

print (a2)

a3 = hstack ((a1, a2))

print (a3) ​​

print (a3.форма)

При выполнении примера сначала печатаются два отдельно определенных одномерных массива. Затем массивы укладываются горизонтально, в результате получается новый одномерный массив с 6 элементами, содержимое и форма которых печатаются.

[1 2 3] [4 5 6] [1 2 3 4 5 6] (6,)

[1 2 3]

[4 5 6]

[1 2 3 4 5 6]

(6,)

Расширения

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

  • Поэкспериментируйте с различными способами создания массивов собственного размера или с новыми данными.
  • Найдите и разработайте пример 3 дополнительных функций NumPy для создания массивов.
  • Найдите и разработайте пример 3 дополнительных функций NumPy для объединения массивов.

Если вы изучите какое-либо из этих расширений, я хотел бы знать.

Дополнительная литература

В этом разделе представлены дополнительные ресурсы по теме, если вы хотите углубиться.

Книги

Список литературы

API

Сводка

В этом руководстве вы обнаружили N-мерный массив в NumPy для представления числовых данных и управления данными в Python.

В частности, вы выучили:

  • Что такое ndarray и как создавать и проверять массив в Python.
  • Ключевые функции для создания новых пустых массивов и массивов со значениями по умолчанию.
  • Как объединить существующие массивы для создания новых массивов.

Есть вопросы?
Задайте свои вопросы в комментариях ниже, и я постараюсь ответить.

Получите знания о линейной алгебре для машинного обучения!

Развить рабочее понимание линейной алгебры

... путем написания строк кода на Python

Узнайте, как это сделать, в моей новой электронной книге:
Линейная алгебра для машинного обучения

Он предоставляет самоучителей по таким темам, как:
векторные нормы, умножение матриц, тензоры, собственное разложение, SVD, PCA и многое другое.