Как установить namba python windows

Python — Введение в программирование с помощью SciPy для разработчиков на C#

Формального определения термина науки о данных (data science) не существует, но я рассматриваю его как применение ПО для анализа данных с использованием классических метод статистики и алгоритмов машинного обучения. До недавнего времени большая часть анализа данных выполнялась с помощью дорогостоящих коммерческих продуктов, но в последние несколько лет значительно увеличилось использование альтернативного ПО с открытым исходным кодом.

По итогам бесед со своими коллегами, могу сказать, что имеется три наиболее распространенных подхода к анализу в науке о данных с применением ПО с открытым исходным кодом: язык R, язык Python в комбинации с библиотекой SciPy («scientific Python») и интегрированные языковые и исполняющие среды вроде SciLab и Octave.

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

По моему мнению, самая трудная часть в освоении нового языка программирования или технологии — начало работы с ним, поэтому я подробно опишу, как установить (и удалить) ПО, необходимое для выполнения SciPy-программы. Затем я расскажу о нескольких способах редактирования и запуска SciPy-программы и поясню, почему я предпочитаю использовать программу Integrated Development Environment (IDLE).

В заключение мы подробно разберем типичную программу, которая использует SciPy для решения системы линейных уравнений, чтобы продемонстрировать схожесть с программированием на C# и отличия от него. На рис. 1 показан вывод демонстрационной программы — он даст вам представление, о чем пойдет речь в этой статье.

Вывод типичной SciPy-программы

Рис. 1. Вывод типичной SciPy-программы

Установка стека SciPy

Стек SciPy состоит из трех компонентов: Python, NumPy и SciPy. Язык Python имеет базовые средства, такие как управляющие структуры наподобие цикла while, универсальный тип данных list, но, что интересно, отсутствует встроенный тип «массив». Библиотека NumPy добавляет поддержку массивов и матриц плюс некоторые сравнительно простые функции, например для поиска в массиве и его сортировки. Библиотека SciPy добавляет сложные функции, работающие с данными, которые хранятся в массивах и матрицах.

Чтобы выполнить SciPy-программу (с технической точки зрения, это скрипт, поскольку Python является интерпретируемым, а не компилируемым языком), нужно установить Python, затем NumPy, потом SciPy. Установка не особо сложна, и вы можете установить программный пакет, включающий все три компонента. Один из популярных пакетов — дистрибутив Anaconda, который поддерживается Continuum Analytics на сайте continuum.io. Однако я покажу, как установить эти компоненты индивидуально.

Python поддерживается почти всеми версиями Windows. Чтобы установить Python, отправляйтесь по ссылке python.org/downloads, где вам предложат на выбор Python либо версии 3.x, либо версии 2.x (рис. 2). Эти две версии не полностью совместимы, но библиотеки NumPy и SciPy поддерживают обеими версиями. Я предлагаю установить версию 2.x, поскольку существуют некоторые сторонние функции, пока не поддерживаемые в версии 3.x.

Установка Python

Рис. 2. УстановкаPython

Щелкнув кнопку Download, вы должны выбрать между немедленным запуском пакета .msi программы установки и его сохранением для последующего запуска. Можете щелкнуть кнопку Run. Установщик использует мастер. На первом экране будет запрос, хотите ли вы установить пакет для всех пользователей или только для текущего пользователя. По умолчанию установка происходит для всех пользователей, так что щелкните Next.

На следующем экране вас попросят указать корневой каталог установки. По умолчанию — это C:\Python27 (а не более привычный каталог C:\Program Files), и я предлагаю использовать вариант по умолчанию, щелкнув Next. Следующий экран позволяет включать или исключать различные компоненты вроде документации и утилит, таких как pip (аббревиатура «pip installs Python»). Компоненты Python по умолчанию отлично подходят, так что вновь щелкните Next.

Начнется установка, и вы увидите окно с привычной синей полоской прогресса. По окончании установки появится окно с кнопкой Finish — щелкните ее.

По умолчанию процесс установки Python не модифицирует переменную окружения PATH. Вы захотите добавить в эту переменную C:\Python27, C:\Python27\Scripts и C:\Python27\Lib\idlelib, чтобы у вас была возможность запускать Python из командной оболочки и использовать редактор IDLE без необходимости перехода в соответствующие каталоги.

Вы должны удостовериться, что Python установлен правильно. Запустите командную оболочку и перейдите в корневой каталог своей системы, введя команду cd \. Теперь введите команду python — version (обратите внимание на два символа-дефиса). Если Python отвечает, он установлен правильно.

Установка NumPy и SciPy

Пакеты NumPy и SciPy можно установить из исходного кода с помощью утилиты pip в Python. Подход с pip хорошо работает для пакетов, содержащих чистый код на Python, но NumPy и SciPy имеют точки подключения (hooks) к скомпилированному коду на языке C, поэтому установить их через pip не так-то просто.

К счастью, члены сообщества Python создали заранее скомпилированные в двоичный код установщики для NumPy и SciPy. Я рекомендую задействовать тот, который поддерживается в репозитарии SourceForge. Чтобы установить NumPy, перейдите по ссылке bit.ly/1Q3mo4M, где вы увидите ссылки на разные версии. Советую использовать самую свежую версию, которая скачивается чаще всего.

Вы увидите список ссылок. Найдите ссылку с именем, напоминающим numpy-1.10.2-win32-superpack-python2.7.exe, как показано на рис. 3. Убедитесь, что исполняемый файл соответствует вашей версии Python, и щелкните эту ссылку. После короткой паузы вам будет предложено сразу же запустить самораспаковывающийся исполняемый файл установщика или сохранить его для установки впоследствии. Щелкните кнопку Run.

Установка NumPy

Рис. 3. УстановкаNumPy

Установщик NumPy использует мастер. Первый экран просто отображает вводную заставку. Щелкните кнопку Next. На следующем экране вас попросят указать каталог установки. Установщик найдет существующий каталог установки Python и порекомендует установить NumPy в каталог C:\Python27\Lib\site-packages. Согласитесь и щелкните кнопку Next.

Следующий экран дает вам последний шанс выйти из процесса установки, но не делайте этого. Щелкните кнопкуNext. При установке появится окно с индикатором прогресса, и, если вы присмотритесь, вы заметите некоторые интересные сообщения, записываемые в журнал. При завершении установки NumPy станет доступна кнопка Finish — щелкните ее. Затем вы увидите последнее окно Setup Completed с кнопкой Close, которую и следует нажать.

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

После установки NumPy следующий шаг — установка пакета SciPy, и этот процесс идентичен таковому для NumPy. Перейдите по bit.ly/1QbwJ0z и найдите самый недавний, хорошо отработанный каталог. Перейдите в него и найдите ссылку на исполняемый файл с названием, похожим на scipy-0.16.1-win32-superpack-python2.7.exe, и щелкните его для запуска самораспаковывающегося установщика.

Одна из приятных особенностей стека SciPy состоит в том, что он позволяет очень легко удалять компоненты. Вы можете перейти в Windows Control Panel, Programs and Features, выбрать компонент (т. е. Python, NumPy или SciPy) для удаления, щелкнуть кнопку Uninstall, и компонент будет быстро и корректно удален.

Редактирование и запуск SciPy-программы

Если вы пишете программы, используя какой-либо .NET-язык, у вас не так много вариантов, и вы почти наверняка работаете в Visual Studio. Но при написании программы на Python вариантов уйма. Советую использовать редактор и исполняющую среду IDLE.

Файл запуска программы idle.bat по умолчанию находится в каталоге C:\Python27\Lib\idelib. Если вы добавили этот каталог в свою системную переменную окружения PATH, то можете запускать IDLE открытием командной оболочки и вводом команды idle. Это приведет к старту программы IDLE Python Shell, как показано в верхней части рис. 4.

Редактирование и запуск программы с использованием IDLE

Рис. 4. Редактирование и запуск программы с использованием IDLE

Вы можете создать новый файл исходного кода на Python, выбрав File | New File в строке меню. Появится похожее на предыдущее отдельное окно редактора, как показано в нижней части рис. 4. Наберите в окне редактора следующие семь выражений:

# test.py import numpy as np import scipy.misc as sm arr = np.array([1.0, 3.0, 5.0]) print arr n = sm.factorial(4) print "4! = " + str(n)

После этого сохраните свою программу как test.py в любом удобном для вас каталоге. Теперь вы можете запустить ее, выбрав Run | Run Module в окне редактора или нажав клавишу F5. Вывод программы будет отображаться в окне Python Shell. Элементарно!

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

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

C:\IntroToPython> python test.py

Это предполагает наличие пути к интерпретатору python.exe в вашей системной переменной окружения PATH. Вывод показывается в командной оболочке.

Существует много Python IDE. Одна из популярных IDE с открытым исходным кодом, которая специально предназначена для использования со SciPy, — программа Scientific Python Development Environment (Spyder). Вы найдете информацию о ней на pythonhosted.org/spyder.

Интересная альтернатива IDLE иSpyder — плагин Python Tools for Visual Studio (PTVS) с открытым исходным кодом. Как и предполагает его название, PTVS позволяет редактировать и выполнять программы Python с помощью Visual Studio. Информацию о PTVS см. на microsoft.github.io/PTVS.

Демонстрационная программа для SciPy

Взгляните на программу на Python (рис. 5) или, что еще лучше, наберите текст этой программы или откройте ее файл, который входит сопутствующий пакет кода для этой статьи, в редакторе Python и запустите ее. Демонстрационная программа не является исчерпывающим набором примеров SciPy, но дает хорошее представление о том, что такое программирование с применением SciPy.

Рис. 5. Типичная SciPy-программа

# linear_systems.py # Python 2.7 import numpy as np import scipy.linalg as spla def my_print(arr, cols, dec, nl): n = len(arr) fmt = "%." + str(dec) + "f" # like %.4f for i in xrange(n): # alt: for x in arr if i > 0 and i % cols == 0: print "" print fmt % arr[i], if nl == True: print "\n" def main(): print "\nBegin linear system using SciPy demo \n" print "Goal is to solve the system: \n" print "3x0 + 4x1 - 8x2 = 9" print "2x0 - 5x1 + 6x2 = 7" print " x0 + 9x1 - 7x2 = 3" print "" A = np.matrix([[3.0, 4.0, -8.0], [2.0, -5.0, 6.0], [1.0, 9.0, -7.0]]) b = np.array([9.0, 7.0, 3.0]) # b is an array b = np.reshape(b, (3,1)) # b is a col vector print "Matrix A is " print A print "" print "Array b is " my_print(b, b.size, 2, True) d = spla.det(A) if d == 0.0: print "Determinant of A is zero so no solution " else: Ai = spla.inv(A) print "Determinant of A is non-zero " print "Inverse of A is " print Ai print "" Aib = np.dot(Ai, b) print "A inverse times b is " print Aib print "" x = spla.solve(A, b) print "Using x = linalg.solve(A,b) gives x = " print x print "" try: A = np.array([[2.0, 4.0], [3.0, 6.0]]) print "Matrix A is " print A print "" print "Inverse of A is " Ai = spla.inv(A) print Ai except Exception, e: print "Fatal error: " + str(e) print "\nEnd SciPy demo \n" if __name__ == "__main__": main()

Демонстрационная программа начинается с двух строк комментариев:

# linear_systems.py # Python 2.7

Поскольку версии Python 2.x и 3.x не полностью совместимы, всегда неплохо явно указывать, какую версию Python вы используете. Далее демонстрация загружает весь модуль NumPy и один подмодуль SciPy:

import numpy as np import scipy.linalg as spla

Вы можете считать эти выражения чем-то похожим на то, как в программу на C# добавляется ссылка на Microsoft .NET Framework DLL, а затем эта сборка вводится в область видимости выражением using. Название подмодуля linalg расшифровывается как «linear algebra» (линейная алгебра). SciPy организован в 16 основных подмодулей и два вспомогательных.

Затем демонстрируется реализация определенной в программе функции для отображения массива:

def my_print(arr, cols, dec, nl): n = len(arr) fmt = "%." + str(dec) + "f" # like %.4f for i in xrange(n): # alt: for x in arr if i > 0 and i % cols == 0: print "" print fmt % arr[i], if nl == True: print "\n"

В Python блоки кода отделяются отступами, а не фигурными скобками. Здесь я использую два пробела в качестве отступа для экономии места; большинство программистов на Python применяет по четыре пробела в качестве отступа.

Функция my_print имеет четыре параметра: массив для отображения, количество столбцов для вывода значений, число десятичных разрядов для каждого значения и флаг, указывающий, надо ли перейти на новую строку. Функция len возвращает размер массива (число ячеек в нем). Альтернатива — задействовать свойство «размер массива»:

n = arr.size

Функция xrange возвращает итератор, и это стандартный способ перебора массива. Альтернатива — использовать шаблон «for x in arr», похожий на выражение foreach в C#.

При написании программы на Python вариантов уйма. Советую использовать редактор и исполняющую среду IDLE.

Поскольку корни как Python, так и C# уходят в язык C, большая часть синтаксиса Python знакома программистам на C#. В демонстрации % — это операция по модулю, но также используется для форматирования вывода значений с плавающей точкой и как логический оператор вместо &&; == — это проверка на равенство, а True и False (именно в таком написании) являются булевыми константами.

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

def main(): print "\nBegin linear system using SciPy demo \n" print "Goal is to solve the system: \n" print "3x0 + 4x1 - 8x2 = 9" print "2x0 - 5x1 + 6x2 = 7" print " x0 + 9x1 - 7x2 = 3"

Цель — найти значения переменных x0, x1 и x2, которые удовлетворяли бы всем трем уравнениям. Слово «main» не является ключевым в Python, так что его можно было бы использовать как угодно. Наличие некоей функции main не требуется. В коротких программах (обычно менее одной страницы кода) я, как правило, обхожусь без функции main и просто начинаю с исполняемых выражений.

Далее демонстрационная программа подготавливает задачу, помещая значения коэффициентов в NumPy-матрицу 3×3 с именем A и константы в NumPy-массив с именем b:

A = np.matrix([[3.0, 4.0, -8.0], [2.0, -5.0, 6.0], [1.0, 9.0, -7.0]]) b = np.array([9.0, 7.0, 3.0])

Здесь функции matrix и array на самом деле принимают в качестве аргументов списки Python (обозначаемые квадратными скобками) с «зашитыми» в код значениями. Кроме того, вы можете создавать матрицы и массивы, используя NumPy-функцию zeros, и считывать данные из текстового файла в массив или матрицу с помощью функции loadtxt.

Если вы изучали курс алгебры, то, вероятно, помните, что для решения системы уравнений Ax = b для x, где A — квадратная матрица коэффициентов и b — матрица-столбец констант (т. е. имеет n строк и только один столбец), нужно найти матрицу, обратную A, а затем выполнить матричное перемножение обратной матрицы и матрицы-столбца b.

К этому моменту в демонстрации b является массивом с тремя ячейками, а не матрицей-столбцом 3×1. Чтобы преобразовать b в матрицу-столбец, программа использует функцию reshape:

b = np.reshape(b, (3,1))

В библиотеке NumPy много функций, способных манипулировать массивами и матрицами. Например, функция flatten преобразует матрицу в массив. Теперь, как оказалось, SciPy-функция перемножения матриц достаточно интеллектуальна, чтобы логически определить ваши намерения, если вы перемножаете матрицу и массив, поэтому вызов reshape на самом деле здесь не требуется.

Идем дальше. Демонстрационная программа отображает значения в матрицах A и b:

print "Matrix A is " print A print "" print "Array b is " my_print(b, b.size, 2, True)

В Python 2.x print — это выражение, а не функция, как в Python 3.x, поэтому скобки не обязательны. Моя функция my_print не возвращает никакого значения, а значит, она эквивалентна void-функции из C# и вызывается так, как вы и ожидали. Python поддерживает вызовы с именованными параметрами, поэтому данный вызов мог бы выглядеть так:

my_print(arr=b, cols=3, dec=2, nl=True)

Демонстрационная программа находит матрицу, обратную для A:

d = spla.det(A) if d == 0.0: print "Determinant of A is zero so no solution " else: Ai = spla.inv(A) print "Determinant of A is non-zero " print "Inverse of A is " print Ai

SciPy-функция det возвращает детерминанту квадратной матрицы. Если матрица коэффициентов для системы линейных уравнений имеет детерминанту, равную нулю, эту матрицу нельзя обратить. Выражение if-else в Python должно быть знакомо вам. В Python есть изящное ключевое слово elif для управляющих конструкций if-else-if, например:

if n < 0: print "n is negative" elif n == 0: print "n equals zero" else: print "n is positive"

Некоторые опытные разработчики на Python критикуют IDLE за ее простоту. Но именно этим она мне и нравится.

Демонстрационная программа решает систему уравнений, используя перемножение матриц через NumPy-функцию dot:

Aib = np.dot(Ai, b) print "A inverse times b is " print Aib

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

После этого программа напрямую решает систему уравнений с помощью NumPy-функцииsolve:

x = spla.solve(A, b) print "Using x = linalg.solve(A,b) gives x = " print x

Многие функции SciPy и NumPy имеют необязательные параметры со значениями по умолчанию, что в какой-то мере эквивалентно перегрузке C#-метода. У SciPy-функции solve пять необязательных параметров. Смысл в том, что, когда вы видите пример вызова SciPy- или NumPy-функции и даже, как вам кажется, понимаете пример, всегда лучше заглянуть в документацию, чтобы выяснить, есть ли у нее какие-либо полезные необязательные параметры.

Библиотеки NumPy и SciPy отчасти перекрывают друг друга. Например, в пакете NumPy также есть подмодуль linalg, в котором имеется функция solve. Однако NumPy-функция solve не имеет никаких необязательных параметров.

Далее демонстрационная программа показывает пример механизма try-except в Python:

try: A = np.array([[2.0, 4.0], [3.0, 6.0]]) Ai = spla.inv(A) print Ai except Exception, e: print "Fatal error: " + str(e)

Этот шаблон должен выглядеть знакомым, если вы когда-нибудь использовали C#-выражения try-catch. В C# конкатенация строк может выполняться неявным образом. Например, в C# вы могли бы написать:

int n = 99; Console.WriteLine("The value of n is " + n);

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

n = 99 print "The value of n is " + str(n)

Демонстрационная программа завершается выражением print и особым заклинанием в Python:

print "\nEnd SciPy demo \n" if __name__ == "__main__": main()

В Python блоки кода отделяются отступами, а не фигурными скобками.

Последним выражением демонстрационной программы могло бы быть просто main(), что было бы интерпретировано как инструкция вызвать определенную в программе функцию main, и программа работала бы совершенно нормально. Добавление шаблона if __name__ == "__main__" (обратите внимание на два знака подчеркивания до и после как name, так и main) устанавливает текущий модель в качестве точки входа в программу. Когда программа на Python начинает выполнение, интерпретатор на внутреннем уровне помечает начальный модуль как:

"__main__"

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

Итак, к чему все это?

Вашей первой реакцией на эту статью вполне может быть следующее: «Что ж, все это даже интересно, но в своей повседневной работе мне не требуется решать системы линейных уравнений или использовать заумные математические функции». На это я ответил бы так: «Что ж, это правда, но, возможно, одна из причин, по которой вы не пользуетесь какой-то частью функциональности библиотеки SciPy, заключается в том, что не осознаете, какие типы задач вы можете решать».

Иначе говоря, по моему мнению, среди разработчиков прослеживается тенденция браться в основном за те задачи, для решения которых у них есть инструменты. Например, если вы знаете Windows Communication Foundation (WCF), то будете использовать WCF (и я вам сочувствую). А если вы добавите SciPy в свой личный арсенал, то, возможно, обнаружите, что у вас есть данные, которые можно превратить в полезную информацию.

Джеймс Маккафри*(Dr. James McCaffrey) работает на Microsoft Research в Редмонде (штат Вашингтон). Принимал участие в создании нескольких продуктов Microsoft, в том числе Internet Explorer и Bing. С ним можно связаться по адресу jammc@microsoft.com.*

Выражаю благодарность за рецензирование статьи экспертам Microsoft Дэну Либлингу (Dan Liebling) и Кирку Олинику (Kirk Olynyk).

NumPy в Python. Часть 1

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

Введение

NumPy это open-source модуль для python, который предоставляет общие математические и числовые операции в виде пре-скомпилированных, быстрых функций. Они объединяются в высокоуровневые пакеты. Они обеспечивают функционал, который можно сравнить с функционалом MatLab. NumPy (Numeric Python) предоставляет базовые методы для манипуляции с большими массивами и матрицами. SciPy (Scientific Python) расширяет функционал numpy огромной коллекцией полезных алгоритмов, таких как минимизация, преобразование Фурье, регрессия, и другие прикладные математические техники.

Установка

Если у вас есть Python(x, y) (Примечание переводчика: Python(x, y), это дистрибутив свободного научного и инженерного программного обеспечения для численных расчётов, анализа и визуализации данных на основе языка программирования Python и большого числа модулей (библиотек)) на платформе Windows, то вы готовы начинать. Если же нет, то после установки python, вам нужно установить пакеты самостоятельно, сначала NumPy потом SciPy. Установка доступна здесь. Следуйте установке на странице, там всё предельно понятно.

Немного дополнительной информации

Сообщество NumPy и SciPy поддерживает онлайн руководство, включающие гайды и туториалы, тут: docs.scipy.org/doc.

Импорт модуля numpy

Есть несколько путей импорта. Стандартный метод это — использовать простое выражение:

>>> import numpy

Тем не менее, для большого количества вызовов функций numpy, становится утомительно писать numpy.X снова и снова. Вместо этого намного легче сделать это так:

>>> import numpy as np

Это выражение позволяет нам получать доступ к numpy объектам используя np.X вместо numpy.X. Также можно импортировать numpy прямо в используемое пространство имен, чтобы вообще не использовать функции через точку, а вызывать их напрямую:

>>> from numpy import *

Однако, этот вариант не приветствуется в программировании на python, так как убирает некоторые полезные структуры, которые модуль предоставляет. До конца этого туториала мы будем использовать второй вариант импорта (import numpy as np).

Массивы

Главной особенностью numpy является объект array. Массивы схожи со списками в python, исключая тот факт, что элементы массива должны иметь одинаковый тип данных, как float и int. С массивами можно проводить числовые операции с большим объемом информации в разы быстрее и, главное, намного эффективнее чем со списками.

Создание массива из списка:

a = np.array([1, 4, 5, 8], float) >>> a array([ 1., 4., 5., 8.]) >>> type(a)

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

>>> a[:2] array([ 1., 4.]) >>> a[3] 8.0 >>> a[0] = 5. >>> a array([ 5., 4., 5., 8.])

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

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float) >>> a array([[ 1., 2., 3.], [ 4., 5., 6.]]) >>> a[0,0] 1.0 >>> a[0,1] 2.0

Array slicing работает с многомерными массивами аналогично, как и с одномерными, применяя каждый срез, как фильтр для установленного измерения. Используйте ":" в измерении для указывания использования всех элементов этого измерения:

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float) >>> a[1,:] array([ 4., 5., 6.]) >>> a[:,2] array([ 3., 6.]) >>> a[-1:, -2:] array([[ 5., 6.]])

Метод shape возвращает количество строк и столбцов в матрице:

>>> a.shape (2, 3)

Метод dtype возвращает тип переменных, хранящихся в массиве:

>>> a.dtype dtype('float64')

Тут float64, это числовой тип данных в numpy, который используется для хранения вещественных чисел двойной точности. Так же как float в Python.

Метод len возвращает длину первого измерения (оси):

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

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

>>> a = np.array([[1, 2, 3], [4, 5, 6]], float) >>> 2 in a True >>> 0 in a False

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

>>> a = np.array(range(10), float) >>> a array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) >>> a = a.reshape((5, 2)) >>> a array([[ 0., 1.], [ 2., 3.], [ 4., 5.], [ 6., 7.], [ 8., 9.]]) >>> a.shape (5, 2)

Обратите внимание, метод reshape создает новый массив, а не модифицирует оригинальный.

Имейте ввиду, связывание имен в python работает и с массивами. Метод copy используется для создания копии существующего массива в памяти:

>>> a = np.array([1, 2, 3], float) >>> b = a >>> c = a.copy() >>> a[0] = 0 >>> a array([0., 2., 3.]) >>> b array([0., 2., 3.]) >>> c array([1., 2., 3.])

Списки можно тоже создавать с массивов:

>>> a = np.array([1, 2, 3], float) >>> a.tolist() [1.0, 2.0, 3.0] >>> list(a) [1.0, 2.0, 3.0]

Можно также переконвертировать массив в бинарную строку (то есть, не human-readable форму). Используйте метод tostring для этого. Метод fromstring работает в для обратного преобразования. Эти операции иногда полезны для сохранения большого количества данных в файлах, которые могут быть считаны в будущем.

>>> a = array([1, 2, 3], float) >>> s = a.tostring() >>> s '\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@' >>> np.fromstring(s) array([ 1., 2., 3.])

Заполнение массива одинаковым значением.

>>> a = array([1, 2, 3], float) >>> a array([ 1., 2., 3.]) >>> a.fill(0) >>> a array([ 0., 0., 0.])

Транспонирование массивов также возможно, при этом создается новый массив:

>>> a = np.array(range(6), float).reshape((2, 3)) >>> a array([[ 0., 1., 2.], [ 3., 4., 5.]]) >>> a.transpose() array([[ 0., 3.], [ 1., 4.], [ 2., 5.]])

Многомерный массив можно переконвертировать в одномерный при помощи метода flatten:

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

Два или больше массивов можно сконкатенировать при помощи метода concatenate:

>>> a = np.array([1,2], float) >>> b = np.array([3,4,5,6], float) >>> c = np.array([7,8,9], float) >>> np.concatenate((a, b, c)) array([1., 2., 3., 4., 5., 6., 7., 8., 9.])

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

>>> a = np.array([[1, 2], [3, 4]], float) >>> b = np.array([[5, 6], [7,8]], float) >>> np.concatenate((a,b)) array([[ 1., 2.], [ 3., 4.], [ 5., 6.], [ 7., 8.]]) >>> np.concatenate((a,b), axis=0) array([[ 1., 2.], [ 3., 4.], [ 5., 6.], [ 7., 8.]]) >>> np.concatenate((a,b), axis=1) array([[ 1., 2., 5., 6.], [ 3., 4., 7., 8.]])

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

>>> a = np.array([1, 2, 3], float) >>> a array([1., 2., 3.]) >>> a[:,np.newaxis] array([[ 1.], [ 2.], [ 3.]]) >>> a[:,np.newaxis].shape (3,1) >>> b[np.newaxis,:] array([[ 1., 2., 3.]]) >>> b[np.newaxis,:].shape (1,3)

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

На этом у нас конец первой части перевода. Спасибо за внимание.

Введение в библиотеку pandas: установка и первые шаги / pd 1

Библиотека pandas в Python — это идеальный инструмент для тех, кто занимается анализом данных, используя для этого язык программирования Python.

В этом материале речь сначала пойдет об основных аспектах библиотеки и о том, как установить ее в систему. Потом вы познакомитесь с двумя структурам данных: series и dataframes . Сможете поработать с базовым набором функций, предоставленных библиотекой pandas, для выполнения основных операций по обработке. Знакомство с ними — ключевой навык для специалиста в этой сфере. Поэтому так важно перечитать материал до тех, пока он не станет понятен на 100%.

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

Библиотека Python для анализа данных

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

Библиотека была спроектирована и разработана преимущественно Уэсом Маккини в 2008 году. В 2012 к нему присоединился коллега Чан Шэ. Вместе они создали одну из самых используемых библиотек в сообществе Python.

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

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

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

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

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

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

Установка pandas

Простейший способ установки библиотеки pandas — использование собранного решения, то есть установка через Anaconda или Enthought.

Установка в Anaconda

В Anaconda установка занимает пару минут. В первую очередь нужно проверить, не установлен ли уже pandas, и если да, то какая это версия. Для этого введите следующую команду в терминале:

conda list pandas

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

# packages in environment at C:\Users\Fabio\Anaconda: # pandas 0.20.3 py36hce827b7_2

Если pandas не установлена, ее необходимо установить. Введите следующую команду:

conda install pandas

Anaconda тут же проверит все зависимости и установит дополнительные модули.

Solving environment: done ## Package Plan ## Environment location: C:\Users\Fabio\Anaconda3 added / updated specs: - pandas The following new packages will be installed: Pandas: 0.22.0-py36h6538335_0 Proceed ([y]/n)? Press the y key on your keyboard to continue the installation. Preparing transaction: done Verifying transaction: done Executing transaction: done

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

conda update pandas

Система проверит версию pandas и версию всех модулей, а затем предложит соответствующие обновления. Затем предложит перейти к обновлению.

Установка из PyPI

Pandas можно установить и с помощью PyPI, используя эту команду:

pip install pandas

Установка в Linux

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

В Debian и Ubuntu используется команда:

sudo apt-get install python-pandas

А для OpenSuse и Fedora — эта:

zypper in python-pandas

Установка из источника

Если есть желание скомпилировать модуль pandas из исходного кода, тогда его можно найти на GitHub по ссылке https://github.com/pandas-dev/pandas:

git clone git://github.com/pydata/pandas.git cd pandas python setup.py install

Убедитесь, что Cython установлен. Больше об этом способе можно прочесть в документации: (http://pandas.pydata.org/pandas-docs/stable/install.html).

Репозиторий для Windows

Если вы работаете в Windows и предпочитаете управлять пакетами так, чтобы всегда была установлена последняя версия, то существует ресурс, где всегда можно загрузить модули для Windows: Christoph Gohlke’s Python Extension Packages for Windows (www.lfd.uci.edu/~gohlke/pythonlibs/). Каждый модуль поставляется в формате WHL для 32 и 64-битных систем. Для установки нужно использовать приложение pip:

pip install SomePackage-1.0.whl

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

pip install pandas-0.22.0-cp36-cp36m-win_amd64.whl

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

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

Проверка установки pandas

Библиотека pandas может запустить проверку после установки для верификации управляющих элементов (документация утверждает, что тест покрывает 97% всего кода).

Во-первых, нужно убедиться, что установлен модуль nose . Если он имеется, то тестирование проводится с помощью следующей команды:

nosetests pandas

Оно займет несколько минут и в конце покажет список проблем.

Модуль Nose

Этот модуль спроектирован для проверки кода Python во время этапов разработки проекта или модуля Python. Он расширяет возможности модуль unittest . Nose используется для проверки кода и упрощает процесс.

Здесь о нем можно почитать подробнее: _http://pythontesting.net/framework/nose/nose-introduction/.

Первые шаги с pandas

Лучший способ начать знакомство с pandas — открыть консоль Python и вводить команды одна за одной. Таким образом вы познакомитесь со всеми функциями и структурами данных.

Более того, данные и функции, определенные здесь, будут работать и в примерах будущих материалов. Однако в конце каждого примера вы вольны экспериментировать с ними.

Для начала откройте терминал Python и импортируйте библиотеку pandas. Стандартная практика для импорта модуля pandas следующая:

>>> import pandas as pd >>> import numpy as np

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

>>> from pandas import *

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

Installation¶

Numba is compatible with Python 3.6 or later, and Numpy versions 1.15 or later.

Our supported platforms are:

Linux x86 (32-bit and 64-bit)
Linux ppcle64 (POWER8)
Windows 7 and later (32-bit and 64-bit)
OS X 10.9 and later (64-bit)
NVIDIA GPUs of compute capability 2.0 and later
AMD ROC dGPUs (linux only and not for AMD Carrizo or Kaveri APU)
ARMv7 (32-bit little-endian, such as Raspberry Pi 2 and 3)
ARMv8 (64-bit little-endian, such as the NVIDIA Jetson)

Automatic parallelization with @jit is only available on 64-bit platforms.

Installing using conda on x86/x86_64/POWER Platforms¶

The easiest way to install Numba and get updates is by using conda , a cross-platform package manager and software distribution maintained by Anaconda, Inc. You can either use Anaconda to get the full stack in one download, or Miniconda which will install the minimum packages required for a conda environment.

Once you have conda installed, just type:

$ conda install numba

$ conda update numba

Note that Numba, like Anaconda, only supports PPC in 64-bit little-endian mode.

To enable CUDA GPU support for Numba, install the latest graphics drivers from NVIDIA for your platform. (Note that the open source Nouveau drivers shipped by default with many Linux distributions do not support CUDA.) Then install the cudatoolkit package:

$ conda install cudatoolkit

You do not need to install the CUDA SDK from NVIDIA.

Installing using pip on x86/x86_64 Platforms¶

Binary wheels for Windows, Mac, and Linux are also available from PyPI. You can install Numba using pip :

$ pip install numba

This will download all of the needed dependencies as well. You do not need to have LLVM installed to use Numba (in fact, Numba will ignore all LLVM versions installed on the system) as the required components are bundled into the llvmlite wheel.

To use CUDA with Numba installed by pip , you need to install the CUDA SDK from NVIDIA. Please refer to Setting CUDA Installation Path for details. Numba can also detect CUDA libraries installed system-wide on Linux.

Enabling AMD ROCm GPU Support¶

The ROCm Platform allows GPU computing with AMD GPUs on Linux. To enable ROCm support in Numba, conda is required, so begin with an Anaconda or Miniconda installation with Numba 0.40 or later installed. Then:

Follow the ROCm installation instructions.
Install roctools conda package from the numba channel:

$ conda install -c numba roctools

See the roc-examples repository for sample notebooks.

Installing on Linux ARMv7 Platforms¶

Berryconda is a conda-based Python distribution for the Raspberry Pi. We are now uploading packages to the numba channel on Anaconda Cloud for 32-bit little-endian, ARMv7-based boards, which currently includes the Raspberry Pi 2 and 3, but not the Pi 1 or Zero. These can be installed using conda from the numba channel:

$ conda install -c numba numba

Berryconda and Numba may work on other Linux-based ARMv7 systems, but this has not been tested.

Installing on Linux ARMv8 (AArch64) Platforms¶

We build and test conda packages on the NVIDIA Jetson TX2, but they are likely to work for other AArch64 platforms. (Note that while the Raspberry Pi CPU is 64-bit, Raspbian runs it in 32-bit mode, so look at Installing on Linux ARMv7 Platforms instead.)

Conda-forge support for AArch64 is still quite experimental and packages are limited, but it does work enough for Numba to build and pass tests. To set up the environment:

Install conda4aarch64. This will create a minimal conda environment.
Add the c4aarch64 and conda-forge channels to your conda configuration:

$ conda config --add channels c4aarch64 $ conda config --add channels conda-forge

$ conda install -c numba numba

On CUDA-enabled systems, like the Jetson, the CUDA toolkit should be automatically detected in the environment.

Installing from source¶

Installing Numba from source is fairly straightforward (similar to other Python packages), but installing llvmlite can be quite challenging due to the need for a special LLVM build. If you are building from source for the purposes of Numba development, see Build environment for details on how to create a Numba development environment with conda.

If you are building Numba from source for other reasons, first follow the llvmlite installation guide. Once that is completed, you can download the latest Numba source code from Github:

$ git clone git://github.com/numba/numba.git

Source archives of the latest release can also be found on PyPI. In addition to llvmlite , you will also need:

A C compiler compatible with your Python installation. If you are using Anaconda, you can use the following conda packages:
- Linux x86 : gcc_linux-32 and gxx_linux-32
- Linux x86_64 : gcc_linux-64 and gxx_linux-64
- Linux POWER : gcc_linux-ppc64le and gxx_linux-ppc64le
- Linux ARM : no conda packages, use the system compiler
- Mac OSX: clang_osx-64 and clangxx_osx-64 or the system compiler at /usr/bin/clang (Mojave onwards)
- Windows: a version of Visual Studio appropriate for the Python version in use
Then you can build and install Numba from the top level of the source tree:
```
$ python setup.py install
```
Dependency List¶

Numba has numerous required and optional dependencies which additionally may vary with target operating system and hardware. The following lists them all (as of September 2019).
- Required build time:
  - setuptools
  - numpy
  - llvmlite
  - Compiler toolchain mentioned above
  - OpenMP C headers and runtime libraries compatible with the compiler toolchain mentioned above and accessible to the compiler via standard flags (Linux, Windows).
  - llvm-openmp (OSX) - provides headers for compiling OpenMP support into Numba’s threading backend
  - intel-openmp (OSX) - provides OpenMP library support for Numba’s threading backend.
  - tbb-devel - provides TBB headers/libraries for compiling TBB support into Numba’s threading backend
  - setuptools
  - numpy
  - llvmlite
  - scipy - provides cython bindings used in Numba’s np.linalg.* support
  - tbb - provides the TBB runtime libraries used by Numba’s TBB threading backend
  - jinja2 - for “pretty” type annotation output (HTML) via the numba CLI
  - cffi - permits use of CFFI bindings in Numba compiled functions
  - intel-openmp - (OSX) provides OpenMP library support for Numba’s OpenMP threading backend
  - ipython - if in use, caching will use IPython’s cache directories/caching still works
  - pyyaml - permits the use of a .numba_config.yaml file for storing per project configuration options
  - colorama - makes error message highlighting work
  - icc_rt - (numba channel) allows Numba to use Intel SVML for extra performance
  - pygments - for “pretty” type annotation
  - gdb as an executable on the $PATH - if you would like to use the gdb support
  - Compiler toolchain mentioned above, if you would like to use pycc for Ahead-of-Time (AOT) compilation
  - r2pipe - required for assembly CFG inspection.
  - radare2 as an executable on the $PATH - required for assembly CFG inspection. See here for information on obtaining and installing.
  - graphviz - for some CFG inspection functionality.
  - sphinx
  - pygments
  - sphinx_rtd_theme
  - numpydoc
  - make as an executable on the $PATH
  Checking your installation¶
  
  You should be able to import Numba from the Python prompt:
```
$ python Python 3.8.1 (default, Jan 8 2020, 16:15:59) [Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import numba >>> numba.__version__ '0.48.0'
```
  You can also try executing the numba --sysinfo (or numba -s for short) command to report information about your system capabilities. See Command line interface for further information.
```
$ numba -s System info: -------------------------------------------------------------------------------- __Time Stamp__ 2018-08-28 15:46:24.631054 __Hardware Information__ Machine : x86_64 CPU Name : haswell CPU Features : aes avx avx2 bmi bmi2 cmov cx16 f16c fma fsgsbase lzcnt mmx movbe pclmul popcnt rdrnd sse sse2 sse3 sse4.1 sse4.2 ssse3 xsave xsaveopt __OS Information__ Platform : Darwin-17.6.0-x86_64-i386-64bit Release : 17.6.0 System Name : Darwin Version : Darwin Kernel Version 17.6.0: Tue May 8 15:22:16 PDT 2018; root:xnu-4570.61.1~1/RELEASE_X86_64 OS specific info : 10.13.5 x86_64 __Python Information__ Python Compiler : GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final) Python Implementation : CPython Python Version : 2.7.15 Python Locale : en_US UTF-8 __LLVM information__ LLVM version : 6.0.0 __CUDA Information__ Found 1 CUDA devices id 0 GeForce GT 750M [SUPPORTED] compute capability: 3.0 pci device id: 0 pci bus id: 1
```
  (output truncated due to length)
  
  © Copyright 2012-2020, Anaconda, Inc. and others
  Похожие публикации: