Рубрики
Без рубрики

Numpy Tustorial – все, что вам нужно знать, чтобы начать

Это руководство дает вам простое введение в Numpy Bibrey Python. Вам не нужно никаких предпосылок, чтобы следовать учебнику. Моя цель состояла в том, чтобы дать практическое и веселое применение Numpy для абсолютных новичков и многих примеров. Прочитав этот учебник, вы получите базовое понимание наиболее важных функций Numpy. … Numpy Учебник – все, что вам нужно знать, чтобы начать Подробнее »

Автор оригинала: Chris.

Этот учебник дает вам простое введение в Python’s Numpy библиотека. Вам не нужно никаких предпосылок, чтобы следовать учебнику. Моя цель состояла в том, чтобы дать практическое и веселое применение Numpy для абсолютных новичков и многих примеров.

Прочитав этот учебник, вы получите базовое понимание наиболее важных функций Numpy. Более того, я дам вам ссылки на дальнейшее чтение, а также «следующие шаги». Чтение этого учебника занимает между 20-30 минут Отказ

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

После завершения учебника я понял, что стал статьей> 6000 слов. Поэтому я в процессе публикации расширенной версии в качестве электронной книги прямо сейчас.

Редактировать : В то же время я опубликовал новый Numpy TextBook на основе обучения на основе головоломки.

Numpy Cheat лист (PDF)

Вот быстрое скачивание для вас: я создал этот мошеннический лист, чтобы объяснить некоторые важные Numpy Concepts для моих студентов кодирования.

Вы также можете скачать больше читов для читов Python:

Numpy Video.

Я также создал всеобъемлющий Numpy видеоурок для начинающих на основе большого количества содержания здесь:

Так что без дальнейшего введения давайте погрузимся в Numpy библиотеку в Python.

Что такое Numpy?

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

В основе Numpy является основным типом данных, называемых Numpy Array. Объемный массив представляет собой многомерную матрицу численных значений данных (целые числа или плавать). Облегающий массив позволяет только для численных значений данных. В этом смысле многие массивы отличаются от Списки Python которые позволяют произвольными типами данных. Numpy еще более ограничит, чем сосредоточиться только на численных значениях данных. Это должно быть Однородные значения данных также. Это означает, что Numpy Array содержит целое число или плавайте значения, но не оба одновременно.

Эти ограничения типа данных позволяют Numpy специализироваться на обеспечении эффективной линейной алгебры.

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

Но вы можете спросить (и правильно):

Что может наменять для меня?

Страх пропустить на машине обучения и науке о данных? Обучение Numpy теперь является отличным первым шагом в области машинного обучения и науки о данных. В машинном обучении важные алгоритмы и структуры данных полагаются на матричные вычисления. Что такое матрицы? В Numpy они являются массивами с однородными данными одного и того же типа – например, значения поплавка.

Numpy является одним из самых популярных библиотек в Python (E.g. см. Эта статья ). Большинство экспертов по изучению машин согласны с тем, что Python является верхним языком программирования для изучения машин. Внутри Python Numpy является одним из важнейших библиотек для Наука и машина науки и машины Отказ Например, поиск ключевого слова «Обнажитие машины» показывает больше, чем 3 миллиона страницы.

Сравните это с библиотекой Scikit-Learn, которая напрямую обращается к машине обучения:

Как видите, Numpy производит больше результатов – даже если он не напрямую обрабатывает машинное обучение (в отличие от Scikit-Surve).

Независимо от того, какая библиотека более популярна – numpy – это 600 фунтов горилла в машинном обучении и научном пространстве данных. Если вы серьезно относитесь к вашей карьере в качестве ученого данных, вы должны завоевать Numpy сейчас!

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

Кроме того, если вам нужно визуализировать данные, вы очень полагаетесь на Numpy Library. Вот пример от официальной документации Python’s Построение библиотеки Pyplot (слегка рестайлируется;)). Вы можете увидеть небольшой сценарий, который графикирует линейную, квадратичную и кубическую функцию. Он использует только два библиотека: Матплотлиб и … numpy!

import numpy as np
import matplotlib.pyplot as plt

# evenly distributed data between 0 and 1
x = np.arange(0., 1., 0.1)

# xkcd-styled plot
plt.xkcd()

# linear, quadratic, and cubic plots
plt.plot(x, x, 'v-', x, x**2, 'x-', x, x**3, 'o-')
plt.savefig("functions.jpg")
plt.show()

Куда бы вы ни находились в науке о данных с Python, Numpy уже там!

Каковы ограничения Numpy?

Фокус Numpy работает с численными данными. Это оба: мощный и низкий уровень (он предоставляет основные функциональные возможности для алгоритмов высокого уровня). Если вы входите в программу обучения машины и науке данных, вы хотите сначала освоить Numpy. Но в конце концов, вы будете использовать другие библиотеки, которые работают на более высоком уровне, например Tensorflow и Scikit – Учите Отказ Эти библиотеки содержат функции обучения на машине, такие как алгоритмы обучения и вывода. Посмотрите на них после прочтения этого руководства.

Если вы введете математические области, которые не рядом с линейной алгеброй, вы можете захотеть сдвинуть фокус на другие библиотеки, которые лучше удовлетворить ваши потребности. Примеры – это Матплотлиб и Pyqtgraph Отказ

В любом случае Numpy поможет вам понять более продвинутые библиотеки. Чтобы быть Фрэнком, у меня были проблемы, находящиеся ограничения Numpy. Поиск в Интернете – вы не найдете много людей, жалующихся на Numpy. Вот что мой поиск Google выявил – простите мой французский

Ничего я не могу добавить к этому.

Какие основы линейной алгебры вам нужно знать?

Numpy – это все о манипулирующих массивах. Узнав Numpy, вы также узнаете и обновите свой Линейная алгебра навыки из школы. Только если у вас очень мало знаний о линейной алгебре, вы должны работать через быстрый учебник перед погружением в Numpy Library. Всегда лучше изучать концепции сначала и инструменты позже. Numpy – это только конкретный инструмент, который реализует концепции линейной алгебры.

Посмотрите этот удивительный учебник из Ханской академии. Это даст вам быстрее в линейную алгебру и матричные операции.

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

В центре линейной алгебры выделяется решение линейных уравнений. Вот один из этих уравнений:

y = 2x + 4

Если вы затерете это уравнение, вы получите следующий выход:

Как видите, уравнение + 4 приводит к прямой линии в пространстве. Эта линия помогает вам читать для любого ввода x соответствующий выход Y.

Позвольте мне повторить это: вы можете получить для любого ввода x соответствующий выход Y.

Как оказывается, это цель любого технике обучения машины. У вас есть куча значений данных. Вы находите функцию, которая описывает эту кучу значений данных. (Мы называем это этапом обучения .) Теперь вы можете использовать научную функцию для «прогнозирования» выходного значения для любого нового входного значения. Это работает, даже если вы никогда не видели этот ввод раньше. (Мы называем это Фаза вывода .)

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

Вот пример с некоторыми поддельными данными. Скажем, вы узнали отношения между работой этикой (в количестве часов работали в день) и почасовой заработной плате (в долларах США). Ваши изученные отношения (в условиях обучения машины: Модель ) – это вышеуказанное уравнение + 4. Вход X – это количество часов, работающих в день, а выход Y – почасое.

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

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

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0., 10., 1)
# [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

y = 2 * x + 4
# [ 4.  6.  8. 10. 12. 14. 16. 18. 20. 22.]

print(x)
print(y)

# xkcd-styled plot
plt.xkcd()

plt.plot(x, y, 'x-')
plt.xlabel("Working time (h)")
plt.ylabel("Earnings per hour ($)")
plt.ylim((0,30))

plt.tight_layout()
plt.savefig("simple_linear_equation_example.jpg")
plt.show()

Как видите, прежде чем делать что-либо еще в скрипте, мы должны импортировать Numpy Library. Вы можете сделать это с утверждением « Импорт Numpy как NP ‘. Каждый раз, когда вы хотите вызвать функцию numpy, вы тогда используете префикс имени ‘ NP ‘(например np.average (x) ). Теоретически вы можете указать каждый другой префикс имени. Но вы не должны этого делать. Префикс ‘ NP «Кристаллизовано в качестве конвенции для имена Numpy Library, и поэтому каждый (более или менее) опытный кодер ожидает этого имени.

После этого первоначального импорта мы создаем серию значений с плавающей запятой от 0 до 9. Эти значения служат х Значения, которые мы хотим отображать их соответствующие функциональные значения y = f (x) Отказ Переменная х Удерживает мному массив этих значений с плавающей запятой.

Переменная y Удерживает множество такого же размера. Это наш выход – один для каждого наблюдается х стоимость. Вы видите основную арифметику того, как получить y значения?

Уравнение y * x + 4 кажется, делает то же самое, что обсуждалось в предыдущем уравнении. Но как получается, значение очень иное: х Это не числовое значение, это NaMpy Array!

При расчете y * x + 4 Мы в основном размножаем множество массива с 2 и добавляя константу 4 к нему. Это основные математические операции на многоразмерных (Numpy) массивов, а не числовых значений.

Исследование подобных операций лежит в ядре линейной алгебры. Объемный массив в примере называется одномерной матрицей (или вектором) плавающих значений. Матрица х состоит из десяти плавающих значений от 0 до 9 (включительно): [0. 1. 2. 3. 4. 5. 6. 6. 7. 8. 9.] Отказ Как мы знаем, что значения в массиве имеют тип поплавка типа? Мы указываем это, написав небольшую точку '.' После значения матрицы (это ничего, кроме короткой формы [0,0 1.0 2.0 ... 9.0] ).

Линейная алгебра Magic of Numpy рассчитывает соответствующую y значения. Затем мы замышляем результат, используя библиотеку Матплотлиб Отказ

В двухмерном пространстве, показанном на сюжете, мы работаем с одномерными массивами. Каждое числовое входное значение приводит к выходу. Одному наблюдению (например, »работал 4 часа в день« ) приводит к одному предсказанию (например, »заработал 12 долларов в час« ). Но реальные проблемы гораздо более сложны, чем это.

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

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

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

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

В графике четыре наблюдения (с тремя факторами для каждого наблюдения): [4, 4, 3], [3, 3, 0], [4, 1, 4], [2, 12, 1] – каждый из них является одномерная матрица. Мы собираем эти наблюдения в двумерной матрице наблюдения. Каждая строка этой матрицы состоит из одного наблюдения. Каждый столбец состоит из всех наблюдений в течение одного фактора. Например, первый ряд [4, 4, 3] Стенги за первое наблюдение: ,,]. Первый столбец [4, 3, 4, 2] обозначает все наблюдаемые значения фактора «опыта».

Теперь откройте нашу цель: мы хотим рассчитать заработную плату Y Value) на основе наблюдаемых факторов «», «и». Итак, давайте предположим, что волшебство Oracle (например, алгоритм машинного обучения) говорит нам, что вы можете рассчитать почасовую заработную плату Суммируя эти факторы: + x2 + x3. Например, первое наблюдение приводит к + x2 + + 4+. На простых английских: если у вас есть четыре года опыта, четыре года образования и 3 детей, вы заработаете 11 долларов в час.

Теперь, вместо использования численных значений, мы также можем использовать векторы фактора в виде X1, X2, и X3 – и уравнение все еще работает. Таким образом, вместо настройки, и, и вы можете установить x1 = [4, 3, 4, 2], x2 = [4, 3, 1, 12] и x3 = [3, 0, 4, 1]. Почему вы должны это сделать? Потому что это позволяет рассчитать прогнозы все наблюдения за одним шагом.

В каждом ряду мы рассчитываем прогноз одного человека. Каждая из операндов суммы – одномерная матрица (вектор). Когда мы рассчитываем сумму векторов (а не сумма численных значений), мы получаем результирующий вектор [11, 6, 9, 15], который содержит прогнозируемую почасовую заработную плату каждого из четырех человек.

На данный момент вы уже узнали, как и зачем добавлять векторы (или одномерные матрицы). Это позволяет компьютеру свернуть большое количество данных (и прогнозировать почасовую заработную плату для большого количества людей). Я хотел бы пойти более глубоко в эту тему, но я только что нашел прекрасную статью, которая научит вам линейную алгебру в визуально. Проверьте Этот удивительный артикул блог Для дальнейшего чтения на эту тему.

Что такое массивы и матрицы в Numpy?

Вы путаете о терминах матриц, массивов, векторов? Не отчаиваться. В Numpy есть только одна структура данных: Numpy массивы. Огночный массив может быть одномерным, двумерным или 1000-мерным. Это одна концепция, чтобы управлять их всеми.

В следующем видео я дам вам краткое и сладное введение в арифметику Numpy Artmay:

Массив NUMPY – это основной объект всей библиотеки. Вы должны знать его в сердце, прежде чем вы сможете продолжать и понимать операции, предоставляемые Numpy Bibly. Так что же такое Numpy Array?

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

Во-первых, все числовые значения имеют одинаковый тип данных. У многих Numpy Tutorials вы найдете заявление: «Обмочные массивы однородны». Это означает то же самое: Все значения имеют одинаковый тип Отказ В частности, это возможные типы данных Numpy Array:

  • Bool : По умолчанию Boolean тип данных в Python (1 байт).
  • int : Тип данных Python по умолчанию в Python (4 или 8 байта).
  • плавать Тип данных поплавка по умолчанию в Python (8 байт).
  • комплекс : Тип данных по умолчанию в Python (16 байт).
  • NP.int8 : Тип целочисленного типа (1 байт).
  • np.int16 : Тип целых данных (2 байта).
  • np.int32 : Целочисленный тип данных (4 байта).
  • np.int64 : Тип целых данных (8 байтов).
  • np.float16 : Тип данных поплавка (2 байта).
  • np.float32 : Тип данных поплавка (4 байта).
  • np.float64 : Тип данных поплавка (8 байтов).

Вот пример, который показывает, как создавать Numpy массивы разных типов данных.

import numpy as np

a = np.array([1, 2, 3], dtype=np.int16)
print(a) # [1 2 3]
print(a.dtype) # int16

b = np.array([1, 2, 3], dtype=np.float64)
print(b) # [1. 2. 3.]
print(b.dtype) # float64

В этом примере мы создали две массивы.

Первый массив А имеет тип данных np.int16 Отказ Если мы распечатаем массив, мы уже можем видеть, что числа имеют целое число типа (не существует «точка» после номера). В специфическом, при печати dtype Собственность массива А мы получаем результат Int16 Отказ

Второй массив B имеет тип данных float64 Отказ Так что даже если мы пройдем Список целых чисел В качестве функционального аргумента NUMPY преобразует тип на np.float64 Отказ

Вы должны помнить две вещи из этого примера:

  • 1) Numpy дает вам контроль о данных, а также
  • 2) Данные в Numpy Array однородны одинаковым типом).

Что такое оси и форма Numpy Array?

Второе ограничение Numpy массивов является следующим. Numpy не просто хранит кучу значений данных в свободной моде (вы можете использовать списки для этого). Вместо этого Numpy накладывает строгое упорядочение к данным – оно создает оси с фиксированными размерами. Не путайте ось с измерением.

💡 Точка в 3D-пространстве, например [1, 2, 3] имеет три размера, но только одну ось.

Так что такое ось в Numpy? Подумайте об этом как о глубине ваших вложенных данных. Если вы хотите узнать количество осей в Numpy, подсчитайте количество открытых кронштейнов «[» пока вы не достигнете первого численного значения. Вот пример:

import numpy as np

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

b = np.array([[1, 2], [2, 3], [3, 4]])
print(b.ndim)
# 2

c = np.array([[[1, 2], [2, 3], [3, 4]],
              [[1, 2], [2, 3], [3, 4]]])
print(c.ndim)
# 3

Мы создаем три выгодных массива А , B и C Отказ Для каждого массива мы Печать количество осей. Откуда нам это знать? Numpy хранит количество осей в свойстве массива NDIM Отказ Как видите, подсчет количества вложенных списков дает вам правильное количество осей вашего Numpy Array.

Но есть еще одна важная информация, которую вам часто нужно знать о вашем Numpy Array: Форма Отказ Форма дает вам не только количество осей, но и количество элементов в каждой оси (размерность).

Вот пример:

import numpy as np

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

b = np.array([[1, 2], [2, 3], [3, 4]])
print(b.shape)
# (3, 2)

c = np.array([[[1, 2], [2, 3], [3, 4]],
              [[1, 2], [2, 3], [3, 4]]])
print(c.shape)
# (2, 3, 2)

Изучите этот пример тщательно. Свойство Form дает вам три типа информации о каждом массиве.

Во-первых, он показывает, что количество осей за массив – то есть – длина кортежа. Numpy Array А имеет одну ось, Numpy Array B Имеет две оси и Numpy Array C имеет три оси.

Во-вторых, это показывает вам длину каждой оси в качестве численного значения. Например, массив А имеет одну ось с тремя элементами. Следовательно, форма массива – (3,) Отказ Не запутайтесь этим странным кортеж Обозначение. Причина, по которой операция Numpy Form не возвращает кортеж с одним элементом (3) Есть: Python преобразует его в числовое значение 3. Это имеет следующее преимущество. Если вы получаете доступ к первому элементу объекта вашей формы A.Shape [0] Переводчик этого способа не бросает исключение.

В-третьих, это показывает вам упорядочение осей. Рассмотрим массив C Отказ Имеет три ценности кортежей (2, 3, 2) Отказ Какое значение кортеж для какой оси?

  • Первая ценность кортежа – это количество элементов на первом уровне вложенных списков. Другими словами: сколько элементов в автономном списке? Внешний список для C представляет собой [X1, X2], где X1 и X2 являются Вложенные списки самих себя. Следовательно, первая ось состоит из двух элементов.
  • Но какое количество элементов для второй оси? Давайте проверим ось X1. Он имеет форму x1 = [y1, y2, y3] где y1, y2 и y3 – это перечислены сами. Поскольку есть три таких элемента, результат 3 для второго значения кортежа.
  • Наконец, вы проверяете внутреннюю ось Y1. Он состоит из двух элементов [1, 2], поэтому есть два элемента для третьей оси.

💡 Таким образом, оси упорядочены от самого самого внутреннего уровня гнездования. Количество осей хранится в NDIM свойство. Свойство Form показывает вам количество элементов в каждой оси.

Как создавать и инициализировать Numpy массивы?

Существует много способов создания и инициализации Numpy массивов. Вы уже видели некоторые из них в предыдущих примерах. Но самый простой способ создать Numpy Array – это функция np.array (ы) Отказ Вы просто положите в последовательность S однородных численных значений и Voilà – вы получаете свой Numpy Array.

Вот пример:

import numpy as np


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

b = np.array((1, 2, 3))
print(b)
# [1 2 3]

c = np.array([1.0, 2.0, 3.0])
print(c)
# [1. 2. 3.]

В примере мы создаем три массивы А , B и C Отказ Аргумент последовательности для массива А это Список целочисленных ценностей. Аргумент последовательности для массива B это кортеж целочисленных ценностей. Оба дают один и тот же Numpy Array целочисленных значений. Аргумент последовательности для массива C представляет собой список плавает Отказ Как видите, результатом является множественным массивом плавающих значений.

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

Вот пример:

import numpy as np


# 2D numpy array
a = np.array([[1, 2, 3], [4, 5, 6]]) 
print(a.shape)

# 3D numpy array
b = np.array([[[1, 2], [3, 4], [5, 6]],
              [[1, 2], [3, 4], [5, 6]]])
print(b.shape)

Головоломка: что такое выход этого кода фрагмент?

Ответ : Головоломка печатает две формы объекты. Форма массива А это (2, 3) Поскольку первая ось имеет два элемента, а вторая ось имеет три элемента. Форма массива B это (2, 3, 2 ) Поскольку первая ось имеет два элемента (последовательности последовательностей), вторая ось имеет три элемента (последовательности), а третья ось имеет два элемента (целые числа).

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

import numpy as np


a = np.array([[1, 2, 3.0], [4, 5, 6]])
print(a)
# [[1. 2. 3.]
#  [4. 5. 6.]]

Теперь давайте перейдем к более автоматическим способам создания Numpy Armays. Для приведенных выше примеров игрушек вы можете просто ввести весь массив. Но что, если вы хотите создать огромные массивы с тысячами ценностей?

Вы можете использовать процедуры создания массива Numpy, называемые Они (форма) и Zeros (Форма) Отказ

Все, что вам нужно сделать, это указать кортеж формы, которую вы видели в последних абзацах. Предположим, вы хотите получить 5-мерный массив с 1000 значений на размерность, инициализированные значениями 0,0. Используя эти процедуры, вы просто звоните: NP.ZEROS ((1000, 1000, 1000, 1000, 1000)) Отказ Давайте не будем распечатать это в оболочку! 😉.

Как оказывается, это простое простые процедуры создания массива перегружается в память вашего компьютера. Переводчик Python бросает ошибку при попытке создать Numpy Array этого размера. Почему? Потому что вы сказали ему создать 1000 * 1000 * 1000 * 1000 *** 15 или 1000 триллионов (!) Целых номеров. Это Проклятие высокой размерности !

В любом случае, вот примеры того, как создать Numpy массивы с помощью функций из них () и Zeros () Отказ

a = np.zeros((10, 10, 10, 10, 10))
print(a.shape)
# (10, 10, 10, 10, 10)

b = np.zeros((2,3))
print(b)
# [[0. 0. 0.]
#  [0. 0. 0.]]

c = np.ones((3, 2, 2))
print(c)
# [[[1. 1.]
#   [1. 1.]]
#
# [[1. 1.]
#  [1. 1.]]
#
# [[1. 1.]
#  [1. 1.]]]

print(c.dtype)
# float64

Вы можете видеть, что типы данных неявно преобразуются в плавать. Номера с плавающей запятой являются типом данных NUMPY по умолчанию (на моем компьютере: the np.float64 тип). Но что, если вы хотите создать Numpy Array целочисленных значений? Вы можете указать тип данных NaMpy Array в качестве второго аргумента для из них () или Zeros () Функции. Вот пример:

import numpy as np


a = np.zeros((2,3), dtype=np.int16)
print(a)
# [[0 0 0]
#  [0 0 0]]

print(a.dtype)
# int16

Наконец, есть один способ создания Numpy массивов, которые также очень распространены: Numpy arange функция. Я написал Вся статья о функции Arange – Проверьте это, чтобы выкопать глубже в создание массива в Numpy!

Если вы предпочитаете видео, быстро посмотрите на мое видео из этого блога:

💡 Вот быстрое резюме NP.Arge () : Функция numpy NP.Arge (запуск [, остановить [, шаг]) Создает новую Numpy Array с равномерно расположенным номером между Начать (включено) и Стоп (эксклюзив) с данным шаг размер. Например, NP.Arge (1, 6, 2) Создает Numpy Array [1 3 5] Отказ

Следующий подробный пример показывает, как это сделать:

import numpy as np


a = np.arange(2, 10)
print(a)
# [2 3 4 5 6 7 8 9]

b = np.arange(2, 10, 2)
print(b)
# [2 4 6 8]

c = np.arange(2, 10, 2, dtype=np.float64)
print(c)
# [2. 4. 6. 8.]

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

Но имейте в виду следующее. Если вы хотите создать равномерно разнесенную последовательность поплавковых значений в определенном интервале, не используйте функцию Numpy Arand. Документация препятствует этому, потому что это ненадлежащее обращение с границами. Вместо этого Официальное обслуживание Numpy рекомендует использовать Numpy Linspace () функция вместо этого.

💡 np.linspace () Функция работает как NP.Arge () функция. Но есть одно важное отличие: вместо определения размера шага вы определяете количество элементов в интервале между значениями запуска и остановки.

Вот пример:

import numpy as np


a = np.linspace(0.5, 9.5, 10)
print(a)
# [0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5]

b = np.linspace(0.5, 9.5, 5)
print(b)
# [0.5  2.75 5.   7.25 9.5 ]

Это все, что вам нужно знать о создании массива, чтобы начать работу с Numpy.

Если вы чувствуете, что вы освоили процедуры создания массива, перейдите к следующей важной теме в Numpy Numpy Python.

Как работает индексация и нарезка в Python?

Индексирование и нарезка в Numpy очень похожи на индексацию и нарезку в Python. Если вы освоили нарезку в Python, понимание нарезки в Numpy легко.

С этой целью я написал самую всеобъемлющую электронную книгу нарезки «Нарезание для кофе-брейки Python».

В следующих абзацах вы получите короткое введение в индексацию в Python. После этого я скоро объясню нарезку в Python. Поняв индексацию и нарезка в Python, вы тогда узнаете о индексировании и нарезке в Numpy.

Давайте посмотрим на пример объяснить индексацию в Python. Предположим, у нас есть строка «Вселенная» Отказ Индексы – это просто позиции персонажей этой строки.

Показатель 0 1 2 3 4 5 6 7
Персонаж u n i v e r s e

Первый символ имеет индекс 0, второй символ имеет индекс 1, а i-й символ имеет индекс I-1.

Теперь давайте погрузимся в нарезку в Python.

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

Для нарезки используйте нотацию кронштейна с идентификаторами начальной и конечной позиции. Например, Слово [I: J] Возвращает подстроку, начиная с индекса Я (включая) и заканчивая индекс J (Исключенный).

Вы также можете пропустить идентификатор положения до или после нарезки толстой кишки. Это указывает на то, что среза начинается с первой или последней позиции соответственно. Например, Word [: I] + Word [I:] Возвращает ту же строку, что и слово Отказ

Вот пример.

x = 'universe'
print(x[2:4])

Результатом является строка «IV» Отказ Мы начинаем с персонажа на положении 2 (третий символ) и заканчиваем ломтик в положении 4 (исключен из среза).

Ради полноты, позвольте мне вскоре объяснить продвинутую нарезку обозначения [Пуск: конец: шаг] Отказ Единственное значение для предыдущей записи – это то, что вы также указываете размер шага. Например, выражение «Python» [: 5: 2] Возвращает каждый второй символ до четвертого символа, то есть строка «ВОМ» Отказ Смотрите следующий пример.

x = 'universe'
print(x[2::2])

Результатом является строка «IES» Отказ Вы начинаете от третьего символа (включенного) и выбираете каждый другой символ, пока не дойдете до конца строки.

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

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

1) Как пропустить показатели нарезки (например, [:: 2])?

Переводчик Python предполагает определенные значения по умолчанию для S [Старт: Стоп: Шаг] Отказ Они: Start = 0 , Стоп = Лен (ы) и Шаг = 1 (На срезе ломтика: s [::] == s [0: Len (ы): 1] ).

2) Когда использовать однокольскую оборотную оболочку (E.g. S [:]), а когда двойная обозначение двоеточия (например, a.g. s [:: 2])?

Одна толстая кишка (например, S [1: 2] ) позволяет двумя аргументам, начало и конец индекса. Двойная толстая кишка (например, s [1: 2: 2] ) позволяет третьим аргументам, индекс запуска, конце индекс и размер шага. Если размер шага установлен на значение 1 по умолчанию 1, мы можем использовать однокольскую обозначение для краткости.

3) Что означает отрицательный размер шага (например, [5: 1: -1])?

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

4) Какие индексы по умолчанию при использовании отрицательного размера шага (например, [:: – 1])?

В этом случае индексы по умолчанию не являются Start = 0 и конец = ЛЕН (S) Но наоборот: start = len (s) -1 и End = -1 Отказ Обратите внимание, что индекс запуска все еще включен, и конечный индекс по-прежнему исключен из среза. Из-за этого индекс конца по умолчанию –1, а не 0.

5) Как работает список нарезки?

Нарезка работает то же самое для всех типов последовательностей. Для списков рассмотрим следующий пример:

l = [1, 2, 3, 4]
print(l[2:])
# [3, 4]

Нарезка кортежей работает аналогичным образом.

6) Почему последний индекс исключен из ломтика?

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

customer_name = 'Hubert'
k = 3 # maximal size of database entry
x = 1 # offset
db_name = customer_name[x:x+k]

Теперь предположим, что конечный индекс будет включен. В этом случае общая длина db_name Подстрока будет K + 1 символов. Это было бы очень противоборбительным.

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

Связанная статья: Введение в нарезку в Python

Как работает индексация и нарезка в Numpy?

В Numpy вы должны дифференцировать между одномерными массивами и многомерными массивами, поскольку нарезка работает по-разному для обоих.

💡 Одномерные насыпные массивы аналогичны численным спискам в Python, поэтому вы можете использовать Slicing в NUMPY, так как вы используете нарезку для списков.

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

import numpy as np


a = np.arange(0, 10)
print(a)
# [0 1 2 3 4 5 6 7 8 9]

print(a[:])
# [0 1 2 3 4 5 6 7 8 9]

print(a[1:])
# [1 2 3 4 5 6 7 8 9]

print(a[1:3])
# [1 2]

print(a[1:-1])
# [1 2 3 4 5 6 7 8]

print(a[::2])
# [0 2 4 6 8]

print(a[1::2])
# [1 3 5 7 9]

print(a[::-1])
# [9 8 7 6 5 4 3 2 1 0]

print(a[:1:-2])
# [9 7 5 3]

print(a[-1:1:-2])
# [9 7 5 3]

Я хочу выделить последние два примера здесь. Вы действительно поняли, почему А [-1: 1: -2] точно так же, как А [: 1: -2] ? Если вы прочитали последний раздел о нарезке Python, вы можете вспомнить, что индекс запуска по умолчанию для отрицательных размеров шагов –1.

Но в отличие от регулярного нарезка, Numpy немного более мощный. Смотрите следующий пример того, как Numpy обрабатывает присвоение значения до расширенного среза.

import numpy as np


l = list(range(10))
l[::2] = 999
# Throws error --> assign iterable to extended slice


a = np.arange(10)
a[::2] = 999
print(a)
# [999   1 999   3 999   5 999   7 999   9]

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

Давайте перейдем к Многомерные ломтики Отказ

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

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

import numpy as np


a = np.arange(16)
a = a.reshape((4,4))
print(a)
# [ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]
# [12 13 14 15]]

print(a[:, 1])
# Second column:
# [ 1  5  9 13]

print(a[1, :])
# Second row:
# [4 5 6 7]

print(a[1, ::2])
# Second row, every other element
# [4 6]

print(a[:, :-1])
# All columns except last one
# [[ 0  1  2]
# [ 4  5  6]
# [ 8  9 10]
# [12 13 14]]

print(a[:-1])
# Same as a[:-1, :]
# [[ 0  1  2  3]
# [ 4  5  6  7]
# [ 8  9 10 11]]

Как вы можете видеть в приведенных выше примерах, нарезка многомерных множественных массивов легко – если вы знаете, что Numpy Armays и как нарезать их. Самая важная информация, чтобы помнить, что Вы можете нарезать каждую ось отдельно Отказ Если вы не укажете обозначение среза для определенной оси, интерпретатор применяет нарезку по умолчанию (то есть, толстой кишки:).

Я буду пропустить подробное объяснение Numpy Dot Notiator – просто знаю, что вы можете «заполнить» оставшиеся колонты нарезки по умолчанию, используя три точки. Вот пример:

import numpy as np


a = np.arange(3**3)
a = a.reshape((3, 3, 3))
print(a)
##[[[ 0  1  2]
##  [ 3  4  5]
##  [ 6  7  8]]
##
## [[ 9 10 11]
##  [12 13 14]
##  [15 16 17]]
##
## [[18 19 20]
##  [21 22 23]
##  [24 25 26]]]


print(a[0, ..., 0])
# Select the first element of axis 0
# and the first element of axis 2. Keep the rest.
# [0 3 6]
# Equal to a[0, :, 0]

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

Вместо того, чтобы определять кусок, чтобы вырезать последовательность элементов из оси, вы можете выбрать произвольную комбинацию элементов из множества. Как? Просто укажите логический массив точно такой же формы. Если логическое значение в позиции (Я, j) это Правда Элемент будет выбран, в противном случае нет. Так просто. Вот пример.

import numpy as np


a = np.arange(9)
a = a.reshape((3,3))
print(a)
# [[0 1 2]
# [3 4 5]
# [6 7 8]]

b = np.array(
    [[ True, False, False],
     [ False, True, False],
     [ False, False, True]])
print(a[b])
# Flattened array with selected values from a
# [0 4 8]

Матрица B С формой (3,3) является параметром схемы индексации. Красивая, не так ли?

Позвольте мне выделить важную деталь. В примере вы выбираете произвольное количество элементов из разных осей. Как должен решить переводчик Python, чтобы решить об окончательной форме? Например, вы можете выбрать четыре ряда для столбца 0, но только 2 строки для столбца 1 – какая здесь форма? Существует только одно решение: результат этой операции должен быть одномерным множеством.

Если вам нужно иметь другую форму, не стесняйтесь использовать np.reeshape () Операция, чтобы вернуть свой Numpy Array обратно в ваш предпочтительный формат.

Куда пойти отсюда?

Поздравляем, вы сделали это через это массивное обслуживание Numpy. Это один из самых больших номеров Numpy в Интернете. Овладение Numpy Biate Python – это критический шаг на вашем пути, чтобы стать лучшим кодером Python и приобретение ваших навыков науки и машинного обучения. Ваше инвестированное время, работающее через этот учебник, амортизирует сотни в течение вашей карьеры.

Мой друг, и я в настоящее время пишу нетрадиционным Numpy TextBook, который уточняет ваши навыки Numpy. В книге мы используем научно проверенный метод обучения: обучение на основе головоломки. Метод Super Simple: вы ничего не делаете, кроме головоломки Numpy Code, и сравните ваше решение против правильного. Этот простой способ достаточно мощный, чтобы катапультировать уровень навыка на продвинутый уровень.

Книга отличается двумя способами. Во-первых, вы улучшите свое быструю навыку понимания Numpy (если вы посмотрите на NUMPY код, вы сможете прочитать и быстро понимать его). Во-вторых, вы проверите свои навыки понимания кода. В результате вы получите номер рейтинга, который отражает ваши навыки Numpy Coding, которые могут помочь вам в качестве основы для дальнейших улучшений.

Вы хотите книгу? Зарегистрируйтесь для моего списка электронного письма, чтобы получить обновления. Вы не пожалеете, зарегистрировавшись. Я обещаю. После регистрации вы улучшите свои навыки Python на Autopilot, потому что я отправлю вам 5 чис-листов Python и бесконечный поток питовых питонов. Итак, вы узнаете много во время ожидания уведомлений о книге. 😉.

Редактировать: Numpy Cook наконец опубликована!

Работая в качестве исследователя в распределенных системах, доктор Кристиан Майер нашел свою любовь к учению студентов компьютерных наук.

Чтобы помочь студентам достичь более высоких уровней успеха Python, он основал сайт программирования образования Finxter.com Отказ Он автор популярной книги программирования Python One-listers (Nostarch 2020), Coauthor of Кофе-брейк Python Серия самооставленных книг, энтузиаста компьютерных наук, Фрилансера и владелец одного из лучших 10 крупнейших Питон блоги по всему миру.

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