Привет!

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

Моя цель — создать короткую статью-обзор, прочитав/просмотрев которую Вы будете примерно представлять весь спектр инструментов для работы с данными на языке Python. В основном упор будет сделан на обработку данных, но также будут упомянуты и другие библиотеки (web разработка, асинхронное программирование, принципы написания кода и т.д.), которые возможно пригодятся для выполнения поставленных перед Вами задач.

Если Вы ищите литературу по направлению Python или Power BI (разработка аналитических приложений), то загляните обязательно в мой Telegram канал @python_powerbi (пишу про разработку на Python, построение аналитических отчетов на Power BI)

Итак, приступим. Начнем с библиотек обработки данных.

Обзор библиотек Python для обработки данных, анализа и визуализации данных

• Numpy — это библиотека языка Python, которая позволяет работать с многомерными массивами и матрицами, в том числе внутри библиотеки есть большой выбор математических функций для выполнения операций над массивами и матрицами.
• Pandas — это библиотека для работы с данными, а именно для анализа данных, трансформации данных (обработки данных), загрузки данных из различных источников и сохранения данных в разных форматах как в файловую систему, так и в базу данных. В качестве структуры данных используется Pandas DataFrame или Pandas Series.
• pyodbc — это Python модуль/библиотека, драйвер для подключения к базе данных через ODBC.
• pymssql — это библиотека Python для подключения к базе данных на MSSQL (но можно использовать и pyodbc).
• SQLAlchemy — это очень популярная библиотека Python для работы с реляционными СУБД для выполнения SQL или для использования технологии ORM (Object-Relational Mapping или объектно-реляционное отображение). ORM необходим для объектно-ориентированных языков программирования. С помощью ORM классы могут быть сопоставлены с базой данных, что позволяет с самого начала четко связать объектную модель и схему базы данных.
• Alembic — это инструмент миграции баз данных, написанный автором SQLAlchemy. Также может использоваться для создания таблиц, их удаления, добавления или удаления полей таблиц.
• SciPy — это пакет прикладных математических процедур (или научных инструментов), основанный на расширении Numpy Python. Содержит модули для оптимизации, интегрирования, специальных функций, обработки сигналов, обработки изображений, генетических алгоритмов, решения обыкновенных дифференциальных уравнений и других задач, обычно решаемых в науке и при инженерной разработке.
• Plotly — это графическая библиотека Python (с открытым исходным кодом), с помощью которой можно создавать интерактивную визуализацию (scatter plots, box plots, 3D графики, bar charts, heatmaps, дендрограммы и т.д.). Если коротко, то эту библиотеку можно охарактеризовать как «Красочное интерактивное отображение датасета в одну строку».
• Dash — это передовой web‑фреймворк Python с открытым исходным кодом, предназначенный для создания реактивных веб-приложений / аналитических веб-приложений. С помощью Dash можно создать интерактивное приложения для аналитических отчетов и просматривать приложение в браузере, при этом не нужно использовать в приложении JavaScript или HTML. Для привязки пользовательского кода анализа данных к пользовательскому интерфейсу в Dash используется реактивный декоратор. С его помощью можно фильтровать DataFrame Pandas, выполнить SQL‑запрос, запустить расчет и т.д.
• Seaborn — это
• json — это модуль python, который позволяет кодировать и декодировать данные в удобном формате. Входит в стандартную библиотеку Python и является эффективным средством взаимодействия с JSON (JavaScript Object Notation).

Библиотеки Python для парсинга страниц web сайтов (Web Scraping) и работа с API сайтов

• Requests — это библиотека, с помощью которой можно отправлять все виды HTTP-запросов к различным ресурсам в сети интернет (сайты, API различных сервисов, поисковики). После выполнения запроса Вы получите ответ от сервера (данные, контент страницы сайта). По сути, с помощью этой библиотеки Вы можете автоматизировать обмен данными с такими ресурсами, как Yandex Метрика, Bitrix24, Мой Склад, Google Analytics, Google BigQuery, AmoCRM, Binance и др.
• Beautiful Soup — это библиотека Python, парсер для синтаксического разбора файлов HTML/XML. Может преобразовать даже неправильную разметку в дерево, состоящее из тегов, элементов, атрибутов и значений.
• Selenium — это это инструмент для автоматизации действий веб-браузера. В большинстве случаев используется для тестирования Web-приложений, но этим не ограничивается. Selenium представляет собой драйвер, который управляет поведением браузера. Состоит из нескольких продуктов: Selenium WebDriver, Selenium RC, Selenium Server, Selenium Grid, Selenium IDE.
• Lxml — это библиотека для парсинга сайтов и документов с разметкой XML и HTML. С её помощью можно разложить элементы документа/страницы в дерево. Обработка производится через XPath (язык запросов к элементам xml или html документа).
• Scrapy — это быстрый бесплатный фреймворк для веб-краулинга (веб-паук, поисковый робот, т.е. для работ по перебору страниц сайта и занесения информации в базу данных) или веб-скрейпинга (получение веб-данных путем извлечения их со страниц веб-ресурсов). С его помощью можно извлечь данные с веб-страниц сайтов с помощью селекторов на основе XPath.

Многопоточность, параллелизм, многопроцессорная обработка — библиотеки Python

В операционной системе существует два типа многозадачности:

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

• AsyncIO — это библиотека Python для написания параллельного кода. Библиотека asyncio позволяет вам писать код, который выглядит и чувствует себя синхронно, но работает асинхронно. Модуль asyncio предоставляет инфраструктуру для написания однопоточного параллельного кода с использованием сопрограмм, мультиплексирования доступа ввода-вывода через сокеты и другие ресурсы, запуска сетевых клиентов и серверов и других связанных примитивов.
• Threading — это стандартная библиотека Python, которая содержит необходимые классы для работы с потоками. Модуль threading значительно упрощает работу с потоками и позволяет программировать запуск нескольких задач одновременно. Python содержит Global Interpreter Lock (GIL), который запускает все потоки внутри главного потока. Если Вы запустите несколько интенсивных операций с потоками, то программа будет работать достаточно медленно, т.к. запуск потоков производится только на одном процессоре.
• Multiprocessing — это Модуль multiprocessing позволяет вам создавать процессы таким же образом, как при создании потоков при помощи модуля threading, но с помощью multiprocessing Вы сможете обойти GIL и использовать несколько процессоров на вашей вычислительной машине. Т.е. в рамках библиотеки multiprocessing Вы можете задействовать несколько процессоров для выполнения ваших операций.
• Aiohttp — это фреймворк для создания асинхронных HTTP Client и/или HTTP Server. Является HTTP-клиентом / сервером для asyncio.  Пакет aiohttp также поддерживает Server WebSockets и Client WebSockets.

Python Libraries / Инструменты для Machine Learning

• TensorFlow — это это комплексная платформа для машинного обучения с открытым исходным кодом. Основной объект — это тензор, или многомерный массив чисел. TensorFlow используется для создания многослойных нейронных сетей.
• Keras — это библиотека, позволяющая на более высоком уровне работать с нейросетями, упрощает код, увеличивает быстродействие. Изначально была разработана в целях ускорения экспериментов. Keras может запускаться поверх TensoFlow, Theano или CNTK. Этот фреймворк применяется для перевода, распознавании изображений, речи и т.п.
• Theano — это библиотека Python, которая используется для разработки систем Machine Learning (ML) и Artificial Intelligence (AI) как сама по себе, так и в качестве вычислительного backend для более высокоуровневых библиотек (например для Keras, Lasagne или Blocks). Библиотека построена поверх NumPy. Theano позволяет достигать больших скоростей, которые конкурируют с кодом C, написанным вручную, для задач, связанных с большими объемами данных. Theano компилируется на архитектурах CPU и GPU.
• Scikit-Learn — это инструмент для обработки изображений и имитации искусственного интеллекта. Библиотека построена на SciPy (Scientific Python). Библиотека Scikit-Learn использует в своей реализации NumPy массивы. Она предоставляет широкий выбор алгоритмов обучения с учителем и без учителя. В этой библиотеке находится большое количество алгоритмов для задач, связанных с классификацией и машинным обучением в целом.
• PyTorch — это machine learning framework или библиотека для решения задач с помощью машинного обучения, используется для приложений по обработке естественного языка. PyTorch считается Pythonic, т.е. плавно интегрируется со стеком данных Python. С помощью PyTorch можно построить динамический вычислительный граф. PyTorch сейчас используется в таких компаниях как Twitter, Facebook, NVIDIA и др. PyTorch создана на базе Torch (MATLAB-подобная библиотека для языка программирования Lua). Вокруг фреймворка PyTorch выстроена экосистема из различных библиотек: Fast.ai (упрощающая процесс обучения моделей), Pyro (модуль для вероятностного программирования от Uber), Flair (для обработки естественного языка) и Catalyst (для обучения DL и RL моделей).
• LightGBM (Light Gradient Boosted Machine) — это быстрая, распределенная, высокопроизводительная библиотека для повышения градиента, основанная на алгоритмах обучения на основе дерева решений. Используется для решения задач ранжирования, классификации, популярен для задач структурированного прогнозного моделирования, регрессия табличных данных и др. Разработана Microsoft. Справочно: Повышение градиента — это мощный алгоритм машинного обучения.
• XGBoost — это оптимизированная распределенная библиотека повышения градиента (GBM, GBRT, GBDT) с открытым исходным кодом. Доступна для языков программирования C++, Java, Python, R, Julia, Perl и Scala. Работает на Linux, Windows и macOS. Код работает в распределенной среде (Hadoop, SGE, MPI) и может решать проблемы с миллиардами примеров. В последнее время он приобрел большую популярность и внимание как алгоритм выбора для команд-победителей соревнований по машинному обучению.
• VowpalWabbit — это библиотека машинного обучения для онлайн интерактивного обучения, разработанная в Yahoo. К разработке и развитию подключилась команда Microsoft Research. Используются методы: online, hashing, allreduce, reductions, learning2search, active and interactive learning.
• CatBoost — это высокопроизводительная библиотека с открытым исходным кодом для повышения градиента в деревьях решений. Библиотека разработана компанией Яндекс, использует одну из оригинальных схем градиентного бустинга (boosting — улучшение). Библиотека является преемником алгоритма MatrixNet, который широко используется в компании для ранжирования задач, прогнозирования и выработки рекомендаций.
  
• Hyperopt — это библиотека, в которой реализован алгоритм оптимизации Tree-Structured Parzen Estimators (TPE). Используется байесовская оптимизация для настройки параметров модели.
• fastText — это бесплатная, легковесная библиотека с открытым исходным кодом, которая позволяет пользователям изучать текстовые представления и классификаторы текста. Инструмент поддерживает несколько языков, включая английский, немецкий, испанский, французский, чешский и русский. Библиотека разработана в лаборатории Facebook AI Research (FAIR).

Python Web Frameworks — Веб-Разработка сайтов, микросервисов. Обзор фреймворков

• Django — это фреймворк для веб-приложений, работающий на Python, считается лучшим web-framework на языке Python. Фреймворки облегчают процесс разработки и позволяют разработчикам не изобретать колесо (в Django есть набор компонентов, которые можно использовать в своем проекте), поэтому создание сайта на Django можно сравнить с конструктором Lego. Django подходит для разработки высоконагруженных веб-приложений. Django следует философии «все включено», Вам только нужно найти нужный компонент для той или иной задачи.
• Flask — это легковесный и гибкий фреймворк, который используется для создания веб-приложений на языке Python. Flask реализуется с минимальными надстройками, позволяет выбирать модули под конкретные задачи и устанавливать их по мере необходимости. Вы вправе самостоятельно решить, как стоит реализовать те или иные вещи в вашем проекте. Flask стоит выбрать, если необходима тонкая настройка проекта. Flask из-за своей гибкости лучше подходит для создания REST API.
• Tornado — это веб-фреймворк Python и асинхронная библиотека для NetWorking (сетей). Используя неблокирующий сетевой ввод/вывод (I/O), Tornado может масштабироваться до десятков тысяч открытых соединений, что делает его идеальным для веб-сервисов реального времени (например для длинных опросов или long polling, WebSockets, т.е. которые требуют долгого соединения с каждым пользователем). Был создан для использования в проекте FriendFeed, который в 2009 году приобрела компания Facebook. После этого исходный код этой библиотеки разместили в открытом доступе. Есть интеграция с Amazon S3. Есть реализация сторонних схем аутентификации и авторизации (Google OpenID / OAuth, Facebook, Yahoo BBAuth, FriendFeed OpenID/OAuth, Twitter OAuth).
• Pyramid — это это самый молодой web-фреймворк Python с открытым исходным кодом для веб-проектов среди других популярных frameworks. Pyramid очень похожа на Flask (мало усилий для установки и запуска). Pyramid хорошо себя проявляет как в небольших, так и в больших проектах.
• Bottle — это быстрый, простой и легкий микро-фреймворк Python для небольших веб-приложений. Включает в себя диспетчеризацию запросов (маршрутизацию) с поддержкой параметров URL, шаблоны, имеет встроенный HTTP-сервер и адаптеры для сторонних WSGI/HTTP-серверов. Протокол WSGI — стандарт взаимодействия между Python-программой, выполняющейся на стороне сервера, и самим веб-сервером, например, Apache.
• CherryPy — это минималистичный объектно-ориентированный веб-фреймворк с открытым исходным кодом на языке Python. Является Pythonic. Спроектирован для быстрой разработки веб-приложений, используя ООП. CherryPy может быть настроек, как самостоятельный веб-сервер, или может работать под управлением другого серверного приложения, которое поддерживает протокол WSGI. CherryPy имеет собственный совместимый с HTTP веб-сервер WSGI.

Фреймворки для разработки мобильных приложений, GUI Development

• Kivy — это кросс-платформенный фреймворк Python с открытым исходным кодом для быстрой разработки межплатформенных В дополнение к стандартному вводу через клавиатуру и мышь он поддерживает мультитач. Kivy работает на Linux, Windows, OS X, Android, iOS и Raspberry Pi. Графика создается через OpenGL ES 2, что приводит к равномерному появлению в разных операционных системах.
• PyQt5 / PyQt4 / PyQt — это это библиотека Python для разработки приложений с графическим интерфейсом пользователя GUI (создано на основе набора кроссплатформенных библиотек C++). Является одной из самых мощных библиотек GUI (более 600 классов, более 6000 функций и методов). Библиотека доступна для Python 2.x и 3.x. PyQt работает на всех платформах, поддерживаемых Qt: Linux и другие UNIX-подобные ОС, Mac OS X и Windows. Существует 2 версии: PyQt5, поддерживающий Qt 5, и PyQt4, поддерживающий Qt 4.
• Tkinter — это бесплатная кросс-платформенная графическая библиотека Python, которая позволяет создавать программы с оконным интерфейсом (стандратный модуль Python для создания приложений с GUI интерфейсом). Tkinter является кроссплатформенной библиотекой и может быть использована в большинстве распространённых операционных систем (Windows, Linux, Mac OS X и др.). Функционирует на основе средств Tk (широко распространённая в мире GNU/Linux и других UNIX‐подобных систем, портирована также и на Microsoft Windows).
• WxPython — это это бесплатная кросс-платформенная библиотека Python для разработки приложений GUI (Windows, Mac OS X, Linux), поставляется вместе с Python и является альтернативой Tkinter. Библиотека написана на C++. Реализовано на основе wxWidgets — инструмент разработчика для написания настольных или мобильных приложений с графическим интерфейсом (GUI).
• PyGUI — это
• PySide — это

Фреймворки Python для разработки API

• Marchmallow — это библиотека, независимая от ORM/ODM/Framework для преобразования сложных типов данных, таких как объекты, в простые типы данных Python, а также обратная операция. Наиболее распространенное использование Marshmallow — десериализация объекта JSON в объект Python или сериализация объекта Python в объект JSON для использования в веб-API. Marshmallow делает это путем определения схемы, которую можно использовать для применения правил проверки десериализации данных или изменения способа сериализации данных.
• OpenAPI = спецификация. OpenAPI — это официальное название спецификации. Разработка спецификации поддерживается инициативой OpenAPI, в которой участвуют более 30 организаций из разных областей технического мира, включая Microsoft, Google, IBM и CapitalOne. Smartbear Software, которая является компанией, которая возглавляет разработку инструментов Swagger, также является участником инициативы OpenAPI, помогая вести эволюцию спецификации.
• Swagger = Инструменты для реализации спецификации. Swagger — это имя, связанное с некоторыми из самых известных и широко используемых инструментов для реализации спецификации OpenAPI. Набор инструментов Swagger включает в себя набор открытых, бесплатных и коммерческих инструментов, которые можно использовать на разных этапах жизненного цикла API. Инструменты Swagger — не единственные инструменты, доступные для реализации спецификации OpenAPI. Инструменты Swagger включают в себя:
  • Редактор Swagger: Редактор Swagger позволяет редактировать спецификации OpenAPI в YAML внутри вашего браузера и просматривать документы в реальном времени.
  • Swagger UI: Swagger UI — это набор ресурсов HTML, Javascript и CSS, которые динамически генерируют прекрасную документацию из OAS-совместимого API.
  • Swagger Codegen: позволяет автоматически генерировать клиентские библиотеки API (SDK), заглушки серверов и документацию с учетом спецификации OpenAPI.
  • Swagger Parser: автономная библиотека для анализа определений OpenAPI из Java
  • Swagger Core: Java-библиотеки для создания, использования и работы с определениями OpenAPI
  • Swagger Inspector (бесплатно): инструмент тестирования API, который позволяет проверять ваши API и генерировать определения OpenAPI из существующего API
  • SwaggerHub (бесплатный и коммерческий): API-дизайн и документация, созданные для команд, работающих с OpenAPI.
• FastAPI — это это современная, быстрая (высокопроизводительная) веб-фреймворк для создания лаконичных и довольно быстрых HTTP API-серверов со встроенными валидацией, сериализацией и асинхронностью, работает с Python 3.6+. Работу с web в FastAPI выполняет Starlette, а валидацию — Pydantic. FastAPI интегрируется с OpenAPI-schema и автоматически генерирует документацию для API посредством Swagger и ReDoc.

Python Libraries for Game Development (Библиотеки Python для разработки игр)

• PyGame — это библиотека модулей/фреймворк Python для разработки 2D игр и мультимедиа-приложений. Pygame основывается на мультимедийной библиотеке SDL (Simple DirectMedia Layer — кроссплатформенная мультимедийная библиотека с открытым исходным кодом, которая реализует единый программный интерфейс для работы с графикой и анимацией, со звуком и музыкой, для работы с интерфейсами I/O — мышь, клавиатура, джойстик и т.д.). Pygame содержит функции и классы Python, которые позволяют вам использовать поддержку SDL.
• Pyglet — это кроссплатформенная библиотека окон и мультимедиа для Python, предназначенная для разработки игр и других мультимедийных приложений Windows, Mac OS X и Linux. Pyglet поддерживает работу с окнами, обработку событий пользовательского интерфейса, графику OpenGL, загрузку изображений и видео, а также воспроизведение звуков и музыки.
• PyOpenGL — это это большой пакет Python, который позволяет работать с функциями OpenGL, GLU, GLE и GLUT. PyOpenGL обеспечивает реализацию приложений с двухмерной и трехмерной графикой.
• Arcade — это простая в освоении библиотека Python для создания 2D видеоигр. Он идеально подходит для людей, которые учатся программировать, или для разработчиков, которые хотят написать двумерную игру, не изучая сложную структуру.
• Panda3D — это полностью бесплатный в использовании движок с открытым исходным кодом для создания 3D-игр, визуализаций, симуляций, экспериментов в реальном времени. Его богатый набор функций легко адаптируется к вашим рабочим процессам и потребностям разработки. Игровой движок включает в себя графику, звук, ввод/вывод, обнаружение и столкновение, а также другие функции, относящиеся к созданию 3D игр.

Python Libraries/Tools for Image Processing

Анализ изображений – это извлечение значимой информации из изображений. Что полезного можно получить из изображений?

• Медицина (выявление аномалий, диагностика заболеваний)
• Системы безопасности (обнаружение «подозрительных» предметов)
• Военная промышленность (системы слежения и целенаведения)
• Обнаружение и распознавание текста

Обзор инструментов:

• OpenCV (Open Source Computer Vision Library) — это библиотека алгоритмов компьютерного зрения с исходным кодом, для обработки изображений и видео, ориентирована на приложения реального времени. Реализована на C/C++, также разрабатывается для Python, Java, Ruby, Matlab, Lua и других языков. Библиотека opencv-python — неофициальный релиз пакетов OpenCV для Python.
• Mahotas — это библиотека компьютерного зрения и обработки изображений для Python, которая включает в себя множество алгоритмов, реализованных в C++ для повышения скорости при работе с большими массивами данных. Mahotas в настоящее время имеет более 100 функций для обработки изображений и компьютерного зрения и продолжает расти.
• SimpleITK (Insight Segmentation and Registration Toolkit, ITK) — это набор инструментов для анализа изображений с большим количеством компонентов, поддерживающих общие операции фильтрации, сегментации и регистрации изображений. Сам SimpleITK написан на C++, но доступен для большого количества языков программирования, включая Python.
• Pillow — это библиотека языка Python, предназначенная для работы с растровой графикой. Однако проект под названием Pillow, являющийся форком PIL, развивается и включает, в том числе, поддержку Python 3.x.
• SciKit-image — это библиотека Python, предназначенная для обработки изображений, включает в себя набор алгоритмов обработки изображений (сегментации, геометрических преобразований, управления цветовым пространством, анализа, фильтрации, морфологии, обнаружения признаков и многое другое). Библиотека доступна бесплатно и без ограничений.

Python Libraries For Text Analytics — библиотеки для анализа текста / NLP

Обработка написанных на естественном языке текстов (Natural Language Processing, NLP), с которой мы познакомились в предыдущей главе, и вычислительная лингвистика (Computational Linguistics, CL) — две сферы вычислительных методов изучения естественных языков.

NLP занимается разработкой методов решения связанных с языками практических задач, таких как извлечением информации, автоматическим распознаванием речи, машинным переводом, анализом тональности высказываний, формированием ответов на вопросы и автоматическим реферированием.

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

• SpaCy — это open-source библиотека для NLP, написанная на Python и Cython. В отличие от NLTK, который широко используется для преподавания и исследований, spaCy фокусируется на предоставлении программного обеспечения для разработки. spaCy поставляется с предварительно обученными статистическими моделями и векторами слов, и в настоящее время поддерживает токенизацию для 50+ языков. В нем реализована современная скорость, сверточные модели нейронных сетей для тегирования, анализа и распознавания именованных объектов, а также простая интеграция с глубоким обучением. Это коммерческое программное обеспечение с открытым исходным кодом, выпущенное под лицензией MIT.
• NLTK (Natural Language Toolkit) — это библиотека для обработки естественного языка на Python, которая позволяет создавать программы для работы с данными на человеческом языке. NLTK доступен для Windows, Mac OS X и Linux. NLTK — это бесплатный проект с открытым исходным кодом, который поддерживает и развивает сообщество специалистов.
• Flair — это мощная библиотека NLP, которая позволяет применять современные модели обработки естественного языка (NLP) к тексту, такие как распознавание именованных объектов (NER), тегирование частей речи (PoS), устранение неоднозначности смысла и классификация.
• TextBlob — это библиотека Python (2 и 3) для обработки текстовых данных. Он предоставляет простой API для погружения в общие задачи обработки естественного языка (NLP), такие как определение части речи, извлечение имен существительных, анализ настроений, классификация, перевод и многое другое.
• Gensim — это библиотека для обработки естественного языка, с помощью которой осуществляют индексацию документов, моделирование тем, поиска сходства. Целевая область применения — это natural language processing (NLP) обработка естественного языка и information retrieval (IR) поиск информации.
• Наташа — это библиотека для извлечения структурированной информации из текстов на русском языке (например извлечения имён, адресов, дат, сумм денег и других сущностей). В библиотеке собраны грамматики и словари для парсера Yargy.

Инструментарий Python для автоматического тестирования

• Исследовательское тестирование (Exploratory Testing, ET). Объединяет тестовый дизайн и тестовое выполнение. Оно направлено на изучение приложения в условиях тестирования.
• Модульные тесты (Unit Test). Определяют поведение малых частей системы, например ветвей конкретных функций. Могут быть направлены на объект или метод, вытекающий из одного или нескольких дизайнерских решений. В контексте Agile автоматизированные модульные тесты направляют программирование на низшем уровне. Как правило, код модульных тестов составляет менее двенадцати строк. Некоторые специалисты предпочитают термин «микротест».
• Операционное тестирование (Operational Acceptance Testing, OAT). Используется для проведения OPS-подготовки (предвыпуска) продукта, услуги или системы как части контроля качества. OAT — стандартный тип нефункционального тестирования программного обеспечения, по большей части поддерживающий софт и проекты ПО.
• Приемочное тестирование (Acceptance Test). Тесты, определяющие бизнес-ценность и объемы каждой истории (функции). Могут определять как функциональные, так и нефункциональные требования, например, рабочие показатели или надежность. Хотя используются для разработки на основе примеров, представляют собой тесты высшего уровня, в отличие от модульных, используемых для создания кода в разработке на основе тестов. Это широкий термин, он может включать в себя бизнес-ориентированные и технологические тесты.
• Регрессионное тестирование (Regression Test). Определяет, что поведение системы в условиях тестирования не меняется. Регрессионные тесты часто пишутся как модульные, чтобы поддерживать программирование, или как приемочные, чтобы определять желаемое поведение системы. Как только проверка завершена, она становится частью набора регрессионных тестов, предотвращающих незапланированные изменения. Регрессионные тесты должны быть автоматизированы для обеспечения непрерывной обратной связи.
• Автотест (автоматизированный тест) – это скрипт, который имитирует взаимодействие бизнес-пользователя с приложением. Целью автотестов является локализация ошибок в работе системы/ПО. Конечная цель автоматического тестирования — создание набора автотестов, которые будут поочередно запускаться после нажатия на кнопку «Старт». Также должны быть предусмотрены одиночные автотесты для проверки отдельной функциональности. Каждый тестовый скрипт контролирует правильность работы определенной функциональности приложения (его части) и фиксирует ошибки, если что-то пошло не так.

Библиотеки Python для тестирования:

• Splinter — это инструмент с открытым исходным кодом для тестирования веб-приложений с использованием Python. Позволяет автоматизировать действия браузера, такие как посещение URL-адресов и взаимодействие с их элементами. Например, 1) Посетите веб-сайт Google, 2) Введите текст поиска, 3) Нажмите кнопку поиска, 4) Узнайте, находится ли сайт вашей компании в результатах поисковой выдачи. И т.д.
• Robot (Robot Framework) — это универсальная среда автоматизации с открытым исходным кодом. Он может быть использован для автоматизации тестирования и автоматизации процессов (RPA). Robot Framework активно поддерживается, и многие ведущие компании используют его при разработке программного обеспечения. Robot Framework имеет простой синтаксис, использующий удобочитаемые ключевые слова. Его возможности могут быть расширены библиотеками, реализованными на Python или Java.
• Behave — это behavior-driven (BDD) фреймворк для тестирования, который использует тесты, написанные в стиле естественного языка, подкрепленные кодом Python. Выдаёт красивые, аккуратные и понятные отчеты. Лучше всего подходит для тестирования «черного ящика». Лучше не использовать для модульного тестирования или низкоуровневого интеграционного тестирования.
• PyUnit (или unittest) — это framework для тестирования, входящий в стандартную библиотеку языка Python. Представляет собой версию JUnit на языке Python. Позволяет просто создавать программы модульного тестирования с помощью Python.
• PyTest — это фреймворк для тестирования, который позволяет легко писать небольшие тесты, а также масштабируется для поддержки сложного функционального тестирования приложений и библиотек. Это один из лучших инструментов, которые вы можете использовать для повышения производительности тестирования. Может запускать тесты параллельно. Может выполнить определенный тест или подмножество тестов.

Обзор других библиотек Python (работа со временем, оперативной системой, числами и т.д.)

• math — это модуль Python, который обеспечивает доступ к математическим функциям для работы с числами (набор функций для выполнения математических, тригонометрических и логарифмических операций и другие).
• time — это модуль Python, который предоставляет различные функции для работы со временем (смещение DST часового пояса, форматирование времени, делать задержки по таймеру и др.). Большинство функций, определенных в этом модуле, вызывают библиотечные функции платформы С с тем же именем.
• datetime — это модуль, который предоставляет классы для работы с датой и временем (формирование даты, вычисление разницы между двумя моментами времени, получение информации о временной зоне, получение текущего времени, получение даты из datetime, получение времени из datetime и др.).
• calendar — это модуль Python, который позволяет выводить календари (в виде простого текста или в HTML формате), а также предоставляет дополнительные полезные функции, связанные с календарем.
• os — это модуль, который предоставляет функции для работы с операционной системой. Модель содержит функции для работы с файлами, директориями, с переменными окружения, производить работу с путями, получать информацию об операционной системе и др.
• sys — это модуль, который предоставляет доступ к некоторым переменным и функциям для получения информации о взаимодействии интерпретатора Python с операционной системой. Модуль sys очень часто используют вместе с os модулем. С помощью sys можно получить такую информацию, как запущенная версия Питона, путь к интерпретатору Python, каталог установки Python, кодировка файловой системы, параметры командной строки и др.
• random — это модуль, который реализует генераторы псевдослучайных чисел для различных распределений (равномерного, нормального/гауссовского, логнормального, отрицательного экспоненциального, гамма- и бета-распределений).
• re — это модуль предоставляет операции сопоставления регулярных выражений (поиск с помощью «регулярных выражений» или с помощью текстовых «паттернов»/»patterns»). Другими словами это парсинг текста или поиск последовательностей символов, согласно заданным правилам, которые описываются в виде шаблонов.
• python-docx — это библиотека Python для создания и обновления/изменения файлов Microsoft Word (.docx).
• python-play — это модуль python, позволяющий воспроизводить аудиофайл в формате mp3.
• PyPDF2 — это библиотека PDF на чистом python, способная разбивать, объединять, обрезать и преобразовывать страницы файлов PDF. Он также может добавлять пользовательские данные, параметры просмотра и пароли к файлам PDF. Он может извлекать текст и метаданные из PDF-файлов, а также объединять файлы целиком.

Лучшие IDE (интегрированные среды разработки) и редакторы кода для Python

• IDLE (Integrated Development and Learning Environment) — это интегрированная среда разработки и обучения на языке Python, созданная с помощью библиотеки Tkinter. Это оболочка Python, окно для ввода команд на языке Python. В Windows это поставляется с интерпретатором Python, т.е. устанавливается вместе с Python.
• Jupyter Notebook — это веб-приложение с открытым исходным кодом, которое позволяет создавать и обмениваться документами, которые содержат живой код и результат его выполнения, уравнения, визуализации и текст с пояснениями по вычислениям. Часто используется для: очистки и преобразования данных, числового моделирования, статистического моделирования, визуализации данных, машинного обучения и др.
• Anaconda — дистрибутив языков программирования Python и R, включающий набор популярных свободных библиотек, объединённых проблематиками науки о данных и машинного обучения. Основная цель — поставка единым согласованным комплектом наиболее востребованных соответствующим кругом пользователей тематических модулей (таких как NumPy, SciPy, Astropy и других) с разрешением возникающих зависимостей и конфликтов, которые неизбежны при одиночной установке. По состоянию на 2019 год содержит более 1,5 тыс. модулей.
• PyCharm — это кросс-платформенная среда (Windows, MacOS, Linux) разработки для разных языков программирования (в частности для Python). PyCharm Community Edition (бесплатная версия) находится под лицензией Apache License, а PyCharm Professional Edition(платная версия) является проприетарным ПО. PyCharm предоставляет умную проверку кода, быстрое выявление ошибок и оперативное исправление, вкупе с автоматическим рефакторингом кода, и богатыми возможностями в навигации.
• Spyder — свободная и кроссплатформенная интерактивная IDE для научных расчетов на языке Python. Используется инженерами и аналитиками данных. Spyder является частью модуля spyderlib для Python, основанного на PyQt4, pyflakes, rope и Sphinx, предоставляющего мощные виджеты на PyQt4, такие как редактор кода, консоль Python (встраиваемая в приложения), графический редактор переменных (в том числе списков, словарей и массивов).
• Visual Studio Code — редактор кода, разработанный Microsoft для Windows, Linux и macOS. Позиционируется как «лёгкий» редактор кода для кроссплатформенной разработки веб- и облачных приложений. Включает в себя отладчик, инструменты для работы с Git, подсветку синтаксиса, IntelliSense (технология автодополнения Microsoft) и средства для рефакторинга. Имеет широкие возможности для кастомизации: пользовательские темы, сочетания клавиш, файлы конфигурации, имеет множество полезных плагинов. Распространяется бесплатно, разрабатывается как программное обеспечение с открытым исходным кодом, но готовые сборки распространяются под проприетарной лицензией.
• Thonny — интегрированная среда разработки для Python, специально разработанная для начинающих Pythonista. Поддерживает различные способы пошагового выполнения кода, пошаговое вычисление выражений, детальную визуализацию стека вызовов и режим объяснения концепций ссылок и кучи.
• Sublime Text — легковесный текстовый редактор для программистов. Поддерживает плагины на языке программирования Python. Разработчик позволяет бесплатно и без ограничений ознакомиться с продуктом, однако программа уведомляет о необходимости приобретения лицензии.
• Atom (с плагином atom-python-run) — бесплатный текстовый редактор с открытым исходным кодом для Linux, macOS, Windows с поддержкой плагинов, написанных на Node.js, и встраиваемых под управлением Git. Большинство плагинов имеют статус свободного программного обеспечения, разрабатываются и поддерживаются сообществом. Есть плагин для Python atom-python-run.

Синхронизация. Координация распределенных приложений

• ZooKeeper (Apache ZooKeeper) — это высокопроизводительный сервис координации для распределенных приложений; Служба, предназначенная для хранения конфигурационной информации, имён, выполнения распределённой синхронизации процессов. Фактически выполняет важнейшие задачи многих распределённых приложений. Является важной составляющей Hadoop-инфраструктуры, но может использоваться отдельно. Поддерживается Apache Foundation, написана на Java. Для получения информации каждый клиентский компьютер связывается с одним из серверов. ZooKeeper следит за синхронизацией всего кластера. Внедрение ZooKeeper делает ставку на высокую производительность, доступность и строго упорядоченный доступ. Аспекты производительности ZooKeeper позволяют использовать его в больших распределенных системах.

Реляционные базы данных (СУБД)

• MySQL — это
• PostgreSQL — это

NoSQL СУБД и Time-Series DataBase

• Redis (Remote Dictionary Server) — это база данных in-memory (хранимая в оперативной памяти) с исходным кодом (лицензиия BSD), которая хранится на диске. База данных организована по модели «ключ-значение», также можно использовать другие типы значений: строки, списки, наборы, отсортированные наборы, хэши, потоки, HyperLogLogs, растровые изображения. Redis обеспечивает время отклика на уровне долей миллисекунды и позволяет приложениям, работающим в режиме реального времени, выполнять миллионы запросов в секунду. Такие приложения востребованы в сфере игр, рекламных технологий, финансовых сервисов, здравоохранения и IoT.
• MongoDB — это кросс-платформенная, документоориентированная NoSQL система управления базами данных с открытым исходным кодом, не требующая описания схемы таблиц (schemaless). Написана на C++. Хранит данные в JSON-подобных документах, в основе БД лежит концепция коллекций и документов. Обеспечивает высокую производительность и лугкую масштабируемость. Документ — JSON-объект имеющий произвольное число полей. Коллекция (таблица)- однотипные документы хранятся в отдельной коллекции.База данных — набор коллекций. Используется в веб-разработке.
• CouchDB (Сluster Of Unreliable Commodity Hardware) — это документо-ориентированная NoSQL СУБД с открытым исходным кодом, написанная на языке Erlang, которая не требует описания схемы данных. CouchDB предоставляет REST интерфейс для работы с базой: Если мы хотим получить информацию — отправляем GET запрос, Если надо создать документ — POST, Необходимо что-то изменить — PUT, COPY для копирования, DELETE для удаления. Используется в веб-разработке.
• Cassandra — это распределенная гибридная NoSQL система управления БД, которая используется для создания высокомасштабируемых и надежных хранилищ огромных массивов данных, которые представлены в виде хэша. Cassandra разработана Facebook на языке Java, а затем СУБД передали для дальнейшего развития фонду Apache Software Foundation. Cassandra сочетает в себе модель хранения данных на базе семейства столбцов (ColumnFamily) с концепцией key-value (ключ-значение). Есть возможность организации хранения хэшей с несколькими уровнями вложенности. Относится к категории отказоустойчивых СУБД: помещённые в базу данные автоматически реплицируются на несколько узлов распредёленной сети или даже равномерно распределяются в нескольких дата-центрах, при сбое узла его функции на лету подхватываются другими узлами, добавление новых узлов в кластер и обновление версии Cassandra производится на лету, без дополнительного ручного вмешательства и переконфигурации других узлов.
• Neo4j — является ведущей в мире графовой системой управления базами данных с открытым исходным кодом, разработана на Java. Данные хранит в собственном формате, специализированно приспособленном для представления графовой информации. Программист работает с гибкой сетевой структурой узлов и отношений, а не со статическими таблицами.
• Clickhouse — это колоночная аналитическая система управления базами данных с открытым исходным кодом, разрабатывается компанией Yandex (Яндекс). Позволяет выполнять аналитические запросы в режиме реального времени на структурированных больших данных. ClickHouse использует собственный диалект SQL близкий к стандартному, но содержащий различные расширения: массивы и вложенные структуры данных, функции высшего порядка, вероятностные структуры, функции для работы с URI, возможность для работы с внешними key-value хранилищами («словарями»), специализированные агрегатные функции, функциональности для семплирования, приблизительных вычислений, возможность создания хранимых представлений с агрегацией, наполнения таблицы из потока сообщений Apache Kafka и т.д.
• VictoriaMetrics — это масштабируемая база данных временных рядов с открытым исходным кодом, которую можно использовать в качестве долгосрочного удаленного хранилища для Prometheus. Prometheus — это бесплатное программное приложение с открытым исходным кодом, используемое для мониторинга событий и оповещения. Он записывает метрики в реальном времени в базу данных временных рядов, построенную с использованием HTTP pull model, с гибкими запросами и оповещениями в реальном времени.
• InfluxDB — это база данных временных рядов с открытым исходным кодом, которая предназначена для обработки высокой нагрузки записей и запросов. Является частью стека TICK (Telegraf, InfluxDB, Chronograf, Kapacitor). Используется для IoT мониторинга и аналитики, мониторинга инфраструктуры и приложений.

WebSite Search Engine — механизм поиска для веб-сайта (поисковый движок)

• Elasticsearch — это масштабируемый поисковый движок корпоративного уровня с открытым исходным кодом, основанный на библиотеке Lucene (NoSQL с JSON REST API). Данные хранятся в формате JSON, система работает на платформе Java. Официальные клиенты доступны на Java, .NET (C#), PHP, Python, Apache Groovy, Ruby и многих других языках. Система обеспечивает полнотекстовый поиск и анализ данных.
• Sphinx — это высокоскоростная система для полнотекстового поиска, которую разработал Адрей Аксенов на языке C++. Система работает в Linux (RedHat, Ubuntu и т.д.), Windows, MacOS, Solaris, FreeBSD. Официальные реализации Sphinx API доступны для PHP, Java, Perl, Ruby и Python. Поисковый сервер Sphinx имеет двойную лицензию, поэтому он может быть лицензирован для коммерческой деятельности, а также свободно доступен для загрузки на официальном сайте (если он будет использоваться в соответствии с условиями GPL v.2).
• Solr — это платформа для полнотекстового поиска с открытым исходным кодом, написанная на Java и основана на проекте Apache Lucene. Её основные функции включают в себя полнотекстовый поиск, подсветка результатов, фасетный поиск, индексация в реальном времени, динамическую кластеризацию, интеграцию с базами данных, функции NoSQL, а также обработку документов Word, PDF и др. В основе Solr для реализации поиска и индексации лежит Lucene. Solr имеет HTTP/XML и JSON API, поэтому эту платформу можно использовать из всех популярных языков программирования.
• Xapian — это библиотека для полнотекстового поиска с открытым исходным кодом. Используется во многих ОС: Linux, MacOS, FreeBSD, NetBSD, OpenBSD, Solaris, IRIX, Windows. Может использоваться совместно с Perl, Python, PHP, Java, Tcl, C#, Ruby, Lua, Erlang, Node.js.

Workflow Management системы и Брокеры сообщений

• Apache Airflow — это open-source набор библиотек, платформа для планирования, создания и мониторинга рабочих процессов. Airflow является незаменимым инструментом для современного дата инженера как планировщик ETL/ELT-процессов, предназначен для запуска цепочек задач (data pipelines). Для создания рабочих процессов используется язык Python. Основные компоненты рабочего процесса Airflow: Направленные ациклические графы (DAG), Планировщик (Scheduler), Операторы (Operators), Задачи (Tasks).
• Kafka — это брокер сообщений, проект с открытым исходным кодом, используется для создания конвейеров данных в реальном времени и потоковых приложений. Масштабируется по горизонтали, используется паттерн Producer-Consumer, отказоустойчив. Разработана компанией LinkedIn на JVM стеке (Scala). Приложения (генераторы) посылают сообщения (записи) на узел Kafka (брокер), и указанные сообщения обрабатываются другими приложениями, так называемыми потребителями. Указанные сообщения сохраняются в теме, a потребители подписываются на тему для получения новых сообщений.
• Luigi — это пакет Python (поддерживаются версии 2.7, 3.6, 3.7 и выше), который помогает вам создавать сложные конвейеры пакетных заданий. С помощью Luigi производится управление рабочими процессами, управление зависимостями между задачами, имеется центральный планировщик задач с веб-интерфейсом, статусом выполнения задач и трекингом ошибок, CLI (есть возможность работы через командную строку), failover recovery. Разработан был инженерами из Spotify.
• Celery — это простая, гибкая и надежная распределенная система для обработки в асинхронном режиме огромного количества сообщений. Инструмент, который позволяет обрабатывать очередь задач, причем с акцентом на обработку в реальном времени, а также с поддержкой планирования задач. С помощью Celery можно запускать отложенный или выделенный код в отдельном процессе или даже на отдельном компьютере или сервере. Также Celery можно использовать для отправки электронных писем.
  
• RabbitMQ — это менеджер сообщений (message broker) на основе стандарта AMQP (тиражируемое связующее программное обеспечение, ориентированное на обработку сообщений). Создан на основе системы Open Telecom Platform, написан на языке Erlang, в качестве движка базы данных для хранения сообщений использует Mnesia. Состоит из сервера, библиотек поддержки протоколов HTTP, XMPP и STOMP[en], клиентских библиотек AMQP для Java и .NET Framework и различных плагинов. Если кратко, то это платформа, которая управляет очередью сообщений и к которой могут подключатся различные приложения и передавать/получать сообщения (т.е. предназначен для передачи данных между несколькими сервисами).
• ActiveMQ -это популярный многопротокольный сервер обмена сообщениями на основе Java с открытым исходным кодом. Он поддерживает стандартные отраслевые протоколы. Доступно подключение из C, C ++, Python, .Net и других языков программирования. Работает на основе протокола AMQP. Обмен сообщениями между веб-приложениями осуществляется с помощью STOMP через веб-сокеты. Также для работы с устройствами IoT используется MQTT. Обеспечивает «Enterprise Features», такие как кластеризация, хранение сообщений, с возможностью использовать различные базы данных, кэширование и ведение журналов. Написан на Java с полноценным клиентом Java Message Service (JMS).
• Kombu — это библиотека для работы с сообщениями на языке Python. Цель Kombu — максимально упростить обмен сообщениями в Python, предоставив высокоуровневый интерфейс для протокола AMQP, а также предоставить проверенные и проверенные решения для распространенных проблем обмена сообщениями. AMQP — это расширенный протокол очереди сообщений, открытый стандартный протокол для ориентации сообщений, организации очередей, маршрутизации, надежности и безопасности.

Система контроля версий

• Git — это бесплатная распределенная система контроля версий (управления версиями) с открытым исходным кодом, предназначенная для быстрой и эффективной работы с небольшими и очень крупными проектами. Хранилище истории разработки проектов, которое содержит в себе все версии его файлов (как текущие, так и старые неактуальные). Контроль версий означает что вы храните все версии редактируемых документов и можете вернуться к любой сохраненной версии в любой момент времени.
• Git-Flow — это набор расширений git предоставляющий высокоуровневые операции над репозиторием для поддержки модели ветвления Vincent Driessen.

Git Frameworks. Автоматизация CI/CD

• GitHub — это веб-платформа (облачный сервис по бизнес-модели SaaS), которая предлагает облачный хостинг Git (для контроля версий и совместной работы для разработчиков программного обеспечения). Microsoft, крупнейший участник GitHub, инициировала приобретение GitHub за 7,5 млрд долларов в июне 2018 года. GitHub был запущен в 2008 году и был основан на Git (системе управления открытым исходным кодом, созданная Линусом Торвальдсом для ускорения сборки программного обеспечения). GitHub это «социальная сеть для разработчиков». Участникам, кроме непосредственного хранения кода, своих проектов, можно общаться, комментировать изменения друг друга, отслеживать новости знакомых. У программистов есть возможность объединять репозитории и выводить вклад участника в виде дерева.
• BitBucket — это веб-сервис для хостинга GIT репозитория для контроля версий и совместной разработки проектов, основанный на системе контроля версий Mercurial и Git. Принадлежит Atlassian. Bitbucket предлагает как коммерческие планы, так и бесплатные аккаунты. Bitbucket интегрируется с другими программами Atlassian, такими как Jira, HipChat, Confluence и Bamboo. По назначению и основным предлагаемым функциям аналогичен GitHub. Основные преимущества GitHub лежат в области социализации программирования (social coding), Bitbucket больше ориентирован на небольшие закрытые команды разработчиков. Слоган сервиса — Bitbucket is the Git solution for professional teams («Bitbucket — это Git-решение для профессиональных команд»).
• GitLab — это веб-приложение на основе базы данных, так что его установка немного сложней, чем у некоторых других серверов git. GitLab помогает разработчикам вести непрерывный процесс развертывания для тестирования, создания и деплоя кода, следить за ходом тестов, повышать контроль над качеством, фокусирования на построении продукта вместо настройки инструментов. GitLab — веб-инструмент жизненного цикла DevOps с открытым исходным кодом, представляющий систему управления репозиториями кода для Git с собственной вики, системой отслеживания ошибок, CI/CD пайплайном и другими функциями. Код изначально был написан на Ruby, а некоторые его части были позже переписаны на Go.
• Jenkins — это система с открытым исходным кодом на Java, предназначенная для обеспечения процесса непрерывной интеграции программного обеспечения. Отсоединилась в 2008 году от проекта Hudson, принадлежащего компании Oracle, основным его автором был Косукэ Кавагути. Распространяется под лицензией MIT.

Создание образов, сборка и доставка контейнеров

• Docker — это программное обеспечение для автоматизации развертывания, быстрой разработки и тестирования приложений. Docker упаковывает ПО в стандартизованные блоки, которые называются контейнерами. Каждый контейнер включает все необходимое для работы приложения: библиотеки, системные инструменты, код и среду исполнения. Благодаря Docker можно быстро развертывать и масштабировать приложения в любой среде и сохранять уверенность в том, что код будет работать. Docker – это операционная система для контейнеров. Подобно тому как виртуальная машина создает виртуальное представление аппаратного обеспечения сервера (то есть устраняет необходимость непосредственно управлять таковым), контейнеры создают виртуальное представление серверной операционной системы. После установки на каждый сервер Docker предоставляет доступ к простым командам, необходимым для сборки, запуска или остановки контейнеров. Позволяет «упаковать» приложение со всем его окружением и зависимостями в контейнер, который может быть перенесён на любую Linux-систему с поддержкой cgroups в ядре, а также предоставляет среду по управлению контейнерами.
• OpenShift — это открытая и расширяемая платформа приложений-контейнеров, которая позволяет использовать Docker и Kubernetes на предприятии. Разработано компанией RedHat. OpenShift включает в себя Kubernetes для оркестрации контейнеров и управления ими.
• Kubernetes (также известный как k8s или «kube») — это платформа оркестрации контейнеров с открытым исходным кодом, которая автоматизирует многие ручные процессы, связанные с развертыванием, управлением и масштабированием контейнерных приложений. Kubernetes является идеальной платформой для размещения облачных приложений, требующих быстрого масштабирования, таких как потоковая передача данных в реальном времени через Apache Kafka.

SQL Based Engines

• Apache Hive — это система управления базами данных на основе платформы Hadoop. Позволяет выполнять запросы, агрегировать и анализировать данные, хранящиеся в Hadoop. Apache Hive был создан корпорацией Facebook и передан под открытой лицензией в собственность фонду Apache Software Foundation. На сегодняшний день эта система используется компанией Netflix и доступна в Amazon Web Services через Amazon Elastic MapReduce. Hive определяет простой SQL-подобный язык запросов, называемый HiveQL (Hive Query Language), что позволяет пользователям, знакомым с SQL легко работать с запросами к данным.
• Apache Impala — это аналитическая база данных с открытым исходным кодом для Apache Hadoop. Impala обеспечивает быстрые интерактивные SQL-запросы непосредственно на ваших данных Apache Hadoop, хранящихся в HDFS, HBase или Amazon Simple Storage Service (S3). Apache Impala — это механизм SQL-запросов с открытым исходным кодом для массивно-параллельной обработки (MPP) данных, хранящихся в компьютерном кластере под управлением Apache Hadoop.
• Apache Spark – это Big Data фреймворк с открытым исходным кодом для реализации распределённой обработки неструктурированных и слабоструктурированных данных, входящий в экосистему проектов Hadoop. В отличие от классического обработчика из ядра Hadoop, реализующего двухуровневую концепцию MapReduce с хранением промежуточных данных на накопителях, Spark работает в парадигме in-memory computing — обрабатывает данные в оперативной памяти, благодаря чему позволяет получать значительный выигрыш в скорости работы для некоторых классов задач, в частности, возможность многократного доступа к загруженным в память пользовательским данным делает библиотеку привлекательной для алгоритмов машинного обучения. Проект предоставляет программные интерфейсы для языков Java, Scala, Python, R. Изначально написан на Scala, впоследствии добавлена существенная часть кода на Java для предоставления возможности написания программ непосредственно на Java. Состоит из ядра и нескольких расширений, таких как Spark SQL (позволяет выполнять SQL-запросы над данными), Spark Streaming (надстройка для обработки потоковых данных), Spark MLlib (набор библиотек машинного обучения), GraphX (предназначено для распределённой обработки графов).
• Presto — это высокопроизводительный механизм распределенных SQL-запросов для Big Data (больших данных). Архитектура Presto позволяет пользователям отправлять запросы в различные источники данных, такие как Hadoop, AWS S3, Alluxio, MySQL, Cassandra, Kafka и MongoDB. Можно даже запросить данные из нескольких источников данных в рамках одного запроса. Presto — это программное обеспечение с открытым исходным кодом для сообщества, выпущенное по лицензии Apache.

Качество кода

• PIP8 — это
• code review — это
• code refactoring — это

JavaScript Инструменты

• Socket.IO — это JavaScript библиотека, которая обеспечивает двустороннюю и основанную на событиях связь между браузером и сервером в режиме реального времени. Состоит из двух частей: клиентской, которая запускается в браузере и серверной для node.js. Socket.IO главным образом использует протокол WebSocket, но если нужно, использует другие методы, например Adobe Flash сокеты, JSONP запросы или AJAX запросы. Может быть установлена через npm (node package manager).
• NodeJS — это среда выполнения кода на JavaScript, созданная на основе движка Chrome V8 JavaScript, который позволяет транслировать вызовы на языке JavaScript в машинный код. NodeJS превращает JavaScript из узкоспециализированного языка в язык общего назначения. Node.js добавляет возможность JavaScript взаимодействовать с устройствами ввода-вывода через свой API (написанный на C++), подключать другие внешние библиотеки, написанные на разных языках, обеспечивая вызовы к ним из JavaScript-кода. Node.js применяется преимущественно на сервере, выполняя роль веб-сервера, но есть возможность разрабатывать на Node.js и десктопные оконные приложения (при помощи NW.js, AppJS или Electron для Linux, Windows и macOS) и даже программировать микроконтроллеры (например, tessel, low.js и espruino). В основе Node.js лежит событийно-ориентированное и асинхронное (или реактивное) программирование с неблокирующим вводом/выводом.
• Express.js (или просто Express) — это быстрый, гибкий, минималистичный веб-фреймворк для приложений Node.js, реализованный как свободное и открытое программное обеспечение под лицензией MIT. Он спроектирован для создания веб-приложений и API. Де-факто является стандартным каркасом для Node.js. Express может являться backend’ом для программного стека MEAN, вместе с базой данных MongoDB и каркасом Vue.js, React или AngularJS для frontend’а.
• WebSocket — это протокол связи поверх TCP-соединения, предназначенный для обмена сообщениями между браузером и веб-сервером в режиме реального времени. Веб-сокеты (Web Sockets) — это передовая технология, которая позволяет создавать интерактивное соединение между клиентом (браузером) и сервером для обмена сообщениями в режиме реального времени. Веб-сокеты, в отличие от HTTP, позволяют работать с двунаправленным потоком данных. WebSocket — это своего рода канал связи, открытый в двух направлениях.
• Vue.js — open source JavaScript веб-фреймворк с открытым исходным кодом для создания пользовательских интерфейсов. Легко интегрируется в проекты с использованием других JavaScript-библиотек. Может функционировать как веб-фреймворк для разработки одностраничных приложений в реактивном стиле. С его помощью можно создавать динамические сайты и сложные одностраничные веб-приложения. Ядро фреймворка ориентировано на решение задач уровня представления, благодаря чему фреймворк несложно интегрировать в проекты совместно с дополнительными библиотеками и различными инструментами. В отличие от React.js, jQuery, AngularJS и других фреймворков, Vue.js достаточно прост для изучения. Но, как и с другими JS-фреймворками, потребуются знания основ CSS, HTML и JavaScript, поэтому советуем сначала изучить их.
• Vuex — это шаблон/паттерн управления состоянием + библиотека для приложений Vue.js. Vuex можно рассматривать как единый источник данных для всего приложения. Vuex — это библиотека управления состоянием, специально предназначенная для создания сложных крупномасштабных приложений Vue.js. Она использует глобальное централизованное хранилище для всех компонентов в приложении, используя преимущества собственной системы реактивности для мгновенных обновлений. Хранилище Vuex спроектировано таким образом, что невозможно изменить его состояние из какого-либо компонента. Это гарантирует, что состояние может быть изменено только предсказуемым образом. Таким образом, хранилище становится единственным источником истины: каждый элемент данных хранится только один раз и доступен только для чтения, чтобы предотвратить разрушение компонентами приложения состояния, к которому обращаются другие компоненты. Хранилище Vuex — реактивное.
• Vue-router — является официальным маршрутизатор для Vue.js. Он тесно интегрируется с ядром Vue.js, что позволяет без проблем создавать одностраничные приложения с Vue.js.
• React — это декларативная, эффективная и гибкая библиотека JavaScript с открытым исходным кодом для разработки пользовательских интерфейсов. React может использоваться для разработки одностраничных и мобильных приложений. Его цель — предоставить высокую скорость, простоту и масштабируемость. В качестве библиотеки для разработки пользовательских интерфейсов React часто используется с другими библиотеками, такими как MobX, Redux и GraphQL.
• Angular — это JavaScript-фреймворк с открытым исходным кодом, написанный на языке TypeScript и который разрабатывается командой из компании Google, а также сообществом разработчиков из различных компаний. Цель фреймворка — расширение браузерных приложений на основе MVC-шаблона, а также упрощение тестирования и разработки.

Траблшутинг

• Wireshark — программа-анализатор сетевых протоколов (трафика для компьютерных сетей). Имеет графический пользовательский интерфейс. Он позволяет вам видеть то, что происходит в вашей сети, на микроскопическом уровне и является стандартом де-факто (и часто де-юре) для многих коммерческих и некоммерческих предприятий, государственных учреждений и образовательных учреждений. Развитие Wireshark процветает благодаря добровольному вкладу сетевых экспертов по всему миру и является продолжением проекта, начатого Джеральдом Комбсом в 1998 году. Работает на Windows, Linux, macOS, Solaris, FreeBSD, NetBSD и многих других платформах. Имеется выгрузка данных (экспорт данных) в XML, PostScript, CSV или простой текст (txt).
• Strace — утилита для Linux, которая позволяет отследить выполнение системных вызовов (system call) и сигналов к ядру системы. Она используется для мониторинга и вмешательства во взаимодействие между процессами и ядром Linux, которое включает системные вызовы, доставку сигналов и изменения состояния процессов. Операция strace стала возможной благодаря функции ядра, известной как ptrace. Присутствует во многих дистрибутивах Linux по умолчанию. strace может использоваться для отправки багрепортов разработчикам.
• Procmon (Process Monitor) — это инструмент отслеживания для Windows. В режиме реального времени отображает активность файловой системы, реестра, а также процессов и потоков, включая расширенную и безвредную фильтрацию, всеобъемлющие свойства событий, такие как ID сессий и имена пользователей, достоверную информацию о процессах, полноценный стек потока со встроенной поддержкой всех операций, одновременный запись информации в файл и многие другие возможности. Эти уникальные возможности делают Process Monitor ключевым инструментом для устранения неполадок и избавления от вредоносных программ.
• gdb — это переносимый отладчик проекта GNU, который умеет производить отладку многих языков программирования, включая Си, C++, Free Pascal, FreeBASIC, Ada, Фортран, Python3, Swift, NASM и Rust. GDB можно подключить к VSCode и другим редакторам кода (Включая Vim, NeoVim, Emacs, Atom и др.). GDB может работать на большинстве популярных вариантов UNIX и Microsoft Windows, а также на Mac OS X.
• Syslog (system log — системный журнал) — это стандарт отправки и регистрации сообщений о происходящих в системе событиях (то есть создания событийных журналов), использующийся в компьютерных сетях, работающих по протоколу IP. Термином «syslog» называют как ныне стандартизированный сетевой протокол syslog, так и программное обеспечение (приложение, библиотеку), которое занимается отправкой и получением системных сообщений.
• Windows Event Log (Средство просмотра событий Windows) — отображает журнал приложений и системных сообщений, включая ошибки, информационные сообщения и предупреждения. Это полезный инструмент для устранения различных проблем Windows. Можно выгрузить журнал в текстовый файл.

BI — Business intelligence. Системы бизнес-аналитики

Ниже будут описаны 3 bi системы, по квадранту гартнера их можно упорядочить как:

1. Power BI
2. Tableau
3. Qlik Sense

Из всех трех я бы однозначно отдал первенство Power BI, т.к. будем откровенны — ни одна компания в мире не обладает потенциалом, который есть у Microsoft для работы с данными компаний. По сути, Power BI родился из Excel, сервисов хранилищ данных Microsoft. Инструментарий очень богат, плюс есть огромное множество интеграций с другим софтом (Python, R и др.).

Tableau на втором месте по большей части из-за очень крутой визуализации.

Ну а Qlik Sense занимает третье место (по инерции), т.к. когда то был лидером квадранта и многие компании до сих пор используют это ПО. У меня есть опыт работы с Qlik Sense и хочу сказать, что мне сложно его отнести к лидерам BI инструментов, т.к. QlikTech развивает свою экосистему обработки данных в ущерб функционалу BI. Что несомненно сказалось на позициях Qlik Sense на рынке. Плюс QlikTech свернул свой бесплатный софт Qlik Sense Desktop, что несомненно негативно отразилось на настроениях специалистов.

• Power BI — это это платформа бизнес-аналитики (Business Intelligence), которая предоставляет инструменты для агрегирования, анализа, визуализации данных. Как правило все инструменты максимально адаптированы для нетехнических пользователей для построения аналитических панелей. В случае больших объемов данных или сложной логики приложений требуется более углубленный технический бэкграунд для создания приложений. С помощью Power BI Вы можете построить дашборд с нужными KPI по компании. Power BI состоит из настольного приложения Windows, которое называется Power BI Desktop (в нем Вы создаете само приложение), онлайн-служба SaaS под названием Power BI Service (туда публикуется приложение из Power BI Desktop), а также мобильное приложение Power BI, которое доступно для платформ iOS, Android и Windows.
• Tableau – BI-система интерактивной аналитики, которая позволяет в кратчайшие сроки проводить глубокий и разносторонний анализ больших массивов информации и не требующая обучения бизнес-пользователей и дорогостоящего внедрения. Tableau Online — это онлайн-сервис (функционал Tableau Desktop, но удаленно, в облаке), Tableau Prep — подготовка данных к работе в Tableau, Tableau Server — ПО для установки BI на серверах компании. Также имеется мобильное приложение.
• Qlik Sense — это платформа для анализа данных / система бизнес-аналитики (Business Intelligence), которая позволяет создавать аналитические приложения (агрегирование данных, визуализация). В отличии от Power BI, можно купить свой Enterprice сервер и поставить на сервер компании. У Power BI тоже такое есть, но вроде как за очень большие деньги (честно сказать деталей не знаю). По сравнению с Power BI больше подходит для технических пользователей. Загрузку данных нужно кодить, есть визуальные инструменты, но они более скудные по функционалу и возможностям. Хотя есть платные расширения VizLib, которые разрабатывает тот же QlikTech, но это уже за дополнительные деньги. Сервер внутри компании облегчает доступ к данным, т.к. не нужно весь массив данных компании выводить в онлайн (создавать онлайн хранилище, закачивать данные в облако и т.д.). Также Qlik Sense имеет очень мощный API, с полным доступом ко всем функциям платформы Qlik Sense. Но стоит заметить, что подобный функционал не нужен в 85% случаев. Возможно только если компания захочет сделать свой «космолет», который будет стоить очень больших денег на этапе эксплуатации.

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

• Prometheus — это
• Kibana — это
• Grafana — это
• Graphite — это

Принципы разработки программного обеспечения

• SOA (Service Oriented Architecture) — это модульный подход к разработке программного обеспечения, основанный на использовании распределённых, слабо связанных заменяемых компонентов, оснащённых стандартизированными интерфейсами для взаимодействия по стандартизированным протоколам. интеграции информационной инфраструктуры компании за счет построения архитектуры, позволяющей интегрировать с максимальной гибкостью разнородные приложения.

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

С помощью SOA реализуются три аспекта ИТ-сервисов:

• Сервисы бизнес-функций,
• Сервисы инфраструктуры,
• Сервисы жизненного цикла.

• Архитектура SPA (Single-Page Application или одностраничные приложения) — тип веб-приложений, состоящие из одной страницы, на которых динамически обновляется контент, в зависимости от действий пользователей. При таком подходе разработки экономится время на повторную загрузку одних и тех же элементов (библиотек JS, стилей CSS, структуры сайта, меню и т.д.). По большей части этот подход реализуется за счет инструментов JavaScript (React.js, Angular.js, Vue.js и др.).
• Архитектура MPA (Multi-Page Application или многостраничные приложения) — в многостраничных приложениях каждая страница отправляет запрос на сервер и полностью обновляет все данные. Даже если эти данные небольшие. Таким образом тратятся ресурсы как сервера, так и браузера клиента на перерисовку одних и тех же элементов. Соответственно это сказывается на работоспособности сайта. Поэтому многие разработчики, для того чтобы повысить скорость и уменьшить нагрузку, используют комбинированный подход: сайт состоит из разных страниц (главная, корзина, категории товаров, информация и т.п.), но на каждой странице есть динамическая составляющая работы, например, на странице категории товаров при работе с фильтрами товары подгружаются/обновляются/фильтруются с помощью JavaScript (без перезагрузки всей страницы).
• Паттерн (Design Pattern — Шаблон проектирования) — многократно используемые архитектурные конструкции для решения известных и распространенных проблем проектирования программного обеспечения.
  MVC, MVP и MVVM — три популярных шаблона проектирования в разработке программного обеспечения.
• MVC — Model-View-Controller в веб-приложении: 1) Пользователь вводит URL-адрес, 2) Контроллер (Controller) получает этот запрос, 3) Контроллер использует Модель (Model) для получения всех необходимых данных, организует их, и пересылает их 4) Представлению (View), которое затем использует эти данные, чтобы отрисовать готовую страницу для пользователя в браузере. Т.е. Модель — это механизм общения с базой данных. Контролер — это функционал, который управляет последовательностью действий, принимает данные и передает их. View — отвечает за фронтэнд (frontend), то что видит пользователь.
• Паттерн MVP (Model-View-Presenter) — шаблон проектирования, производный от MVC, который используется в основном для построения пользовательского интерфейса. Состоит из 1) Модели (данные для отображения), 2) Вида/View (отображает данные из модели, обращается к Presenter), и 3) Представитель/Presenter (реализует взаимодействие между Моделью и Видом и содержит в себе всю бизнес-логику). По сути Presenter — это контроллер MVC, за исключением того, что он вообще не привязан к View, а просто взаимодействует с интерфейсом. Это решает проблемы тестируемости, а также проблемы модульности / гибкости, которые у нас были с MVC. Presenter сидят на одном уровне с View, слушая события как из View, так и из Model, и связывает действия между ними.
• Паттерн MVVM (Model-View-View Model) — модель, представление и третий компонент – дополнительная модель под названием ViewModel. MVVM позволяет нам создавать специфичные для View подмножества модели, которые могут содержать информацию о состоянии и логике, избегая необходимости представлять всю модель для представления. Шаблон MVVM поддерживает двустороннюю привязку данных между View и View-Model. Это позволяет автоматически распространять изменения внутри состояния View-Model на View.

И MVP, и MVVM являются производными от MVC. Основное различие между MVC и его производными заключается в зависимости каждого слоя от других уровней, а также от того, насколько тесно они связаны друг с другом.

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

• ESB (Enterprise Service Bus «сервисная шина предприятия») — это концепция, элемент архитектуры IT-ландшафта, используемый для решения задачи интеграции разрозненных информационных систем в единый программный комплекс с централизованным управлением передачей информации и применением сервис-ориентированного подхода. Архитектура ESB строится на 3 компонентах: набор коннекторов, очередь сообщений, платформа. Архитектура ESB заключается во взаимодействии всех приложений через единую точку. При замене одного приложения, подключенного к шине, нет необходимости перенастраивать остальные.
• SOLID — принцип, за которым скрывается рекомендация следовать 5 базовым принципам ООП:
  • Single Responsibility Principle (принцип единственности ответственности) — один класс отвечает за один функционал.
  • Open/Closed Principle (принцип открытости/закрытости) — программные сущности должны быть открыты к расширению, но закрыты к изменению.
  • Liskov Substitution Principle (принцип подстановки Барбары Лисков) — сущность, которая использует объект, реализующий определенный интерфейс, должна иметь возможность использовать другой объект с тем же интерфейсом, даже не зная об этом. Подклассы не могут замещать поведения базовых классов. Подтипы должны дополнять базовые типы.
  • Interface Segregation Principle (принцип разделения интерфейса) — клиенты не должны зависеть от методов, которые они не используют. Слишком «толстые» интерфейсы необходимо дробить на более мелкие и специфические, чтобы клиенты маленьких интерфейсов знали только о методах, которые необходимы им в работе.
  • Dependency Inversion Principle (принцип инверсии зависимостей) — Модули верхнего уровня не зависят от модулей нижнего уровня. И те, и другие должны зависеть от абстракций. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.
• KISS («Keep It Simple, Stupid» или «Keep It Short and Simple«) — это принцип проектирования и программирования, согласно которому основной целью (ценностью) при разработке системы является её простота. Большинство систем работают лучше всего, если они остаются простыми, а не усложняются. Основная суть принципа: 1) нужно реализовывать только тот функционал, который необходим пользователю и описан в ТЗ, не нужно закладывать в проект избыточные функции «про запас». 2) не нужно делать реализацию сложной универсальной бизнес-логики под все варианты поведения системы (это невозможно и с коммерческой точки зрения не принесет выгоды). 3) не стоит подключать огромную библиотеку ради пары функций.
• DRY (Don’t Repeat Yourself) — не повторяйся. Принцип DRY известен также как DIE (Duplication Is Evil) — дублирование это зло. Принцип состоит в том, что нужно избегать использования одного и того же кода. Дубли кода лучше заменять на универсальные свойства и/или функции.
• YAGNI (You Aren’t Gonna Need It) — «Вам это не понадобится» — это принцип проектирования программ/систем, согласно которому в качестве главной цели (ценности) является отказ от избыточной функциональности, которая не заявлена заказчиком. Исходя из экономики проекта можно сделать вывод, что любые реализованные «фичи» были оплачены либо Заказчиком, либо Исполнителем. В одном случае это завышенный бюджет проекта, в другом случае это уменьшенная прибыль. Любые дополнительные фичи в дальнейшем усложняют эксплуатацию систем/программ/проектов, увеличивают количество ошибок и снижают понимание клиентом продукта. Есть такая поговорка «лучший код — это ненаписанный код». Помните, что ни одно гибкое решение никогда не будет достаточно гибким. При изменении входных параметров в системе что-то может «сломаться», испортится бизнес-логика и т.д.
• GRASP (General Responsibility Assignment Software Patterns) — это шаблоны, используемые в объектно-ориентированном проектировании для решения общих задач по назначению ответственностей классам и объектам. GRASP состоит из 5 основных и 4 дополнительных шаблонов.
• SoC (Separation of Concerns) — это принцип в области разработки программного обеспечения, суть которого заключается в следующем: не пишите свою программу как один сплошной блок, вместо этого разбивайте код на куски, которые представляют собой крошечные фрагменты системы, каждый из которых способен выполнить простую отдельную работу. Разделение ответственностей — это процесс разделения компьютерной программы на функциональные блоки, которые не будут перекрывать функции друг друга.
• 4C’s (Clean Code > Clever Code) — дословно означает «Чистый код -> Умный код». Отладка в два раза сложнее написания первоначального кода.
• SLAP (Single Level Of Abstraction) — это Принцип Единого Уровня Абстракции: Идея заключается в том, что в рамках определенного метода/функции мы должны стремиться сохранить весь код на одном уровне абстракции, чтобы легче было его читать. Весь смысл заключается в том, чтобы при чтении кода нам приходилось держать в голове меньше контекста о коде и мы могли просто прочитать код и быстро понять, что происходит. Раскладывайте длинные методы/функции на более короткие методы/функции, каждый из которых несет решает одну задачу и имеет четкое название, прочитав которое станет понятно, что функция делает.

Протоколы передачи финансовых данных

• FIX (Financial Information eXchange) — открытый стандарт передачи информации в электронном виде, который передает финансовую информации и автоматизации коммуникаций на фондовом рынке. Протокол не справлялся с возросшим объёмом финансовой информации, генерируемой на фондовом рынке. При передачи больших объёмов данных с помощью FIX возникали значительные задержки в их обработке, что приносило трейдерам убытки и лишало их возможности разработки действующих торговых стратегий. Поэтому в 2004 году было решено разработать новый протокол (FAST), целью которого было добиться возможности передачи больших объёмов данных, избегая появления задержек в получении информации.
  
• FAST (FIX Adapted for STreaming) — бинарный вариант протокола FIX, который был адаптирован для поточной передачи данных по сети. FAST позволяет в более компактном виде передавать большие объёмы информации о рыночных сделках, применяется в высокоскоростных торговых системах, требующих низких задержек передачи. Трейдеры могут получать по FAST таблицы финансовых инструментов (цены, объёмы торгов и т.п.), котировки, все сделки, индексы, а также информацию обо всех активных обезличенных заявках. Используется на многих мировых биржах, в том числе и на Московской бирже и Санкт-Петербургской бирже.

Архитектурные подходы к проектированию модели данных

• Kimball — это
• Inmon — это
• Data Vault — это
• Data Lake — это

ETL, ELT, Data Pipeline — термины по обработке данных

Что такое Data Pipeline или Конвейер данных?

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

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

Конвейер данных не требует, чтобы конечным пунктом назначения было хранилище данных. Он может направлять данные в другое приложение, такое как инструмент визуализации или Salesforce. Думайте о Data Pipeline как об окончательной сборочной линии.

Чем конвейер данных отличается от ETL?

ETL расшифровывается как Extract, Transform и Load. Системы ETL извлекают данные из одной системы, преобразуют их и загружают в базу данных или хранилище данных. Устаревшие конвейеры ETL обычно работают в пакетном режиме, что означает, что данные перемещаются единым большим блоком в определенное время в целевое хранилище данных. Как правило, это происходит по заданному расписанию или через регулярные запланированные интервалы. Например, вы можете настроить запуск пакетов в 00:30 каждый день, когда нагрузка на системы учета (ERP, MES и т.д.) низкая.

«Конвейер данных» является более широким термином, который охватывает ETL как подмножество. Конвейер данных относится к системе для перемещения данных из одной системы в другую. Данные могут преобразовываться или не преобразовываться, и они могут обрабатываться в режиме реального времени (в потоковом режиме) вместо пакетного типа обработки. Кроме того, данные могут не загружаться в базу данных или хранилище данных. Конвейер данных может использоваться для разных целей: таких как корзина AWS (контейнеры для объектов) или озеро данных, или может запускать триггер в другой системе, например, для запуска определенного бизнес-процесса.

ETL и ELT

7 отличий ETL от ELT:

1. ETL — это извлечение, преобразование и загрузка данных, а ELT — извлечение, загрузка и преобразование данных.
2. В ETL данные перемещаются из источника данных в промежуточное хранилище (Data Staging) и затем в хранилище данных.
3. ELT использует хранилище данных для базовых преобразований. Data Staging не требуется.
4. ETL обеспечивает конфиденциальность данных (data privacy), производится очистка данных и их преобразования.
5. ETL может выполнять сложные преобразования данных и может быть более рентабельным, чем ELT.
6. ETL применяется для работы с хранилищами данных
7. ELT применяется, когда необходимо создавать озера данных.

Извлечение (Extract): это выгрузка исходных данных из исходной базы данных или источника данных (API, Excel, txt, csv и т.д.). При использовании ETL данные попадают во временную промежуточную область. В ELT данные сразу попадают в систему хранения озера данных.
Преобразование (Transform): это процесс изменения структуры информации, поэтому оно интегрируется с целевой системой данных и остальными данными в этой системе.
Загрузка (Load): относится к процессу внесения информации в систему хранения данных.

Что такое ETL?

ETL (или Извлечение, Преобразование, Загрузка) — это сбор и обработка данных из различных источников в одно хранилище данных, где они могут быть проанализированы. Ваша компания имеет доступ ко многим источникам данных, но чаще всего эти данные представляются менее полезным для вас способом. Результаты этого анализа могут быть использованы для информирования ваших бизнес-стратегий и решений.

Что такое ELT?

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

Для начала рассмотрим термин «Озера данных» — это особые виды хранилищ данных, которые, в отличие от хранилищ данных OLAP, принимают любые виды структурированных или неструктурированных данных. Озера данных не требуют от вас преобразования данных перед их загрузкой. Вы можете немедленно загрузить любую необработанную информацию в озеро данных, независимо от ее формата или отсутствия формата. Преобразование данных все еще необходимо, прежде чем анализировать данные с помощью платформы бизнес-аналитики. Однако очистка, обогащение и преобразование данных происходят после загрузки данных в озеро данных.

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

Управление данными

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

Виды трансформации данных

• Дедупликация (нормализация) / Deduplication (normalizing): идентифицирует и удаляет дублирующую информацию.
• Перестройка ключей / Key restructuring: создание ключевых соединений одних таблиц с другими.
• Очистка / Cleansing: включает удаление старых, неполных и дублированных данных, чтобы максимизировать точность данных — путем анализа данных для удаления синтаксических ошибок, опечаток и фрагментов записей.
• Пересмотр формата / Format revision: преобразует форматы в разных наборах данных — таких как дата / время, мужчина / женщина и единицы измерения — в один согласованный формат.
• Деривация / Derivation: создает правила преобразования, которые применяются к данным. Например, может быть, вам нужно вычесть определенные затраты или налоговые обязательства из показателей доходов бизнеса, прежде чем анализировать их.
• Агрегирование / Aggregation: собирает и ищет данные, чтобы их можно было представить в виде сводного отчета.
• Интеграция / Integration: согласовывает различные имена / значения, которые применяются к одним и тем же элементам данных в хранилище данных, так что каждый элемент имеет стандартное имя и определение.
• Фильтрация / Filtering: выбирает определенные столбцы, строки и поля в наборе данных.
• Разделение / Splitting: разбивает один столбец на несколько столбцов.
• Присоединение / Joining: связывает данные из более чем одного источника, например, добавляет информацию о расходах на более чем одну платформу SaaS.
• Суммирование / Summarization: создает различные бизнес-показатели путем вычисления итоговых значений. Например, вы можете сложить все продажи, сделанные конкретным продавцом, чтобы создать метрики общих продаж за определенные периоды.
• Валидация / Validation: устанавливает автоматические правила, которым необходимо следовать при различных обстоятельствах. Например, если первые пять полей в строке имеют значение ПУСТО (NULL), вы можете пометить строку для исследования или запретить ее обработку с остальной информацией.

Системы мониторинга баз данных, IT-инфраструктуры

• Sentry — это
• ELK + elastalert — это
• Prometheus — это
• newrelic — это
• Kibana — это
• Grafana — это
• Zabbix — свободно распространяемая система универсального мониторинга любой IT инфраструктуры (сервисов компьютерной сети, серверов и сетевого оборудования), облачных ресурсов, сервисов и приложений, написанная Алексеем Владышевым. Для хранения данных используется MySQL, PostgreSQL, SQLite или Oracle Database, веб-интерфейс написан на PHP.

Системы/Приложения/Сервисы для проектирования пользовательских интерфейсов

• Balsamiq — это
• Axure — это
• Pencil — это
• Visio — это
• app.diagrams.net — это

Системы управления конфигурацией

• Ansible — это

Терминология для разработчика (независимо от языка программирования)

• DevOps. Термин, объединяющий разработку и эксплуатацию. Объединяет методы и шаблоны, способствующие налаживанию сотрудничества между специалистами команды разработчиков, направляет процесс разработки высококачественного программного обеспечения. Эти методы и шаблоны помогают командам писать пригодные для тестирования и поддержания кодов пакетные продукты, развертки и сохранять развертку кода.
• Выпуск продукта (Product Release). Выпуск продукта ПО может состоять из нового продукта или функций уже существующего. В контексте Agile функция может складываться из одной и более пользовательских историй.
• Продукт с минимальным функционалом (MVP) — продукт, который имеет достаточно ключевых функций, позволяющих делать развертку на небольшие группы потенциальных клиентов. Эти люди формируют часть цикла обратной связи build-measure-learn, или проверенного обучения, направляя дальнейшую разработку и принятие решений. Продукт с минимальным функционалом также используется для представления последних внесенных изменений, которые могут повысить его привлекательность для клиентов.
• Разработка на основе наборов (Set-based Development). В процессе разработки на основе наборов несколько специалистов или команд, независимо друг от друга, предлагают варианты решения проблемы. Заинтересованные стороны, представители бизнеса или другие участники процесса оценивают результаты и выбирают наиболее подходящий.
• Разработка на основе приемочного тестирования (Acceptance-Test-Driven Development, ATDD). Командам, занимающимся разработкой на основе приемочного тестирования, выполнимые тесты помогают определять примеры, полученные во время обсуждений работы с заказчиком. Каждый пример уточняется и представляется в выполнимом формате. Программисты при разработке функций используют тесты как руководство. Когда код написан, Тестирование может проводиться как автоматизированное регрессионное, документирующее поведение функций.
• Разработка через тестирование (Test-Driven Development, TDD). При разработке через тестирование программист, прежде чем написать минимальное количество кода, который позволит провести успешную проверку, создает и автоматизирует маленькие модульные тесты, которые изначально выдают ошибки. Код проходит рефакторинг для того, чтобы соответствовать стандартам. Производственный код написан так, чтобы пропускать по одному тесту за один раз. TDD также называют дизайном на основе тестов, поскольку этот процесс больше относится к методу написания кода, чем к тестированию, и помогает создать надежный, простой в обслуживании код.
• Разработка через поведение (Behavior-Driven Development, BDD). Примеры желаемого поведения, полученные от представителей заказчика, переводятся в выполнимые тесты в формате given_when_then. Программисты автоматизируют тесты, а затем пишут код для прохождения каждого из них. Разработка через поведение может быть использована на модульном уровне для дизайна на основе проверок и бизнес-ориентированных тестов, охватывающих множество компонентов и уровней приложения.
• Технический долг (Technical Debt). Когда команда разработчиков идет по пути наименьшего сопротивления и жертвует качеством ради того, чтобы бизнес мог воспользоваться ситуацией, они образуют долг в плохо спроектированном софте, не защищенном регрессионным тестированием или провисающем по другим качественным характеристикам. Если команда не находит времени, чтобы «выплатить» долг с помощью рефакторинга или добавления автоматизированных регрессионных тестов, разрабатывать новые функции становится сложнее, и «общий» долг замедляет работу команды.
• Унаследованная система (Legacy System). Система, не поддерживаемая автоматизированными регрессионными тестами. Внесение изменений в унаследованный код или его рефакторинг может представлять риски, поскольку не существует тестов, способных уловить незапланированные изменения в поведении системы.
• Legacy Code — это ценный код, доставшийся в наследство от предыдущих разработчиков, который Вы боитесь изменить, потому что не знаете, как внести изменения и при этом не нарушить существующее поведение системы или программы. Legacy code — тяжелая наследственность, устаревший код, который более не поддерживается и не обновляется, но используется.
• IaaS, PaaS и SaaS — это основные модели предоставления облачных услуг.
  • Инфраструктура как сервис (Infrastructure as a Service, IaaS). Модель обслуживания, следуя которой организация использует облачные сервисы для поддержки эксплуатации, включая хранение данных, оборудование, серверы и сетевые компоненты. Сервисы принадлежат провайдеру, который отвечает за их размещение, работу и поддержку. Как правило, клиент платит по факту использования. В IaaS клиент получает только инфраструктуру. Пример: «виртуальный дата-центр» от Selectel или CloudLITE.
  • Платформа как услуга (Platform-as-a-Service, Paas). Разновидность ПО как услуги. Модель предоставления услуг, позволяющая заказчику арендовать виртуальные серверы и сопутствующие услуги для работы существующих приложений или разработки новых. В PaaS — инфраструктуру и подготовленное для разработки приложений ПО. Пример: Облачная среда разработки Codenvy, Microsoft Azure или AWS.
  • ПО как сервис (Software-as-a-Service, SaaS). В этой модели обслуживания подрядчик или провайдер самостоятельно размещает приложения. Вместо того, чтобы установить ПО на собственное оборудование (случай «ПО как продукт»), клиенты получают доступ к нему на серверах провайдера по сети, используя, как правило, подключение к интернету. В SaaS — готовое работающее в облаке приложение. Пример: amoCRM, Bitrix24, МойСклад, МангоТелеком и др.

Сообщение Язык программирования Python 3. Обзор библиотек принципов modules появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

Функции Python 3 — Краткая шпаргалка

Функции – главный и самый важный способ организации и повторного использования кода в Python. Функций не может быть слишком много. 1 функция — это блок кода, который используется для выполнения одного связанного действия.

В Python есть два инструмента для создания функций: def и lambda.

Сначала рассмотрим def. К lambda функции вернемся позже.

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

Объявление функции начинается ключевым словом def, а результат возвращается в предложении return:

def my_function(x, y, z=1.5):
    if z > 1:
        return z * (x + y)
    else:
        return z / (x + y)

Ничто не мешает иметь в функции несколько предложений return. Если при выполнении достигнут конец функции, а предложение return не встретилось, то возвращается None.

У функции могут быть позиционные и именованные аргументы.

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

В примере выше:

• x и y – позиционные аргументы,
• а z – именованный.

Следующие вызовы функции эквивалентны:

my_function(5, 6, z=0.7)
my_function(3.14, 7, 3.5)

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

Определение функции Python 3

Вы можете задать функции для реализации нужной вам функциональности. Вот простые правила для определения функции в Python.

• Ключевое слово для определения функции: def, за которым следуют имя функции и круглые скобки () с параметрами.
• Любые входные параметры или аргументы должны быть помещены в эти круглые скобки.
• В качестве первой команды может быть необязательная конструкция — строка документации функции (эта часть функции — пояснение зачем функция создана, очень рекомендуется использовать для облегчения понимания кода при работе в команде или при повторном возвращении к коду через длительный промежуток времени).
• Блок кода в каждой функции начинается с двоеточия : и имеет отступ.
• Оператор return [выражение] возвращает результат из функции. Оператор return без аргументов аналогичен return None. Функции всегда возвращают значение, хотя бы None.

Синтаксис функции Python

def function_name( parameter1, parameter2 ):
   """function_docstring: функция Python предназначена для расчета ROI"""
   function_suite (algorithms, expressions)
   return [expression]

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

Пример реализации функции

Следующая функция принимает строку в качестве входного параметра и печатает ее на стандартном экране.

def print_me( str ):
   """Выводит на печать переданную строку в эту функцию"""
   print(str)
   return

Вызов функции

В определении функции указывается имя функции, её параметры, а также тело функции (реализация требуемой функциональности).

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

# Определение функции
def printme( str ):
    """This prints a passed string into this function"""
    print(str)
    return

# Теперь вы можете вызвать функцию printme
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Результат:

I'm first call to user defined function!
Again second call to the same function

Аргументы функции

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

• Обязательные аргументы
• Ключевые аргументы
• Аргументы по умолчанию
• Аргументы переменной длины

Обязательные (позиционные) аргументы

Позиционные аргументы: указываются простым перечислением

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

Чтобы вызвать функцию printme() , вам обязательно нужно передать один аргумент, иначе она выдаст следующую синтаксическую ошибку:

# Определение функции
def printme( str ):
   """This prints a passed string into this function"""
   print(str)
   return

# Теперь вы можете вызвать функцию printme
printme()

Ошибка (в функции Printme не указан аргумент):

Traceback (most recent call last):
  File "C:/Users/User/Desktop/CodePythonFunc.py", line 8, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

Правильно указать аргумент так:

# Определение функции
def printme( str ):
   """This prints a passed string into this function"""
   print(str)
   return

# Теперь вы можете вызвать функцию printme
printme("Текстовая переменная")

Ключевые аргументы

Ключевые аргументы: указываются перечислением ключ=значение

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

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

# Определение функции
def printinfo( name, age ):
   "This prints a passed info into this function"
   print("Name: " + name + "|Age: " + str(age))
   return

# Вызов функции printinfo
printinfo( age=23, name="Anton" )
printinfo( name="Alena", age=20 )

Результат:

Name: Anton|Age: 23
Name: Alena|Age: 20

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

Преимущества ключевых аргументов в функциях

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

Аргументы по умолчанию

Аргумент по умолчанию — это аргумент, который принимает значение по умолчанию (задается в описании функции), если при вызове функции аргументу не передается значение.

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

# Определение функции
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print("Name: " + name + "|Age: " + str(age))
   return

# Вызов функции printinfo
printinfo( age=19, name="Семен" )
printinfo( name="Николай" )

Результат:

Name: Семен|Age: 19
Name: Николай|Age: 35

Аргументы переменной длины

Передача кортежа в функцию — Использование *args в Python

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

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

Синтаксис для функции с аргументами переменной длины следующий:

def function_name([formal_args,] *args_tuple ):
    """function_docstring"""
    function_body
    return [expression]

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

Рассмотрим простой пример:

# Определение функции
def print_info( parametr_1, *var_tuple ):
   """Эта функция производит вывод переданных аргументов"""
   print("Output is: ")
   print(parametr_1)
   for elem in var_tuple:
      print(elem)
   return

# Вызов функции printinfo
print_info( 10 )
print_info( 70, 60, 50 )

Результат:

Output is: 
10
Output is: 
70
60
50

Еще один пример использования *args в функции Python:

def multiply(*args):
    z = 1
    for num in args:
        z *= num
    print(z)

multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)

Результат:

20
90
24
900

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

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

Передачи словаря переменной длины с аргументами в функцию **kwargs

**kwargs — сокращение от “keyword arguments”

Форма двойной звездочки **kwargsиспользуется для передачи словарного словаря с аргументами переменной длины в функцию. Опять же, две звездочки ( **) являются здесь важным элементом, так как слово kwargsиспользуется условно, но не поддерживается языком.

Мол *args, **kwargsможет принять столько аргументов, которые вы хотели бы привести к этому. Однако **kwargsотличается от того, *argsчто вам нужно будет назначить ключевые слова.

Во-первых, давайте просто распечатаем **kwargsаргументы, которые мы передаем функции. Мы создадим короткую функцию для этого:

def print_kwargs(**kwargs):
        print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

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

{'kwargs_1': 'Shark', 'kwargs_2': 4.5, 'kwargs_3': True}

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

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

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

def print_values(**kwargs):
    for key, value in kwargs.items():
        print("The value of {} is {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

Результат:

The value of my_name is Sammy
The value of your_name is Casey

Использование **kwargsдает нам гибкость в использовании ключевых аргументов в нашей программе. Когда мы используем **kwargsв качестве параметра, нам не нужно знать, сколько аргументов мы в конечном итоге хотели бы передать функции.

Использование *args и **kwargs в вызовах функций

Мы также можем использовать *argsи **kwargsдля передачи аргументов в функции.

Сначала давайте рассмотрим пример с *args.

def some_args(arg_1, arg_2, arg_3):
    print("arg_1:", arg_1)
    print("arg_2:", arg_2)
    print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")
some_args(*args)

В функции выше, существует три параметра , определенный как arg_1, arg_и arg_3. Функция распечатает каждый из этих аргументов. Затем мы создаем переменную, для которой задано итеративное значение (в данном случае кортеж ), и можем передать эту переменную в функцию с синтаксисом звездочки.

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

arg_1: Sammy
arg_2: Casey
arg_3: Alex

Мы также можем изменить вышеприведенную программу для типа данных итеративного списка с другим именем переменной. Давайте также объединим *argsсинтаксис с именованным параметром:

def some_args(arg_1, arg_2, arg_3):
    print("arg_1:", arg_1)
    print("arg_2:", arg_2)
    print("arg_3:", arg_3)

my_list = [2, 3]
some_args(1, *my_list)

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

arg_1: 1
arg_2: 2
arg_3: 3

Аналогично, **kwargsаргументы с ключевым словом могут использоваться для вызова функции. Мы установим переменную, равную словарю с 3 парами ключ-значение (мы будем использовать kwargsздесь, но она может называться как угодно), и передадим ее функции с 3 аргументами:

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
    print("kwarg_1:", kwarg_1)
    print("kwarg_2:", kwarg_2)
    print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}
some_kwargs(**kwargs)

Результат:

kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

Мы можем использовать специальный синтаксис *args и **kwargs внутри определения функции, чтобы передать переменное число аргументов функции.

Создание функций, которые принимают *argsи **kwargsлучше всего использовать в ситуациях, когда вы ожидаете, что количество входов в списке аргументов останется относительно небольшим. Использование *argsи **kwargsв первую очередь для обеспечения удобочитаемости и удобства, но следует делать с осторожностью.

Комбинирование параметров *args и **kwargs в функции

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

def func(*args, **kwargs):
    """Функция примет любые параметры и выведет их на печать"""
    for elem in args:                   # Перебираем список с переданными параметрами
        print(elem, end=" ")
    for key, value in kwargs.items():   # Перебираем словарь с переданными параметрами
        print("{0} => {1}".format(key, value), end=" ")
    print("") #Перенос строки

func(35, 10, a=1, b=2, c=3) # Выведет: 35 10 a => 1 c => 3 b => 2
func(10)                    # Выведет: 10
func(3, a=1, b=2)           # Выведет: a => 1 b => 2

Результат:

35 10 a => 1 b => 2 c => 3 
10 
3 a => 1 b => 2 

Еще один пример использования комбинации *args & **kwargs:

# Описываем функцию
def echo(*args, **kwargs):
    print(args, kwargs)

# Задаем список
args = (10, 20)
# Задаем словарь
kwargs = {'a':30, 'b':40}

#Вызываем функцию
echo(*args, **kwargs)

Результат:

(10, 20) {'a': 30, 'b': 40}

Порядок аргументов в функции Python

Аргументы внутри вызова функции должны стоять в определенном порядке:

1. Позиционные аргументы (arg_1, arg_2)
2. *args
3. Ключевые аргументы (kw_1=»значение 1″, kw_2=»значение 2″)
4. **kwargs

Рассмотрим детальный пример с использованием всех функций:

def function_print(arg_1, arg_2, *args, kw_1="значение 1", kw_2="значение 2", **kwargs):
    """ Обобщенный пример вывода всех аргументов, переданных функции """
    print("===Позиционные аргументы===")
    print(str(arg_1) + "," + str(arg_2))
    print("===*args===")
    for elem in args: # Перебираем список с переданными параметрами
        print(elem, end=" ")
    print("") #Перенос строки
    print("===Ключевые аргументы===")
    print(kw_1 + "," + kw_2)
    print("===**kwargs===")
    for key, value in kwargs.items(): # Перебираем словарь с переданными параметрами
        print("{0} => {1}".format(key, value), end=" ")
    print("") #Перенос строки


function_print(1, 2, 4, kw_2="Иван", var1=4)

Результат:

===Позиционные аргументы===
1,2
===*args===
4 
===Ключевые аргументы===
значение 1,Иван
===**kwargs===
var1 => 4 

Передача списка (list) по ссылке в функцию

def myfunction (list):
    list.append(40)
    print ("Modified list inside a function: ", list)
    return

mylist=[10,20,30]
myfunction(mylist)
print(mylist)

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

Modified list inside a function: [10, 20, 30, 40]
[10, 20, 30, 40]

Пространства имен, области видимости и локальные функции

Область действия переменной — область видимости переменных

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

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

• Глобальные переменные
• Локальные переменные

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

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

Переменные внутри функции – локальные. Поиск переменных: сперва среди локальных, потом среди глобальных.

Рассмотрим следующую функцию:

def func():
    a = []
    for i in range(5):
        a.append(i)

При вызове func() создается пустой список a, в него добавляется 5 элементов, а затем, когда функция завершается, список a уничтожается. Но допустим, что мы объявили a следующим образом:

a = []
def func():
    for i in range(5):
        a.append(i)

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

a = None

def bind_a_variable():
    global a
    a = []

bind_a_variable()
print a

Результат:

[]

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

def outer_function(x, y, z):
    def inner_function(a, b, c):
        pass
    pass

Здесь функция inner_function не существует, пока не вызвана функция outer_function. Как только outer_function завершает выполнение, inner_function уничтожается.

Не рекомендуется злоупотреблять ключевым словом global. Обычно глобальные переменные служат для хранения состояния системы. Если вы понимаете, что пользуетесь ими слишком часто, то стоит подумать о переходе к объектно-ориентированному программированию (использовать классы).

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

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

Возврат нескольких значений из одной функции

В Python существует возможность возвращать из функции несколько значений.

Вот простой пример:

def f():
    a = 5
    b = 6
    c = 7
    return a, b, c
var1, var2, var3 = f()

print("var1={0} var2={1} var3={2}".format(var1, var2, var3))

Результат:

var1=5 var2=6 var3=7

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

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

Этот пример можно было бы записать и так:

def f():
    a = 5
    b = 6
    c = 7
    return a, b, c
return_value = f()

print(return_value)

Результат:

(5, 6, 7)

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

Иногда разумнее возвращать несколько значений не в виде кортежа, а в виде словаря:

def f():
    a = 5
    b = 6
    c = 7
    return {'a' : a, 'b' : b, 'c' : c}

return_value = f()

print(return_value)

Результат:

{'a': 5, 'b': 6, 'c': 7}

Функции являются объектами

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

states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda', 'south carolina##', 'West virginia?']

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

Первая попытка могла бы выглядеть так:

import re # Модуль регулярных выражений

def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip()
        value = re.sub('[!#?]', '', value) # удалить знаки препинания
        value = value.title()
        result.append(value)
    return result

states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda', 'south carolina##', 'West virginia?']

states = clean_strings(states)

print(states)

Результат:

['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'South Carolina', 'West Virginia']

Другой подход, который иногда бывает полезен, – составить список операций, которые необходимо применить к набору строк:

import re # Модуль регулярных выражений

def remove_punctuation(value):
    return re.sub('[!#?]', '', value)

def clean_strings(strings, ops):
    result = []
    for value in strings:
        for function in ops:
            value = function(value)
        result.append(value)
    return result

clean_ops = [str.strip, remove_punctuation, str.title]
states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda', 'south carolina##', 'West virginia?']

states = clean_strings(states, clean_ops)

print(states)

Результат:

['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'South Carolina', 'West Virginia']

Подобный функциональный подход позволяет задать способ модификации строк на очень высоком уровне. Степень повторной используемости функции clean_strings определенно возросла!

Функции можно передавать в качестве аргументов другим функциям, например встроенной функции map, которая применяет переданную функцию к коллекции:

import re # Модуль регулярных выражений

def remove_punctuation(value):
    return re.sub('[!#?]', '', value)

states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda', 'south carolina##', 'West virginia?']

states = list(map(remove_punctuation, states))
states = list(map(str.strip, states))
states = list(map(str.title, states))

print(states)

Результат:

['Alabama', 'Georgia', 'Georgia', 'Georgia', 'Florida', 'South Carolina', 'West Virginia']

Анонимные функции или Лямбда-функции. Lambda Function Python 3

• Лямбда-функции позволяют создавать «встроенные» функции, которые полезны для функционального программирования. Например, с Map, Filter или Reduce.
• Lambda — это инструмент для создания обработчиков обратного вызова (callback handlers).

Lambda Function — это анонимная однострочная функция, которая возвращает всегда 1 результат.

Определяются они с помощью ключевого слова lambda

ИмяФункции = lambda переменная_1, переменная_2, …, переменная_N: <выражение, которое использует переменные>

Например, функция equiv_anon:

equiv_anon = lambda x: x * 2

эквивалентна функции short_function:

def short_function(x):
    return x * 2

Лямбда-функции особенно удобны в ходе анализа данных, потому что, как вы увидите, во многих случаях функции преобразования данных принимают другие функции в качестве аргументов. Часто быстрее (и чище) передать лямбда-функцию, чем писать полноценное объявление функции или даже присваивать лямбда-функцию локальной переменной.

Рассмотрим такой простенький пример:

def apply_to_list(some_list, f):
    return [f(x) for x in some_list]

ints = [4, 0, 1, 5, 6]

result = apply_to_list(ints, lambda x: x * 2)

print(result)

Результат:

[8, 0, 2, 10, 12]

Можно было бы, конечно, написать [x * 2 for x in ints], но в данном случае нам удалось передать функции apply_to_list пользовательский оператор.

Еще пример: пусть требуется отсортировать коллекцию строк по количеству различных букв в строке.

Для этого можно передать лямбда-функцию методу списка sort:

strings = ['foo', 'card', 'bar', 'aaaa', 'abab']

strings.sort(key=lambda x: len(set(list(x))))

print(strings)

Результат:

['aaaa', 'foo', 'abab', 'bar', 'card']

Для чего хороша лямбда-функция? Зачем нужная lambda function в Python?

Ответ:

• Нам не нужна лямбда функция, мы могли бы обойтись без нее. Но…
• Есть определенные ситуации, когда это удобно — lambda делает написание кода немного легче, а написанный код — немного чище.

Какие ситуации?

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

Обычно функции создаются для одной из двух целей: (а) для уменьшения дублирования кода или (б) для модульности кода.

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

Но предположим, что вам нужно создать функцию, которая будет использоваться только один раз — вызываться только из одного места в вашем приложении. Ну, во-первых, вам не нужно давать имя функции. Это может быть «анонимно». И вы можете просто определить его прямо там, где вы хотите его использовать. Вот где лямбда полезна.

Еще один пример использования lambda функции:

colors = ["Goldenrod", "Purple", "Salmon", "Turquoise", "Cyan"]

normalized_colors = list(map(lambda s: s.casefold(), colors))

print(normalized_colors)

Результат:

['goldenrod', 'purple', 'salmon', 'turquoise', 'cyan']

Неправильное использование: именование лямбда-выражений

PEP8, официальное руководство по стилю Python, советует никогда не писать такой код:

normalize_case = lambda s: s.casefold()

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

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

def normalize_case(s): return s.casefold()

PEP8 рекомендует это, потому что именованные функции — это обычная и понятная вещь. Именованная функция также имеет следующее преимущество: назначая нашей функции правильное имя, Вы упрощаете отладку кода. В отличие от функций, определенных с помощью def, лямбда-функции никогда не имеют имени (это всегда <lambda>).

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

Неправильное использование: ненужные вызовы функций

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

Например, возьмем этот код:

sorted_numbers = sorted(numbers, key=lambda n: abs(n))

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

Поскольку abs (которая возвращает абсолютное значение числа) является функцией и все функции могут быть переданы, мы могли бы написать приведенный выше код следующим образом:

sorted_numbers = sorted(numbers, key=abs)

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

pairs = [(4, 11), (8, 8), (5, 7), (11, 3)]
sorted_by_smallest = sorted(pairs, key=lambda items: min(items))

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

pairs = [(4, 11), (8, 8), (5, 7), (11, 3)]
sorted_by_smallest = sorted(pairs, key=min)

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

Замыкания: функции, возвращающие функции. Динамически сгенерированная функция

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

Вот очень простой пример:

def make_closure(a):
    def closure():
        print('Я знаю секрет: %d' % a)
    return closure

closure = make_closure(5)
closure()

Результат:

Я знаю секрет: 5

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

Так, в примере выше, возвращенное замыкание печатает строку «Я знаю секрет: 5», в какой бы момент ее ни вызвать. Хотя обычно создают замыкания со статическим внутренним состоянием (в данном случае только значение a), ничто не мешает включить в состав состояния изменяемый объект – словарь, множество, список – и затем модифицировать его.

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

def make_watcher():
    have_seen = {}

    def has_been_seen(x):
        if x in have_seen:
            return True
        else:
            have_seen[x] = True
        return False

    return has_been_seen

watcher = make_watcher()

vals = [5, 6, 1, 5, 1, 6, 3, 5]

print([watcher(x) for x in vals])

Результат:

[False, False, False, True, True, True, False, True]

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

def make_counter():
    count = [0]

    def counter():
        # увеличить счетчик и вернуть новое значение
        count[0] += 1
        return count[0]
    return counter

counter = make_counter()
print(counter())

Результат:

1

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

Вот пример функции форматирования строк:

def format_and_pad(template, space):
    def formatter(x):
        return (template % x).rjust(space)
    return formatter

fmt = format_and_pad('%.4f', 15)
print(fmt(1.756))

Результат:

'         1.7560'

Каррирование: частичное фиксирование аргументов функции

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

Пусть, например, имеется тривиальная функция сложения двух чисел:

def add_numbers(x, y):
    return x + y

Мы можем породить на ее основе новую функцию одной переменной, add_five, которая прибавляет к своему аргументу 5:

add_five = lambda y: add_numbers(5, y)

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

Теперь запустим полный код:

def add_numbers(x, y):
    return x + y

add_five = lambda y: add_numbers(5, y)

print(add_five(10))

Результат:

15

Стандартный модуль functools упрощает эту процедуру за счет функции partial:

from functools import partial

def add_numbers(x, y):
    return x + y

add_five = partial(add_numbers, 5)

print(add_five(10))

Также вернет 15

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

# вычислить скользящее среднее временного ряда x за 60 дней
ma60 = lambda x: pandas.rolling_mean(x, 60)
# вычислить скользящие средние за 60 дней всех временных рядов в data
data.apply(ma60)

Сообщение Функции Python 3: значение, аргументы, вызов, переменные, списки появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

В этой статье будет рассмотрено «Как создавать Интерактивные визуализации данных в Python 3 с помощью одной строки»

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

За последние несколько месяцев я понял, что единственная причина, по которой я использую matplotlib — это сотни часов, которые я потратил на изучение сложного синтаксиса. Это осложнение приводит к часам разочарования на StackOverflow, выясняя, как отформатировать дату или добавить вторую ось Y. К счастью, сейчас отличное время для построения графиков в Python, и после изучения разных вариантов графических библиотек явным победителем — с точки зрения простоты использования, документирования и функциональности — является библиотека Python. В этой статье мы подробно рассмотрим plotly, как создавать лучшие графики за меньшее время — часто с помощью одной строки кода.

Весь код этой статьи доступен на GitHub. Все графики являются интерактивными и могут быть просмотрены на NBViewer здесь.

Краткий обзор Plotly & Cufflinks

plotly Пакет Python — это библиотека с открытым исходным кодом, построенная на plotly.js, который в свою очередь построен на d3.js,Мы будем использовать wrapper на plotly, которые называются cufflinks, предназначенные для работы с Pandas DataFrames. Итак, весь наш стек это cufflinks > plotly > plotly.js > d3.js, что означает, что мы получаем эффективность кодирования в Python с невероятными интерактивными графическими возможностями d3.js.

(Сама Plotly — это графическая компания с несколькими продуктами и инструментами с открытым исходным кодом. Библиотека Python бесплатна, и мы можем создавать неограниченное количество диаграмм в автономном режиме и до 25 диаграмм в онлайн-режиме, чтобы поделиться ими со всем миром).

Вся работа в этой статье была выполнена в блокноте Jupyter с plotly + cufflinks, работающими в автономном режиме. После установки plotly и cufflinks с помощью инструкции pip install cufflinks plotly, необходимо импортировать следующие компоненты в Jupyter:

# Standard plotly imports
import plotly.plotly as py
import plotly.graph_objs as go
from plotly.offline import iplot, init_notebook_mode

# Using plotly + cufflinks in offline mode
import cufflinks
cufflinks.go_offline(connected=True)
init_notebook_mode(connected=True)

Распределения по одной переменной: Histograms и Boxplots

Одиночная переменная (single variable) — одномерный график — это стандартный способ начать анализ данных, а гистограмма — это график перехода ( хотя он имеет некоторые проблемы ) для построения графика распределения. Используя некоторую статистику (Скачать статистику >>> ), давайте создадим интерактивную гистограмму количества likes для статей (dfэто стандартный dataframe Pandas):

df['claps'].iplot(kind='hist', xTitle='claps',
                  yTitle='count', title='Claps Distribution')

Для тех, кто привык к matplotlib, все, что нам нужно сделать, это добавить еще одну букву ( iplotвместо plot), и мы получим намного более привлекательный и интерактивный график! Мы можем щелкнуть на колонке, чтобы получить более подробную информацию, увеличить масштаб участков и, как мы увидим позже, выбрать различные категории для выделения.

Если мы хотим построить наложенные гистограммы, это так же просто:

df[['time_started', 'time_published']].iplot(
    kind='hist',
    histnorm='percent',
    barmode='overlay',
    xTitle='Time of Day',
    yTitle='(%) of Articles',
    title='Time Started and Time Published')

С небольшим количеством манипуляций над pandas мы можем сделать barplot:

# Resample to monthly frequency and plot 
df2 = df[['view','reads','published_date']].\
         set_index('published_date').\
         resample('M').mean()
df2.iplot(kind='bar', xTitle='Date', yTitle='Average',
    title='Monthly Average Views and Reads')

Мы можем объединить возможности Pandas с plotly + cufflinks. Для boxplot по подписчикам по всей истории публикаций мы используем pivot, а затем plot (точнее iplot):

df.pivot(columns='publication', values='fans').iplot(
        kind='box',
        yTitle='fans',
        title='Fans Distribution by Publication')

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

Диаграммы рассеяния — Scatterplots

Диаграмма рассеяния (Scatterplots) — используется очень часто для анализа данных. Scatterplots позволяет видеть эволюцию переменной во времени или связь между двумя (или более) переменными.

Временные ряды (Time-Series)

Значительная часть данных реального мира содержит в себе временной параметр. К счастью, plotly + cufflinks были разработаны с учетом визуализации временных рядов. Давайте создадим базу данных по статьям и посмотрим, как изменились тенденции.

# Create a dataframe of Towards Data Science Articles
tds = df[df['publication'] == 'Towards Data Science'].\
         set_index('published_date')

# Plot read time as a time series
tds[['claps', 'fans', 'title']].iplot(
    y='claps', mode='lines+markers', secondary_y = 'fans',
    secondary_y_title='Fans', xTitle='Date', yTitle='Claps',
    text='title', title='Fans and Claps over Time')

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

• Автоматическое получение красиво отформатированного временного ряда по оси X
• Добавление вторичной оси Y, потому что наши переменные имеют разные диапазоны
• Добавление заголовка статей в качестве всплывающей информации

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

tds_monthly_totals.iplot(
    mode='lines+markers+text',
    text=text,
    y='word_count',
    opacity=0.8,
    xTitle='Date',
    yTitle='Word Count',
    title='Total Word Count by Month')

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

df.iplot(
    x='read_time',
    y='read_ratio',
    # Specify the category
    categories='publication',
    xTitle='Read Time',
    yTitle='Reading Percent',
    title='Reading Percent vs Read Ratio by Publication')

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

tds.iplot(
    x='word_count',
    y='reads',
    size='read_ratio',
    text=text,
    mode='markers',
    # Log xaxis
    layout=dict(
        xaxis=dict(type='log', title='Word Count'),
        yaxis=dict(title='Reads'),
        title='Reads vs Log Word Count Sized by Read Ratio'))

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

Как и прежде, мы можем комбинировать pandas с plotly+cufflinks для полезных графических представлений:

df.pivot_table(
    values='views', index='published_date',
    columns='publication').cumsum().iplot(
        mode='markers+lines',
        size=8,
        symbol=[1, 2, 3, 4, 5],
        layout=dict(
            xaxis=dict(title='Date'),
            yaxis=dict(type='log', title='Total Views'),
            title='Total Views over Time by Publication'))

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

Advanced Plots — Расширенные графические представления

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

Scatter Matrix

Когда мы хотим исследовать отношения между многими переменными, отличной опцией является точная матрица — scattermatrix (также называемая спломом или splom):

import plotly.figure_factory as ff
figure = ff.create_scatterplotmatrix(
    df[['claps', 'publication', 'views',      
        'read_ratio','word_count']],
    diag='histogram',
    index='publication')

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

Тепловая карта корреляции — Correlation Heatmap

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

corrs = df.corr()
figure = ff.create_annotated_heatmap(
    z=corrs.values,
    x=list(corrs.columns),
    y=list(corrs.index),
    annotation_text=corrs.round(2).values,
    showscale=True)

Список графиков можно продолжать и продолжать. Cufflinks также имеют несколько тем, которые мы можем использовать, чтобы получить совершенно другой стиль без каких-либо усилий. Например, ниже у нас есть график отношения (ratio plot) в теме «space»:

и график распространения (spread plot) в «ggplot»:

Мы также можем получить 3D-графики (поверхность surface и пузырь bubble).

surface plot:

bubble plot:

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

Редактирование в Plotly Chart Studio

Создавая эти графики в блокноте, вы увидите небольшую ссылку в правом нижнем углу на графике с надписью «Экспорт в plot.ly». Если вы щелкнете по этой ссылке, вы попадете в диаграммную студию, где сможете подправить свой график для окончательной презентации. Вы можете добавлять аннотации, указывать цвета и, в общем, убирать все для получения отличной фигуры. Затем вы можете опубликовать свою фигуру в Интернете, чтобы любой мог найти ее по ссылке.

Ниже приведены два графика, которые были скорректированы в Chart Studio:

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

Выводы
Хуже всего в заблуждении о затонувших затратах является то, что вы понимаете, сколько времени вы потратили впустую после того, как бросили работу. К счастью, теперь, когда я допустил ошибку, придерживаясь matploblibслишком долго, вам не нужно!

Когда мы думаем о построении библиотек, есть несколько вещей, которые мы хотим:

• Графики с одной переменной для быстрого исследования
• Интерактивные элементы для подбора / исследования данных
• Возможность копаться в деталях по мере необходимости
• Простая настройка для финальной презентации

На данный момент, лучший вариант для всего этого в Python — это plotly.

Plotly позволяет нам быстро создавать визуализации и помогает нам лучше понять наши данные с помощью интерактивности. Кроме того, давайте признаем, что построение графиков должно быть одной из самых приятных частей науки о данных! С другими библиотеками построение графиков превратилось в утомительное занятие, но с plotly снова есть радость в создании великой фигуры!

Сообщение Интерактивная визуализация данных в Python 3 появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

Flask vs Django: как понять, нужен ли вам молоток или ящик для инструментов

Если вам интересно, следует ли использовать Flask или Django для своего проекта, эта статья для вас. Обе платформы написаны на Python, поэтому опыт работы с этим языком программирования является ключевым. Согласно исследованию Python для разработчиков 2018 года JetBrains, два самых популярных фрейворка Python — это Flask и Django. Чтобы помочь Вам сделать осознанный выбор между этими фреймворками, мы обсудим, что такое Flask и Django, опишем их преимущества и недостатки, а также рассмотрим истории успеха.

Что такое Django и Flask?

Django — это бесплатная среда разработки веб-приложений Python с открытым исходным кодом, которая следует шаблону Model-Template-View (MTV). Он был создан осенью 2003 года Адрианом Головатым и Саймоном Уиллисоном.

Django был создан для упрощения процесса разработки сайта. Основное внимание уделяется повторно используемым компонентам, меньшему количеству кода и быстрой разработке. На него повлияли несколько более ранних фреймворков, в том числе Zope и Plone, и, в свою очередь, они вдохновили множество других фреймворков, которые последовали за ним, включая Pyramid, CherryPy, Bottle и Web2py.

Flask — это микрофреймворк с удивительным началом. Фактически он зародился как первоапрельская шутка. Перед разработкой Flask Армин Роначер, создатель Flask, написал два других решения:

• Werkzeug (серверная среда) и
• Jinja2 (библиотека шаблонов).

Армин подумал, что было бы интересно взять эти два решения и собрать их в zip-файл, поэтому он написал Denied Framework (как он называл его прежде, и назвал его Flask). Когда разработчик устанавливает этот Denied Framework, программа установки автоматически разархивирует файл и запускает эти два решения одновременно. Хотите верьте, хотите нет, но Flask получил положительную реакцию.

Основные различия между Django и Flask

Чтобы лучше понять, какая инфраструктура лучше всего подходит для вашего проекта, давайте рассмотрим основные различия между Django и Flask.

Django предоставляет свой собственный Django ORM (объектно-реляционное отображение) и использует модели данных, в то время как Flask вообще не имеет моделей данных. Модели данных позволяют разработчикам связывать таблицы базы данных с классами на языке программирования, чтобы они могли работать с моделями так же, как ссылки на базы данных. Почему у Flask нет модели данных? Потому что философия Flask отличается от философии Django.

Django связывает все вместе, а Flask более модульный.

Основное различие между Django и Flask в том, что Django предоставляет полнофункциональную среду Model-View-Controller.

Цель Django — упростить процесс разработки сайта. Он основан на меньшем количестве кода, повторно используемых компонентах и ​​быстрой разработке.

Flask, с другой стороны, представляет собой микрофреймворк, основанный на концепции «хорошо выполнять одну вещь». Он не предоставляет ORM и поставляется только с базовым набором инструментов для веб-разработки.

Приложения для Flask в основном представляют собой одностраничные приложения (SPA). Это хороший выбор для небольших и средних сайтов, таких как форумы и личные блоги. Django идеально подходит для крупных проектов, таких как сайты электронной коммерции и CMS.

Преимущества и недостатки этих фреймворков

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

Производительность

Производительность Flask vs Django является важным показателем функциональности системы. Если инфраструктура обладает высокой производительностью, это приведет к созданию масштабируемого, быстрого и безопасного приложения. Слабая производительность может привести к масштабным проблемам и архитектурным проблемам.

Если учесть, что производительность Django vs Flask имеет хорошие результаты и используется на сайтах с большим трафиком, что является отличным показателем их эффективности.

Пакеты

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

Django, с другой стороны, имеет огромное количество встроенных пакетов. Если быть точным, то на сентябрь 2019 года было 4046 пакетов Django. Это означает, что вы, скорее всего, найдете пакет для сборки и запуска своего приложения с меньшими усилиями.

Сообщество

В случае сравнения Python Django с Flask, Django имеет огромное и активное сообщество разработчиков. Если у вас есть какие-либо вопросы, вы можете задать их на различных веб-порталах и форумах, таких как Stack Overflow, и, скорее всего, получите ответ. Кроме того, не трудно найти работу Django.

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

Безопасность

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

• Межсайтовый скриптинг (XSS). Атаки XSS позволяют злоумышленнику внедрить клиентские сценарии в браузеры. Шаблоны Django защищают ваш проект от большинства XSS-атак.
• Подделка межсайтовых запросов (CSRF). CSRF-атаки позволяют злоумышленнику выполнять действия, используя учетные данные другого пользователя. Django имеет встроенную защиту от большинства типов CSRF-атак.
• SQL-инъекция. SQL-инъекция — это атака, при которой злонамеренный пользователь может выполнить произвольный код SQL в базе данных. Наборы запросов Django защищены от внедрения SQL, поскольку запросы строятся с использованием параметризации.

Библиотека Flask-Security предоставляет почти те же механизмы, что и Django, для предотвращения утечек данных и других веб-атак.

Случаи использования

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

Давайте рассмотрим лучшие примеры сайтов Django и Flask.

Какие проекты строятся с Django?

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

Какие проекты можно разработать на Django

Примеры приложений Django:

• Population Explorer, проект SaaS, который предоставляет пользователям доступ к демографическим данным и инструментам анализа на карте. Пользователи могут выбрать целевую область и получить демографические данные о ней, такие как распределение по полу, возрасту, численности населения, плотности населения и росту населения. Мы внедрили платежную систему, чтобы пользователи могли приобретать планы подписки прямо на сайте. Population Explorer содержит огромное количество данных и множество функций, и Django — это то, что делает все это возможным.
• Possio, SaaS-платформа, где пользователи могут отслеживать местоположение транспортных средств, а также данные о резком торможении, быстром ускорении, агрессивном вождении и превышении скорости. Поскольку Possio обрабатывает огромные объемы данных в режиме реального времени, Django является отличным решением.

Какие типы проектов создаются с помощью Flask?

Flask — одна из ведущих платформ Python для веб-разработки. Согласно опросам разработчиков Python от JetBrains, использование Flask среди разработчиков увеличилось с 41% в 2017 году до 47% в 2018 году. Причины, по которым всемирно известные компании, такие как Airbnb и Reddit, используют Flask, многочисленны. Flask дает вам больше контроля над вашим проектом, поскольку вы можете выбирать, какие компоненты использовать и как вы взаимодействуете с ними. Кроме того, вы можете подключить любое расширение, которое вам нужно.

Сайты этих всемирно известных компаний создаются с помощью Flask:

Какие проекты можно реализовывать на Flask

Один из практических проектов Flask — Cybertunity. Это приложение позволяет коллегам поделиться своими знаниями о кибербезопасности. Cybertunity делит сотрудников на две группы и дает всем сотрудникам опрос, состоящий из 60 вопросов, разделенных по темам. Затем приложение генерирует PDF-файл, показывающий результаты опроса и сводку того, насколько хорошо сотрудники знают темы, термины и концепции кибербезопасности. Это небольшой проект с минимальной функциональностью, поэтому мы использовали Flask.

Что есть что? Hammer vs toolbox или какой фреймворк выбрать

Давайте подытожим особенности и сильные стороны Django и Flask, чтобы вы могли решить, какие рамки выбрать.

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

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

Учитывая, что Django имеет огромное количество встроенных решений, и Flask часто выбирается для использования соответствующего пакета для решения определенной проблемы, наш вердикт таков: Django — это набор инструментов, а Flask — молот.

Мы надеемся, что наше руководство по Python Flask vs Django позволило вам лучше понять преимущества и недостатки этих платформ, различия и варианты использования.

6 причин, по которым Flask — лучший фреймворк для разработки веб-приложений

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

Причина 1: Высокая масштабируемость

В сегодняшней быстро меняющейся среде большинство людей начинают с идеи небольшого веб-приложения, а затем масштабируют ее в соответствии с требованиями. Если вы связаны со стартапом или малым бизнесом, вы хотите разработать свое веб-приложение с помощью хорошо масштабируемой среды. Flask — одна из таких платформ, которая соответствует вашим требованиям. Он может обрабатывать большое количество запросов по мере того, как ваш бизнес расширяется со временем. Например, Pinterest перешел с Django на Flask и обрабатывает миллиарды запросов в день. Причиной масштабируемости Flask является его способность модульности кодовой базы по мере ее роста в течение определенного периода времени.

Причина 2: Простота использования и гибкость

Когда вы выбираете среду разработки веб-приложений, вы будете искать ту, которая позволяет настраивать код в соответствии с вашими требованиями. Flask — одна из таких веб-платформ, поэтому она имеет огромную базу пользователей среди технического сообщества. Есть очень мало частей Flask, которые вы не можете изменить или заменить. По сравнению с Django, Flask открыт для изменений и добавляет уровень гибкости в процесс разработки веб-приложений. Кроме того, фреймворк прост в использовании и понимании даже для новичка. Основной причиной простоты Flask является его простая документация.

Причина 3: больший контроль над кодом

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

Причина 4: Поддержка тестирования

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

Причина 5: Облегчает эксперименты

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

Причина 6: медленная кривая обучения

Когда разработчики веб-приложений выбирают платформу для своего проекта, они будут думать о кривой обучения, будь она крутой или плоской. Естественно, вы хотите выбрать фреймворк с небольшой кривой обучения, и именно здесь Flask превосходит все другие фреймворки Python. Понимание концепции Flask не является сложной задачей, и именно поэтому разработчики любят его. Даже новичок может выучить Flask за несколько недель, если у него есть базовые знания языка программирования Python. Вот почему этот фреймворк становится все более популярным и популярным, и в ближайшие годы он займет центральное место в разработке веб-приложений.

Подведение итогов по преимуществам Flask

Flask — один из самых популярных микрофреймворков для разработки веб-приложений в последнее время. Фреймворк зарекомендовал себя среди сообщества разработчиков Python и разработчиков веб-приложений по всему миру.

Сообщение Сравнение Flask vs Django. Когда стоит выбрать Python Flask? появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

Keras Tutorial: Руководство для начинающих по глубокому обучению на Python 3

В этом пошаговом руководстве по Keras вы узнаете, как построить сверточную нейронную сеть на Python!

Фактически, мы будем обучать классификатор для рукописных цифр, который может похвастаться более чем 99% точностью в известном наборе данных MNIST.

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

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

Вступительная часть по Keras Tutorial Python 3

Для начала изучения машинного обучения на Python с библиотекой Keras, желательно, чтобы Вы:

• Понимали основные концепции машинного обучения
• Имели навыки программирования на Python

Почему Keras?

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

Типичные рабочие процессы Keras выглядят так:

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

Что такое глубокое обучение?

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

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

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

Эти типы глубоких нейронных сетей называются сверточными нейронными сетями.

Что такое сверточные нейронные сети (Convolutional Neural Networks CNN)?

Короче говоря, сверточные нейронные сети (CNN) представляют собой многослойные нейронные сети (иногда до 17 или более слоев), которые предполагают, что входные данные являются изображениями.

Типичная архитектура CNN:

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

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

Чем эта статья не является

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

Если вы заинтересованы в овладении теорией глубокого обучения, мы рекомендуем этот замечательный курс из Стэнфорда:

• CS231n: сверточные нейронные сети для визуального распознавания

О моделях Keras

В Keras доступно два основных типа моделей: последовательная модель и класс Model, используемый с функциональным API .

Эти модели имеют ряд общих методов и атрибутов:

• model.layers это плоский список слоев, составляющих модель.
• model.inputs список входных тензоров модели.
• model.outputs список выходных тензоров модели.
• model.summary()печатает краткое представление вашей модели.
• model.get_config()возвращает словарь, содержащий конфигурацию модели.
• model.get_weights() возвращает список всех весовых тензоров в модели в виде массивов Numpy.
• model.set_weights(weights)устанавливает значения весов модели из списка массивов Numpy. Массивы в списке должны иметь ту же форму, что и возвращаемые get_weights().
• model.to_json()возвращает представление модели в виде строки JSON. Обратите внимание, что представление не включает веса, только архитектуру.
• model.to_yaml()возвращает представление модели в виде строки YAML. Обратите внимание, что представление не включает веса, только архитектуру.
• model.save_weights(filepath) сохраняет вес модели в виде файла HDF5.
• model.load_weights(filepath, by_name=False)загружает вес модели из файла HDF5 (созданного save_weights). По умолчанию ожидается, что архитектура не изменится.

Методы API последовательной модели (Sequential model API)

Компиляция — Compile

compile(
        optimizer, 
        loss=None, 
        metrics=None, 
        loss_weights=None, 
        sample_weight_mode=None, 
        weighted_metrics=None, 
        target_tensors=None
)

Настраивает модель для обучения.

Аргументы:

• optimizer: строка (имя оптимизатора) или экземпляр оптимизатора.
• loss (потеря): строка (имя целевой функции) или целевая функция или Lossэкземпляр. Смотрите потери. Если модель имеет несколько выходов, вы можете использовать разные потери на каждом выходе, передав словарь или список потерь. Значение потерь, которое будет минимизировано моделью, будет тогда суммой всех индивидуальных потерь.
• metrics: список метрик, которые будут оцениваться моделью во время обучения и тестирования. Как правило, вы будете использовать metrics=['accuracy']. Чтобы указать разные метрики для разных выходов модели с несколькими выходами, вы также можете передать словарь, например metrics={'output_a': 'accuracy', 'output_b': ['accuracy', 'mse']}. Вы также можете передать список (len = len (выводы)) списков метрик, таких как metrics=[['accuracy'], ['accuracy', 'mse']]или metrics=['accuracy', ['accuracy', 'mse']].
• loss_weights: необязательный список или словарь, задающий скалярные коэффициенты (числа Python) для взвешивания вкладов потерь в различные выходные данные модели. Значение потерь, которое будет минимизировано моделью, будет затем взвешенной суммой всех индивидуальных потерь, взвешенных по loss_weightsкоэффициентам. Если список, ожидается, что он будет иметь соотношение 1: 1 к выходам модели. Если это диктат, ожидается, что выходные имена (строки) будут сопоставлены скалярным коэффициентам.
• sample_weight_mode: Если вам нужно сделать взвешивание выборки по временным шагам (2D веса), установите это значение "temporal". Noneпо умолчанию используются веса выборки (1D). Если модель имеет несколько выходов, вы можете использовать разные sample_weight_modeна каждом выходе, передав словарь или список режимов.
• weighted_metrics: список метрик, которые будут оцениваться и взвешиваться по sample_weight или class_weight во время обучения и тестирования.
• target_tensors: по умолчанию Keras создаст заполнители для цели модели, которые будут снабжены целевыми данными во время обучения. Если вместо этого вы хотите использовать свои собственные целевые тензоры (в свою очередь, Keras не будет ожидать внешних данных Numpy для этих целей во время обучения), вы можете указать их с помощью target_tensorsаргумента. Это может быть один тензор (для модели с одним выходом), список тензоров или точные сопоставления выходных имен с целевыми тензорами.
• **kwargs: при использовании бэкэндов Theano / CNTK эти аргументы передаются в K.function. При использовании бэкэнда TensorFlow эти аргументы передаются в tf.Session.run.

fit

Обучает модель для фиксированного числа эпох (итераций в наборе данных).

fit(
        x=None, 
        y=None, 
        batch_size=None, 
        epochs=1, 
        verbose=1, 
        callbacks=None, 
        validation_split=0.0, 
        validation_data=None, 
        shuffle=True, 
        class_weight=None, 
        sample_weight=None, 
        initial_epoch=0, 
        steps_per_epoch=None, 
        validation_steps=None, 
        validation_freq=1, 
        max_queue_size=10, 
        workers=1, 
        use_multiprocessing=False
)

Аргументы:

• x: входные данные. Это может быть:
  • Массив Numpy (или похожий на массив) или список массивов (в случае, если модель имеет несколько входов).
  • Диктовое отображение (dict mapping) входных имен в соответствующий массив / тензоры, если модель имеет именованные входы.
  • Генератор или keras.utils.Sequenceвозвращение (inputs, targets)или (inputs, targets, sample weights).
  • None (default) — Нет (по умолчанию) при подаче из тензоров, встроенных в каркас (например, тензоры данных TensorFlow).
• y: целевые данные. Как и входные данные x, это могут быть либо массив (ы) Numpy, тензор (ы), встроенные в платформу, список массивов Numpy (если модель имеет несколько выходных данных), либо None (по умолчанию), если они поступают из тензоров, встроенных в платформу (например, TensorFlow) тензоры данных). Если выходным слоям в модели присвоены имена, вы также можете передать словарь, отображающий выходные имена в массивы Numpy. If xявляется генератором или  keras.utils.Sequence экземпляром, y указывать не следует (поскольку цели будут получены из x).
• batch_size: целое число или None. Количество образцов на обновление градиента. Если batch_sizeне указан, по умолчанию будет 32. Не указывайте, batch_sizeесли ваши данные представлены в виде символических тензоров, генераторов или Sequenceэкземпляров (так как они генерируют пакеты).
• epochs: целочисленные. Количество эпох для обучения модели. Эпоха — это итерация по всему xи y предоставленным данным. Обратите внимание, что в сочетании с initial_epoch, epochsследует понимать как «конечную эпоху». Модель не обучается для ряда итераций, заданных epochs, а просто до тех пор, пока не epochsбудет достигнута эпоха индекса .
• verbose: Integer. 0, 1 или 2. Режим многословия. 0 = тихий, 1 = индикатор выполнения, 2 = одна строка за эпоху.
• callbacks: список keras.callbacks.Callbackэкземпляров. Список обратных вызовов, применяемых во время обучения и проверки (если). Смотрите обратные вызовы.
• validation_split: с плавающей точкой от 0 до 1. Доля данных обучения, которые будут использоваться в качестве данных проверки. Модель выделит эту часть обучающих данных, не будет обучаться им и будет оценивать потери и любые метрики модели на этих данных в конце каждой эпохи. Данные проверки выбираются из последних выборок xи yпредоставленных данных перед перетасовкой. Этот аргумент не поддерживается, когда он xявляется генератором или Sequenceэкземпляром.
• validation_data:

  данные для оценки потерь и любые метрики модели в конце каждой эпохи. Модель не будет обучаться на этих данных. validation_dataперекроет validation_split. validation_dataможет быть: — кортеж (x_val, y_val)массивов или тензоров (x_val, y_val, val_sample_weights)Numpy — кортеж массивов Numpy — набор данных или итератор набора данных

  Для первых двух случаев, batch_sizeдолжны быть предоставлены. Для последнего случая, validation_stepsдолжны быть предоставлены.

• shuffle: Boolean (следует ли перемешивать данные тренировки перед каждой эпохой) или str (для «партии»). «пакетная» — это специальная опция для работы с ограничениями данных HDF5; он тасуется кусками размером с партию. Не имеет эффекта, когда steps_per_epochнет None.

• class_weight: необязательный словарь, отображающий индексы класса (целые числа) на значение веса (с плавающей запятой), используемое для взвешивания функции потерь (только во время обучения). Это может быть полезно для того, чтобы сказать модели «уделять больше внимания» выборкам из недопредставленного класса.

• sample_weight: необязательный массив весов Numpy для обучающих выборок, используемый для взвешивания функции потерь (только во время обучения). Вы можете либо передать плоский (1D) массив Numpy такой же длины, что и входные выборки (отображение весов и выборок 1: 1), либо в случае временных данных вы можете передать двумерный массив с формой (samples, sequence_length), чтобы применить разный вес для каждого временного шага каждого образца. В этом случае вы должны обязательно указать sample_weight_mode="temporal"в compile(). Этот аргумент не поддерживается, когда xгенератор или Sequenceэкземпляр вместо этого предоставляют sample_weights в качестве третьего элемента x.
• initial_epoch: целое число. Эпоха, с которой начинается тренировка (полезно для возобновления предыдущего тренировочного заезда).
• steps_per_epoch: целое число или None. Общее количество шагов (партий образцов) до объявления одной эпохи законченной и начала следующей эпохи. При обучении с использованием входных тензоров, таких как тензоры данных TensorFlow, значение по умолчанию Noneравно числу выборок в вашем наборе данных, деленному на размер пакета, или 1, если это невозможно определить.
• validation_steps: только релевантно, если  steps_per_epoch  указано. Общее количество шагов (партий образцов) для проверки перед остановкой.
• validation_steps: релевантно, только если validation_dataпредоставлено и является генератором. Общее количество шагов (партий образцов), которые нужно нарисовать перед остановкой при выполнении проверки в конце каждой эпохи.
• validation_freq: уместно, только если предоставлены данные проверки. Целое число или список / кортеж / набор. Если целое число, указывает, сколько тренировочных эпох должно быть выполнено до того, как будет выполнен новый прогон проверки, например, validation_freq=2выполняет проверку каждые 2 эпохи. Если в списке, кортеже или наборе указываются эпохи, в которых нужно выполнять проверку, например, validation_freq=[1, 2, 10]выполняет проверку в конце 1-й, 2-й и 10-й эпох.
• max_queue_size: целое число. Используется только для генератора или keras.utils.Sequence входа. Максимальный размер очереди генератора. Если не указано, по max_queue_sizeумолчанию будет 10.
• workers: целое число. Используется только для генератора или keras.utils.Sequenceвхода. Максимальное количество процессов, которые могут ускоряться при использовании потоков на основе процессов. Если не указан, по workers умолчанию будет 1. Если 0, будет запускать генератор в основном потоке.
• use_multiprocessing: Boolean. Используется только для генератора или keras.utils.Sequenceвхода. Если True, используйте процессные потоки. Если не указано, по use_multiprocessingумолчанию False. Обратите внимание, что, поскольку эта реализация опирается на многопроцессорность, вы не должны передавать невыгружаемые аргументы генератору, так как они не могут быть легко переданы дочерним процессам.
• **kwargs: используется для обратной совместимости.

Краткий обзор учебника/статьи по Keras

Вот перечень шагов для создания вашей первой сверточной нейройнной сети (CNN) с использованием Keras:

1. Настройте свою среду.
2. Установите Керас / Keras.
3. Импорт библиотек и модулей.
4. Загрузить данные изображения из MNIST.
5. Предварительная обработка входных данных для Keras.
6. Метки препроцесс-класса для Keras.
7. Определите архитектуру модели.
8. Скомпилируйте модель.
9. Подгонка модели по тренировочным данным.
10. Оценить модель по данным испытаний.

Шаг 1: Настройте свою рабочую среду

убедитесь, что на вашем компьютере установлено следующее:

• Python 2.7+ (Python 3 тоже хорошо, но Python 2.7 все еще более популярен для науки о данных в целом)
• SciPy с NumPy
• Matplotlib (необязательно, рекомендуется для исследовательского анализа)
• Theano * ( Инструкция по установке )

Theano — это библиотека Python, которая позволяет нам так эффективно оценивать математические операции, включая многомерные массивы. В основном он используется при создании проектов глубокого обучения. Он работает намного быстрее на графическом процессоре (GPU), чем на CPU. Theano достигает высоких скоростей, что создает жесткую конкуренцию реализациям на языке C для задач, связанных с большими объемами данных.
Theano знает, как брать структуры и преобразовывать их в очень эффективный код, который использует numpy и некоторые нативные библиотеки. Он в основном предназначен для обработки типов вычислений, требуемых для алгоритмов больших нейронных сетей, используемых в Deep Learning. Именно поэтому, это очень популярная библиотека в области глубокого обучения.

Рекомендуется установить Python, NumPy, SciPy и matplotlib через дистрибутив Anaconda. Он поставляется со всеми этими пакетами.

Conda Cheatsheet: command line package and environment manager.pdf

Краткий обзор как настроить Анаконду здесь:

Инструкция по Anaconda & Conda. Как управлять и настроить среду для Python?

* Примечание: TensorFlow также поддерживается (как альтернатива Theano), но мы придерживаемся Theano для простоты. Основное отличие состоит в том, что вам необходимо изменить данные немного по-другому, прежде чем передавать их в свою сеть.

Еще раз пробежимся по устанавливаемым библиотекам:

SciPy (произносится как сай пай) — это пакет прикладных математических процедур, основанный на расширении Numpy Python. С SciPy интерактивный сеанс Python превращается в такую же полноценную среду обработки данных и прототипирования сложных систем, как MATLAB, IDL, Octave, R-Lab и SciLab.

Matplotlib — библиотека на языке программирования Python для визуализации данных.

Theano — библиотека, которая используется для разработки систем машинного обучения как сама по себе, так и в качестве вычислительного бекэнда для более высокоуровневых библиотек, например, Lasagne, Keras или Blocks.

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

Проверим правильно ли мы все установили

Переходим в Jupyter Notebook в среде, которая имеет установленные библиотеки/пакеты. Запускаем следующие команды:

1. Для проверки среды:

import sys
print(sys.version)
print(sys.base_prefix)

Результата:

3.7.5 (default, Oct 31 2019, 15:18:51) [MSC v.1916 64 bit (AMD64)]
C:\Users\User\.conda\envs\MyNewEnvironmentName

2. Для проверки библиотек:

import numpy as np
import theano as th
import keras as kr
import matplotlib as mpl

print('numpy:' + np.__version__)
print('theano:' + th.__version__)
print('keras:' + kr.__version__)
print('matplotlib:' + mpl.__version__)

Результат:

numpy:1.17.4
theano:1.0.4
keras:2.2.4
matplotlib:3.1.1

Как это выглядит в Jupyter Notebook:

Шаг 2. Импортируем библиотеки и модули для нашего проекта

Удаляем предыдущие проверочные шаги из Notebook.

Теперь начнем с импорта numpy и установки начального числа для генератора псевдослучайных чисел на компьютере. Это позволяет нам воспроизводить результаты из нашего скрипта:

import numpy as np
np.random.seed(123)  # for reproducibility

Далее мы импортируем тип модели Sequential из Keras. Это просто линейный набор слоев нейронной сети, и он идеально подходит для того типа CNN с прямой связью, который мы строим в этом руководстве.

from keras.models import Sequential

Далее, давайте импортируем «основные» слои из Keras. Это слои, которые используются практически в любой нейронной сети:

from keras.layers import Dense, Dropout, Activation, Flatten

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

from keras.layers import Convolution2D, MaxPooling2D

Наконец, мы импортируем некоторые утилиты. Это поможет нам преобразовать наши данные позже:

from keras.utils import np_utils

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

Полный текст скрипта после шага 2:

import numpy as np
np.random.seed(123)  # for reproducibility

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras.utils import np_utils

Шаг 3. Загружаем изображения из MNIST

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

Библиотека Keras удобно уже включает это. Мы можем загрузить это так:

from keras.datasets import mnist
 
# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()

Мы можем посмотреть на форму набора данных:

print(X_train.shape)

Результат:

(60000, 28, 28)

Отлично, получается, что в нашем обучающем наборе 60 000 сэмплов, и размер каждого изображения составляет 28 х 28 пикселей. Мы можем подтвердить это, построив первый пример в matplotlib:

from matplotlib import pyplot as plt
plt.imshow(X_train[0])

Вывод изображения:

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

Полный скрипт после шага 3

import numpy as np
np.random.seed(123)  # for reproducibility

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras.utils import np_utils
from keras.datasets import mnist

from matplotlib import pyplot as plt
 
# Загрузка предварительно перемешанных данных MNIST в наборы trains и tests
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Форма набора данных
print(X_train.shape)

# Вывод изображения
plt.imshow(X_train[0])

Шаг 4: Предварительная обработка входных данных для Keras

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

Наши изображения MNIST имеют глубину только 1, но мы должны явно объявить это.

Другими словами, мы хотим преобразовать наш набор данных из формы (n, ширина, высота) в (n, глубина, ширина, высота).

Вот как мы можем сделать это легко:

X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)

Чтобы подтвердить, мы можем снова напечатать размеры X_train:

print(X_train.shape)

Результат:

(60000, 1, 28, 28)

Последний шаг предварительной обработки для входных данных — преобразовать наш тип данных в float32 и нормализовать наши значения данных в диапазоне [0, 1].

X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Теперь наши входные данные готовы к обучению модели.

Полный текст скрипта после 4 шага

import numpy as np
np.random.seed(123)  # для воспроизводимости

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras.utils import np_utils
from keras.datasets import mnist

from matplotlib import pyplot as plt
 
# Загрузка предварительно перемешанных данных MNIST в наборы trains и tests
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Форма набора данных
print("=== Результат X_train.shape ===")
print(X_train.shape)

# Вывод изображения
plt.imshow(X_train[0])

# Преобразование набора данных из формы (n, ширина, высота) в (n, глубина, ширина, высота)
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)

# Вывод размеров X_train
print("=== Результат X_train.shape ===")
print(X_train.shape)

# Преобразование типа данных в float32
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')

# Нормализация значений данных в диапазоне [0, 1]
X_train /= 255
X_test /= 255

Шаг 5. Предварительная обработка меток классов для Keras

Далее, давайте посмотрим на форму наших данных меток классов:

print(y_train.shape)

Результат:

(60000,)

Хм … это может быть проблематично. У нас должно быть 10 разных классов, по одному на каждую цифру, но, похоже, у нас есть только одномерный массив. Давайте посмотрим на ярлыки для первых 10 учебных образцов:

print(y_train[:10])

Результат:

[5 0 4 1 9 2 1 3 1 4]

И есть проблема. Данные y_train и y_test не разделены на 10 различных меток классов, а представлены в виде одного массива со значениями классов.

Мы можем это легко исправить:

# Convert 1-dimensional class arrays to 10-dimensional class matrices
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

Метод np_utils.to_categorical — Преобразует вектор класса (целые числа) в двоичную матрицу классов.

Теперь мы можем взглянуть еще раз:

print(Y_train.shape)

Результат:

(60000, 10)

Полный текст скрипта после 5 шага

import numpy as np
np.random.seed(123)  # для воспроизводимости

from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from keras.utils import np_utils
from keras.datasets import mnist

from matplotlib import pyplot as plt
 
# Загрузка предварительно перемешанных данных MNIST в наборы trains и tests
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Форма набора данных
print("=== Результат X_train.shape ===")
print(X_train.shape)

# Вывод изображения
plt.imshow(X_train[0])

# Преобразование набора данных из формы (n, ширина, высота) в (n, глубина, ширина, высота)
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)

# Вывод размеров X_train
print("=== Результат X_train.shape ===")
print(X_train.shape)

# Преобразование типа данных в float32
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')

# Нормализация значений данных в диапазоне [0, 1]
X_train /= 255
X_test /= 255

# Просмотр формы меток классов наших данных
print("=== Результат y_train.shape ===")
print(y_train.shape)

print("=== Результат y_train[:10] ===")
print(y_train[:10])

# Преобразование одномерных массивов классов в 10-мерные матрицы классов
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

# Вывод после преобразования
print("=== Результат Y_train.shape после np_utils.to_categorical ===")
print(Y_train.shape)

Результат:

=== Результат X_train.shape ===
(60000, 28, 28)

=== Результат X_train.shape ===
(60000, 1, 28, 28)

=== Результат y_train.shape ===
(60000,)

=== Результат y_train[:10] ===
[5 0 4 1 9 2 1 3 1 4]

=== Результат Y_train.shape после np_utils.to_categorical ===
(60000, 10)

Шаг 6: Зададим архитектуру модели нейронной сети

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

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

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

Начнем с объявления последовательного формата модели:

model = Sequential()

Далее мы объявляем входной слой:

model.add(Conv2D(32,(3, 3), activation = 'relu', input_shape=(1,28,28), data_format='channels_first'))

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

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

* Примечание. Размер шага по умолчанию равен (1,1), и его можно настроить с помощью параметра «subsample».

Мы можем подтвердить это, напечатав форму текущей модели:

print(model.output_shape)

Результат:

(None, 32, 26, 26)

Затем мы можем просто добавить больше слоев в нашу модель, как будто мы строим legos:

model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))

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

MaxPooling2D — это способ уменьшить количество параметров в нашей модели, переместив фильтр пула 2×2 по предыдущему слою и взяв максимум 4 значения в фильтре 2×2.

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

model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

Для плотных слоев первым параметром является выходной размер слоя. Keras автоматически обрабатывает связи между слоями.

Обратите внимание, что конечный слой имеет выходной размер 10, соответствующий 10 классам цифр.

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

Вот как выглядит вся архитектура модели:

model = Sequential()

model.add(Conv2D(32,(3, 3), activation = 'relu', input_shape=(1,28,28), data_format='channels_first'))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

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

Шаг 7. Скомпилируем модель

Сложная часть уже закончилась.

Теперь нам просто нужно скомпилировать модель, и мы будем готовы обучать ее. Когда мы компилируем модель, мы объявляем функцию потерь и оптимизатор (SGD, Adam и т.д.).

model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

Keras имеет множество функций потери и встроенных оптимизаторов на выбор.

Шаг 8. Обучим модель на тестовых данных (тренировочных данных)

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

model.fit(X_train, Y_train, 
          batch_size=32, epochs=10, verbose=1)

Результат:

Epoch 1/10
60000/60000 [==============================] - 38100s 635ms/step - loss: 0.2253 - acc: 0.9337
Epoch 2/10
60000/60000 [==============================] - 728s 12ms/step - loss: 0.1195 - acc: 0.9650
Epoch 3/10
60000/60000 [==============================] - 964s 16ms/step - loss: 0.0927 - acc: 0.9724
Epoch 4/10
60000/60000 [==============================] - 1169s 19ms/step - loss: 0.0778 - acc: 0.9768
Epoch 5/10
60000/60000 [==============================] - 1223s 20ms/step - loss: 0.0709 - acc: 0.9794
Epoch 6/10
60000/60000 [==============================] - 730s 12ms/step - loss: 0.0640 - acc: 0.9809
Epoch 7/10
60000/60000 [==============================] - 749s 12ms/step - loss: 0.0578 - acc: 0.9828
Epoch 8/10
60000/60000 [==============================] - 730s 12ms/step - loss: 0.0554 - acc: 0.9825
Epoch 9/10
60000/60000 [==============================] - 728s 12ms/step - loss: 0.0528 - acc: 0.9848
Epoch 10/10
60000/60000 [==============================] - 719s 12ms/step - loss: 0.0495 - acc: 0.9852

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

Шаг 9: Оценка работы модели на тестовых данных

Наконец, мы можем оценить нашу модель по тестовым данным:

score = model.evaluate(X_test, Y_test, verbose=0)
score

Результат:

[2.3163251502990723, 0.0986]

Сообщение Keras Tutorial: Руководство для начинающих по глубокому обучению на Python появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

Объектно-ориентированный Python

Python был объектно-ориентированным языком с момента его появления. Из-за этого создавать и использовать классы и объекты совершенно просто. Эта глава поможет вам стать экспертом в использовании объектно-ориентированного программирования в Python.

Эта статья является кратким введением в объектно-ориентированное программирование (ООП) на Python, которое поможет вам быстро вникнуть в суть и начать решать прикладные задачи.

Краткий обзор ооп python

Программа/скрипт/код, написанные с использованием парадигмы объектно-ориентированного программирования, должны состоять из

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

Что такое класс в ооп python?

Класс = данные + методы

Класс — это тип данных, состоящий из набора атрибутов (свойств) и методов — функций для работы с этими атрибутами.

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

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

class ИмяКласса:
    ПеременнаяКласса = Значение
    …
    def ИмяМетода(self, ...):
        self.ПеременнаяКласса = Значение
        …
    …

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

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

Пример класса (ООП) на Python 3:

class Second:
    color = "red"
    form = "circle"
    def changecolor(self,newcolor):
        self.color = newcolor
    def changeform(self,newform):
        self.form = newform

obj1 = Second()
obj2 = Second()

print (obj1.color, obj1.form) # вывод на экран "red circle"
print (obj2.color, obj2.form) # вывод на экран "red circle"

obj1.changecolor("green") # изменение цвета первого объекта
obj2.changecolor("blue") # изменение цвет второго объекта
obj2.changeform("oval") # изменение формы второго объекта

print (obj1.color, obj1.form) # вывод на экран "green circle"
print (obj2.color, obj2.form) # вывод на экран "blue oval"

Результат выполнения скрипта Python 3:

red circle
red circle
green circle
blue oval

Конструктор класса — метод __init__

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

Такой метод называется конструктором класса и в языке программирования Python носит имя __init__. (В начале и конце по два знака подчеркивания.)

Первым параметром, как и у любого другого метода, у __init__ является self, на место которого подставляется объект в момент его создания. Второй и последующие (если есть) параметры заменяются аргументами, переданными в конструктор при вызове класса. Рассмотрим два класса: в одном будет использоваться конструктор, а в другом нет. Требуется создать два атрибута объекта.

Рассмотрим два класса: в одном будет использоваться конструктор, а в другом нет. Требуется создать два атрибута объекта.

Пример 1:

class YesInit:
    def __init__(self,one,two):
        self.fname = one
        self.sname = two

obj1 = YesInit("Peter","Ok")
print (obj1.fname, obj1.sname)

Пример 2:

class NoInit:
    def names(self,one,two):
        self.fname = one
        self.sname = two

obj2 = NoInit()
obj2.names("Peter","Ok")

print (obj2.fname, obj2.sname)

Результат выполнения двух скриптов:

Peter Ok

Что значит аргумент self в Python 3 в методе класса

Аргумент self — это ссылка на создаваемый в памяти компьютера объект.

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

Методу необходимо «знать», данные какого объекта ему предстоит обрабатывать. Для этого ему в качестве первого (а иногда и единственного) аргумента передается имя переменной, связанной с объектом (можно сказать, передается сам объект). Чтобы в описании класса указать передаваемый в дальнейшем объект, используется параметр self.

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

Объект.ИмяМетода(…)

Здесь под словом Объект имеется в виду переменная, связанная с ним. Это выражение преобразуется в классе, к которому относится объект, в

ИмяМетода(Объект, …)

Т.е. конкретный объект подставляется вместо параметра self

Объектно-ориентированное программирование Python 3. Классы, объекты, экземпляры, методы

Принципы ООП

Объектно-ориентированный язык работает по следующим принципам:

• Все данные представляются объектами
• Программа является набором взаимодействующих объектов, посылающих друг другу сообщения
• Каждый объект имеет собственную часть памяти и может иметь в составе другие объекты
• Каждый объект имеет тип
• Объекты одного типа могут принимать одни и те же сообщения (и выполнять одни и те же действия)

Идеи/принципы объектно-ориентированного программирования:

1. Наследование. Возможность выделять общие свойства и методы классов в один класс верхнего уровня (родительский). Классы, имеющие общего родителя, различаются между собой за счет включения в них различных дополнительных свойств и методов.
2. Инкапсуляция. Свойства и методы класса делятся на доступные из вне (опубликованные) и недоступные (защищенные). Защищенные атрибуты нельзя изменить, находясь вне класса. Опубликованные же атрибуты также называют интерфейсом объекта, т. к. с их помощью с объектом можно взаимодействовать. По идеи, инкапсуляция призвана обеспечить надежность программы, т.к. изменить существенные для существования объекта атрибуты становится невозможно.
3. Полиморфизм. Полиморфизм подразумевает замещение атрибутов, описанных ранее в других классах: имя атрибута остается прежним, а реализация уже другой. Полиморфизм позволяет специализировать (адаптировать) классы, оставляя при этом единый интерфейс взаимодействия.

Преимущества ООП

В связи со своими особенностями объектно-ориентированное программирование имеет ряд преимуществ перед структурным (и др.) программированием. Выделим некоторые из них:

1. Использование одного и того же программного кода с разными данными. Классы позволяют создавать множество объектов, каждый из которых имеет собственные значения атрибутов. Нет потребности вводить множество переменных, т.к объекты получают в свое распоряжение индивидуальные так называемые пространства имен. Пространство имен конкретного объекта формируется на основе класса, от которого он был создан, а также от всех родительских классов данного класса. Объект можно представить как некую упаковку данных.
2. Наследование и полиморфизм позволяют не писать новый код, а настраивать уже существующий, за счет добавления и переопределения атрибутов. Это ведет к сокращению объема исходного кода.

Особенность ООП

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

Особенности ООП в Python

По сравнению с другими распространенными языками программирования у Python можно выделить следующие особенности, связанные с объектно-ориентированным программированием:

1. Любое данное (значение) — это объект. Число, строка, список, массив и др. — все является объектом. Бываю объекты встроенных классов (как те,что перечисленные в предыдущем предложении), а бывают объекты пользовательских классов (тех, что создает программист). Для единого механизма взаимодействия предусмотрены методы перегрузки операторов.
2. Класс — это тоже объект с собственным пространством имен. Это нигде не было указано в данном цикле уроков. Однако это так. Поэтому правильнее было употреблять вместо слова «объект», слово «экземпляр». И говорить «экземпляр объекта», подразумевая под этим созданный на основе класса именно объект, и «экземпляр класса», имея ввиду сам класс как объект.
3. Инкапсуляции в Python не уделяется особого внимания. В других языках программирования обычно нельзя получить напрямую доступ к свойству, описанному в классе. Для его изменения может быть предусмотрен специальный метод. В Python же это легко сделать, просто обратившись к свойству класса из вне. Несмотря на это в Python все-таки предусмотрены специальные способы ограничения доступа к переменным в классе.

Обзор терминологии ООП

• Класс — определенный пользователем прототип для объекта, который определяет набор атрибутов, которые характеризуют любой объект класса. Атрибутами являются члены данных (переменные класса и переменные экземпляра) и методы, доступ к которым осуществляется через точечную запись.
• Переменная класса — переменная, которая используется всеми экземплярами класса. Переменные класса определены внутри класса, но вне любого из методов класса. Переменные класса используются не так часто, как переменные экземпляра.
• Член данных — переменная класса или переменная экземпляра, которая содержит данные, связанные с классом и его объектами.
• Перегрузка функций — назначение более чем одного поведения определенной функции. Выполняемая операция варьируется в зависимости от типов объектов или аргументов.
• Переменная экземпляра — переменная, которая определена внутри метода и принадлежит только текущему экземпляру класса.
• Наследование — передача характеристик класса другим классам, которые являются его производными.
• Экземпляр — индивидуальный объект определенного класса. Например, объект obj, принадлежащий классу Circle, является экземпляром класса Circle.
• Instantiation — создание экземпляра класса.
• Метод — особый вид функции, который определен в определении класса.
• Объект — уникальный экземпляр структуры данных, который определяется его классом. Объект включает в себя как члены данных (переменные класса и переменные экземпляра), так и методы.
• Перегрузка оператора — назначение более чем одной функции определенному оператору.

Создание классов

Оператор класса создает новое определение класса. Имя класса следует сразу за ключевым словом class, за которым следует двоеточие:

class ClassName:
   'Optional class documentation string'
   class_suite

• Класс имеет строку документации, к которой можно получить доступ через ClassName .__ doc__ .
• Class_suite состоит из всех компонентов утверждений, определяющих член класса, атрибуты данных и функцию.

Пример

Ниже приведен пример простого класса Python 

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• Переменная empCount является переменной класса, значение которой является общим для всех экземпляров этого класса. Доступ к нему можно получить как Employee.empCount внутри класса или за его пределами.
• Первый метод __init __ () — это специальный метод, который называется конструктором класса или методом инициализации, который Python вызывает при создании нового экземпляра этого класса.
• Вы объявляете другие методы класса, как обычные функции, за исключением того, что первый аргумент каждого метода — это self . Python добавляет аргумент self в список для вас; вам не нужно включать его при вызове методов.

Создание объектов экземпляра

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

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

Доступ к атрибутам

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

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Теперь, объединяя все концепции

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Когда приведенный выше код выполняется, он дает следующий результат

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

Вы можете добавлять, удалять или изменять атрибуты классов и объектов в любое время

emp1.age = 7  # Add an 'age' attribute.
emp1.age = 8  # Modify 'age' attribute.
del emp1.age  # Delete 'age' attribute.

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

• GetAttr (объект, имя [, по умолчанию]) — для доступа к атрибуту объекта.
• Hasattr (объект, имя) — проверить , если атрибут существует или нет.
• SetAttr (объект, имя, значение) — установить атрибут. Если атрибут не существует, он будет создан.
• Delattr (объект, имя) — для удаления атрибута.

hasattr(emp1, 'age')    # Returns true if 'age' attribute exists
getattr(emp1, 'age')    # Returns value of 'age' attribute
setattr(emp1, 'age', 8) # Set attribute 'age' at 8
delattr(empl, 'age')    # Delete attribute 'age'

Встроенные атрибуты класса

Каждый класс Python поддерживает следующие встроенные атрибуты, и к ним можно получить доступ, используя оператор точки, как и любой другой атрибут —

• __dict__ — словарь, содержащий пространство имен класса.
• __doc__ — Строка документации класса или нет, если она не определена.
• __name__ — Имя класса.
• __module__ — Имя модуля, в котором определяется класс. Этот атрибут «__main__» в интерактивном режиме.
• __bases__ — возможно пустой кортеж, содержащий базовые классы, в порядке их появления в списке базовых классов.

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

#!/usr/bin/python

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Когда приведенный выше код выполняется, он дает следующий результат

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2, 
'displayEmployee': <function displayEmployee at 0xb7c8441c>, 
'__doc__': 'Common base class for all employees', 
'__init__': <function __init__ at 0xb7c846bc>}

Уничтожение объектов (Сборка мусора)

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

Сборщик мусора в Python запускается во время выполнения программы и запускается, когда счетчик ссылок на объект достигает нуля. Количество ссылок объекта изменяется по мере изменения количества псевдонимов, которые на него указывают.

Счетчик ссылок на объект увеличивается, когда ему присваивается новое имя или он помещается в контейнер (список, кортеж или словарь). Счетчик ссылок объекта уменьшается, когда он удаляется с помощью del , его ссылка переназначается или его ссылка выходит за пределы области видимости. Когда счетчик ссылок объекта достигает нуля, Python собирает его автоматически.

a = 40      # Create object <40>
b = a       # Increase ref. count  of <40> 
c = [b]     # Increase ref. count  of <40> 

del a       # Decrease ref. count  of <40>
b = 100     # Decrease ref. count  of <40> 
c[0] = -1   # Decrease ref. count  of <40>

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

Пример

Этот деструктор __del __ () печатает имя класса экземпляра, который должен быть уничтожен

#!/usr/bin/python

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "destroyed"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # prints the ids of the obejcts
del pt1
del pt2
del pt3

Когда приведенный выше код выполняется, он дает следующий результат

3083401324 3083401324 3083401324
Point destroyed

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

Наследование классов

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

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

Синтаксис

Производные классы объявляются так же, как их родительский класс; однако список базовых классов для наследования дается после имени класса

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

Пример

#!/usr/bin/python

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print "Calling parent constructor"

   def parentMethod(self):
      print 'Calling parent method'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "Parent attribute :", Parent.parentAttr

class Child(Parent): # define child class
   def __init__(self):
      print "Calling child constructor"

   def childMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

Когда приведенный выше код выполняется, он дает следующий результат

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

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

class A:        # define your class A
.....

class B:         # define your class B
.....

class C(A, B):   # subclass of A and B
.....

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

• Issubclass ( к югу, вир) функция булева возвращает истину , если данный подкласс суб действительно подкласс суперкласса вир .
• Isinstance (объект, класс) Функция булева возвращает истину , если OBJ является экземпляром класса Class или является экземпляром подкласса класса

Переопределяющие методы

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

Пример

#!/usr/bin/python

class Parent:        # define parent class
   def myMethod(self):
      print 'Calling parent method'

class Child(Parent): # define child class
   def myMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

Когда приведенный выше код выполняется, он дает следующий результат

Calling child method

Базовые методы перегрузки

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

Операторы перегрузки

Предположим, что вы создали класс Vector для представления двумерных векторов. Что произойдет, когда вы добавите оператор «плюс»? Скорее всего, Python будет кричать на вас.

Однако вы можете определить метод __add__ в вашем классе для выполнения сложения векторов, и тогда оператор плюс будет вести себя так, как ожидалось:

пример

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

Когда приведенный выше код выполняется, он дает следующий результат

Vector(7,8)

Скрытие данных

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

пример

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

Когда приведенный выше код выполняется, он дает следующий результат

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python защищает этих членов, внутренне изменяя имя, чтобы включить имя класса. Вы можете получить доступ к таким атрибутам как object._className__attrName . Если вы заменили свою последнюю строку следующим образом, то она работает для вас

.........................
print counter._JustCounter__secretCount

Когда приведенный выше код выполняется, он дает следующий результат

1
2
2

Сквозной пример по классам

####################################################
## 5. Классы
####################################################

# Чтобы получить класс, мы наследуемся от object.
class Human(object):

    # Атрибут класса. Он разделяется всеми экземплярами этого класса
    species = "H. sapiens"

    # Обычный конструктор, вызывается при инициализации экземпляра класса
    # Обратите внимание, что двойное подчёркивание в начале и в конце имени
    # означает объекты и атрибуты, которые используются Python, но находятся
    # в пространствах имён, управляемых пользователем.
    # Не придумывайте им имена самостоятельно.
    def __init__(self, name):
        # Присваивание значения аргумента атрибуту класса name
        self.name = name

    # Метод экземпляра. Все методы принимают self в качестве первого аргумента
    def say(self, msg):
        return "{name}: {message}".format(name=self.name, message=msg)

    # Метод класса разделяется между всеми экземплярами
    # Они вызываются с указыванием вызывающего класса в качестве первого аргумента
    @classmethod
    def get_species(cls):
        return cls.species

    # Статический метод вызывается без ссылки на класс или экземпляр
    @staticmethod
    def grunt():
        return "*grunt*"


# Инициализация экземпляра класса
i = Human(name="Иван")
print(i.say("привет"))     # Выводит: «Иван: привет»

j = Human("Пётр")
print(j.say("Привет"))  # Выводит: «Пётр: привет»

# Вызов метода класса
i.get_species() #=> "H. sapiens"

# Изменение разделяемого атрибута
Human.species = "H. neanderthalensis"
i.get_species() #=> "H. neanderthalensis"
j.get_species() #=> "H. neanderthalensis"

# Вызов статического метода
Human.grunt() #=> "*grunt*"

Сообщение Классы, методы Python 3. Примеры ООП (объектно ориентированное программирование) появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

Что такое Pandas DataFrame?

Pandas — более новый пакет, надстройка над библиотекой NumPy, обеспечивающий эффективную реализацию класса DataFrame.

Объекты DataFrame — многомерные массивы с метками для строк и столбцов, а также зачастую с неоднородным типом данных и/или пропущенными данными.

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

Импорт библиотек NumPy и Pandas

На самом примитивном уровне объекты библиотеки Pandas можно считать расширенной версией структурированных массивов библиотеки NumPy, в которых строки и столбцы идентифицируются метками, а не простыми числовыми индексами. Библиотека Pandas предоставляет множество полезных утилит, методов и функциональности в дополнение к базовым структурам данных, но все последующее изложение потребует понимания этих базовых структур. Позвольте познакомить вас с тремя фундаментальными структурами данных библиотеки Pandas: классами Series, DataFrame и Index.

Начнем наш сеанс программирования с обычных импортов библиотек NumPy и Pandas:

import numpy as np
import pandas as pd

Объект Series библиотеки Pandas

Объект Series библиотеки Pandas — одномерный массив индексированных данных. Его можно создать из списка или массива следующим образом:

import numpy as np
import pandas as pd

data = pd.Series([0.25, 0.5, 0.75, 1.0])
print(data)

Результат:

Как мы видели из предыдущего результата, объект Series служит адаптером как для последовательности значений, так и последовательности индексов, к которым можно получить доступ посредством атрибутов values и index. Атрибут values представляет собой массив NumPy:

import numpy as np
import pandas as pd

data = pd.Series([0.25, 0.5, 0.75, 1.0])
print(data.values)

Результат:

[0.25 0.5  0.75 1.  ]

Index — массивоподобный объект типа pd.Index:

import numpy as np
import pandas as pd

data = pd.Series([0.25, 0.5, 0.75, 1.0])
print(data.index)

Результат:

RangeIndex(start=0, stop=4, step=1)

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

import numpy as np
import pandas as pd

data = pd.Series([0.25, 0.5, 0.75, 1.0])
print('data[1]:')
print(data[1])

print('data[1:3]:')
print(data[1:3])

Результат:

data[1]:
0.5
data[1:3]:
1    0.50
2    0.75
dtype: float64

Однако объект Series библиотеки Pandas намного универсальнее и гибче, чем эмулируемый им одномерный массив библиотеки NumPy.

Объект Series как обобщенный массив NumPy

Может показаться, что объект Series и одномерный массив библиотеки NumPy взаимозаменяемы. Основное различие между ними — индекс. В то время как индекс массива NumPy, используемый для доступа к значениям, — целочисленный и описывается неявно, индекс объекта Series библиотеки Pandas описывается явно и связывается со значениями.

Явное описание индекса расширяет возможности объекта Series. Такой индекс не должен быть целым числом, а может состоять из значений любого нужного типа. Например, при желании мы можем использовать в качестве индекса строковые значения:

import numpy as np
import pandas as pd

data = pd.Series([0.25, 0.5, 0.75, 1.0],
                 index=['a', 'b', 'c', 'd'])
print(data)

Результат:

a    0.25
b    0.50
c    0.75
d    1.00
dtype: float64

При этом доступ к элементам работает обычным образом:

import numpy as np
import pandas as pd

data = pd.Series([0.25, 0.5, 0.75, 1.0],
                 index=['a', 'b', 'c', 'd'])
print(data['b'])

Результат:

0.5

Объект Series как специализированный словарь

Объект Series библиотеки Pandas можно рассматривать как специализированную разновидность словаря языка Python. Словарь — структура, задающая соответствие произвольных ключей набору произвольных значений, а объект Series — структура, задающая соответствие типизированных ключей набору типизированных значений.

Типизация важна: точно так же, как соответствующий типу специализированный код для массива библиотеки NumPy при выполнении определенных операций делает его эффективнее, чем стандартный список Python, информация о типе в объекте Series библиотеки Pandas делает его намного более эффективным для определенных операций, чем словари Python.

Можно сделать аналогию «объект Series — словарь» еще более наглядной, сконструировав объект Series непосредственно из словаря Python.

По умолчанию при этом будет создан объект Series с полученным из отсортированных ключей индексом. Следовательно, для него возможен обычный доступ к элементам, такой же, как для словаря. Объект Series поддерживает операции «срезы».

import numpy as np
import pandas as pd

# Словарь
population_dict = {'California': 38332521,
                   'Texas': 26448193,
                   'New York': 19651127,
                   'Florida': 19552860,
                   'Illinois': 12882135}
population = pd.Series(population_dict)
print('population:')
print(population)

# Доступ к элементам
print("population['California']:")
print(population['California'])

# Срез
print("population['California':'New York']:")
print(population['California':'New York'])

Результат:

population:
California    38332521
Texas         26448193
New York      19651127
Florida       19552860
Illinois      12882135
dtype: int64

population['California']:
38332521

population['California':'New York']:
California    38332521
Texas         26448193
New York      19651127
dtype: int64

Создание объектов Series

Мы уже изучили несколько способов создания объектов Series библиотеки Pandas с нуля.

Все они представляют собой различные варианты следующего синтаксиса Pandas Series (общий вид синтаксиса):

pd.Series(data, index=index)

где index — необязательный аргумент, а data может быть одной из множества сущностей.

Например, аргумент data может быть списком или массивом NumPy. В этом случае index по умолчанию будет целочисленной последовательностью:

import pandas as pd

data = pd.Series([2, 4, 6])
print(data)

Результат:

0    2
1    4
2    6
dtype: int64

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

import pandas as pd

data = pd.Series(5, index=[100, 200, 300])
print(data)

Результат:

100    5
200    5
300    5
dtype: int64

Аргумент data может быть словарем, в котором index по умолчанию является отсортированными ключами этого словаря:

import pandas as pd

data = pd.Series({2:'a', 1:'b', 3:'c'})
print(data)

Результат:

2    a
1    b
3    c
dtype: object

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

import pandas as pd

data = pd.Series({2:'a', 1:'b', 3:'c'}, index=[3, 2])
print(data)

Результат:

3    c
2    a
dtype: object

Обратите внимание, что объект Series заполняется только заданными явным образом ключами.

Объект DataFrame библиотеки Pandas

Следующая базовая структура библиотеки Pandas — объект DataFrame. Как и объект Series, объект DataFrame можно рассматривать или как обобщение массива NumPy, или как специализированную версию словаря Python. Изучим оба варианта.

DataFrame как обобщенный массив NumPy

Если объект Series — аналог одномерного массива с гибкими индексами, объект DataFrame — аналог двумерного массива с гибкими индексами строк и гибкими именами столбцов. Аналогично тому, что двумерный массив можно рассматривать как упорядоченную последовательность выровненных столбцов, объект DataFrame можно рассматривать как упорядоченную последовательность выровненных объектов Series. Под «выровненными» имеется в виду то, что они используют один и тот же индекс.

Чтобы продемонстрировать это, сначала создадим новый объект Series, содержащий площадь каждого из пяти упомянутых в предыдущем разделе штатов:

import pandas as pd

area_dict = {'California': 423967,
             'Texas': 695662,
             'New York': 141297,
             'Florida': 170312,
             'Illinois': 149995}
area = pd.Series(area_dict)
print(area)

Результат:

California    423967
Texas         695662
New York      141297
Florida       170312
Illinois      149995
dtype: int64

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

import pandas as pd

# Словарь площадь штатов
area_dict = {'California': 423967,
             'Texas': 695662,
             'New York': 141297,
             'Florida': 170312,
             'Illinois': 149995}
area = pd.Series(area_dict)

# Словарь население
population_dict = {'California': 38332521,
                   'Texas': 26448193,
                   'New York': 19651127,
                   'Florida': 19552860,
                   'Illinois': 12882135}
population = pd.Series(population_dict)

# Создаем DataFrame
states = pd.DataFrame({'population': population, 'area': area})
print(states)

Результат:

            population    area
California    38332521  423967
Texas         26448193  695662
New York      19651127  141297
Florida       19552860  170312
Illinois      12882135  149995

Аналогично объекту Series у объекта DataFrame имеется атрибут index, обеспечивающий доступ к меткам индекса. Еще у объекта DataFrame есть атрибут columns, представляющий собой содержащий метки столбцов объект Index.

import pandas as pd

# Словарь площадь штатов
area_dict = {'California': 423967,
             'Texas': 695662,
             'New York': 141297,
             'Florida': 170312,
             'Illinois': 149995}
area = pd.Series(area_dict)

# Словарь население
population_dict = {'California': 38332521,
                   'Texas': 26448193,
                   'New York': 19651127,
                   'Florida': 19552860,
                   'Illinois': 12882135}
population = pd.Series(population_dict)

# Создаем DataFrame
states = pd.DataFrame({'population': population, 'area': area})

print('Индексы - states.index:')
print(states.index)
print('')
print('Колонки - states.columns:')
print(states.columns)

Результат:

Индексы - states.index:
Index(['California', 'Texas', 'New York', 'Florida', 'Illinois'], dtype='object')

Колонки - states.columns:
Index(['population', 'area'], dtype='object')

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

Объект DataFrame как специализированный словарь

DataFrame можно рассматривать как специализированный словарь. Если словарь задает соответствие ключей значениям, то DataFrame задает соответствие имени столбца объекту Series с данными этого столбца. Например, запрос данных по атрибуту ‘area’ приведет к тому, что будет возвращен объект Series, содержащий площади штатов:

import pandas as pd

# Словарь площадь штатов
area_dict = {'California': 423967,
             'Texas': 695662,
             'New York': 141297,
             'Florida': 170312,
             'Illinois': 149995}
area = pd.Series(area_dict)

# Словарь население
population_dict = {'California': 38332521,
                   'Texas': 26448193,
                   'New York': 19651127,
                   'Florida': 19552860,
                   'Illinois': 12882135}
population = pd.Series(population_dict)

# Создаем DataFrame
states = pd.DataFrame({'population': population, 'area': area})

print(states['area'])

Результат:

California    423967
Texas         695662
New York      141297
Florida       170312
Illinois      149995
Name: area, dtype: int64

Создание объектов DataFrame

Существует множество способов создания объектов DataFrame библиотеки Pandas. Вот несколько примеров.

Из одного объекта Series

Объект DataFrame — набор объектов Series.

DataFrame, состоящий из одного столбца, можно создать на основе одного объекта Series:

import pandas as pd

# Словарь население
population_dict = {'California': 38332521,
                   'Texas': 26448193,
                   'New York': 19651127,
                   'Florida': 19552860,
                   'Illinois': 12882135}
population = pd.Series(population_dict)

df = pd.DataFrame(population, columns=['population'])

print(df)

Результат:

            population
California    38332521
Texas         26448193
New York      19651127
Florida       19552860
Illinois      12882135

Из списка словарей

Любой список словарей можно преобразовать в объект DataFrame. Мы воспользуемся простым списковым включением для создания данных:

import pandas as pd

data = [{'a': i, 'b': 2 * i}
        for i in range(3)]

print('data:')
print(data)
print('')

df = pd.DataFrame(data)
print('df:')
print(df)

Результат:

data:
[{'a': 0, 'b': 0}, {'a': 1, 'b': 2}, {'a': 2, 'b': 4}]

df:
   a  b
0  0  0
1  1  2
2  2  4

Даже если некоторые ключи в словаре отсутствуют, библиотека Pandas просто заполнит их значениями NaN (то есть Not a number — «не является числом»):

import pandas as pd

df = pd.DataFrame([{'a': 1, 'b': 2}, {'b': 3, 'c': 4}])
print('df:')
print(df)

Результат:

df:
     a  b    c
0  1.0  2  NaN
1  NaN  3  4.0

Из словаря объектов Series

Объект DataFrame также можно создать на основе словаря объектов Series (этот пример был приведен ранее):

import pandas as pd

# Словарь площадь штатов
area_dict = {'California': 423967,
             'Texas': 695662,
             'New York': 141297,
             'Florida': 170312,
             'Illinois': 149995}
area = pd.Series(area_dict)

# Словарь население
population_dict = {'California': 38332521,
                   'Texas': 26448193,
                   'New York': 19651127,
                   'Florida': 19552860,
                   'Illinois': 12882135}
population = pd.Series(population_dict)

# Создаем DataFrame
df = pd.DataFrame({'population': population,
                   'area': area})

print(df)

Результат:

            population    area
California    38332521  423967
Texas         26448193  695662
New York      19651127  141297
Florida       19552860  170312
Illinois      12882135  149995 

Из двумерного массива NumPy

Если у нас есть двумерный массив данных, мы можем создать объект DataFrame с любыми заданными именами столбцов и индексов. Для каждого из пропущенных значений будет использоваться целочисленный индекс:

import numpy as np
import pandas as pd

df = pd.DataFrame(np.random.rand(3, 2),
                  columns=['foo', 'bar'],
                  index=['a', 'b', 'c'])
print(df)

Результат:

        foo       bar
a  0.290872  0.647270
b  0.690850  0.950563
c  0.468706  0.344193

Из структурированного массива NumPy

Объект DataFrame библиотеки Pandas ведет себя во многом аналогично структурированному массиву библиотеки NumPy и может быть создан непосредственно из него:

import numpy as np
import pandas as pd

A = np.zeros(3, dtype=[('A', 'i8'), ('B', 'f8')])
print('A:')
print(A)
print('')

df = pd.DataFrame(A)
print('df:')
print(df)

Результат:

A:
[(0, 0.) (0, 0.) (0, 0.)]

df:
   A    B
0  0  0.0
1  0  0.0
2  0  0.0

Объект Index библиотеки Pandas

Как объект Series, так и объект DataFrame содержат явный индекс, обеспечивающий возможность ссылаться на данные и модифицировать их.

Объект Index можно рассматривать или как неизменяемый массив (immutable array), или как упорядоченное множество (ordered set) (формально мультимножество, так как объекты Index могут содержать повторяющиеся значения). Из этих способов его представления следуют некоторые интересные возможности операций над объектами Index. В качестве простого примера создадим Index из списка целых чисел:

import pandas as pd

ind = pd.Index([2, 3, 5, 7, 11])
print(ind)

Результат:

Int64Index([2, 3, 5, 7, 11], dtype='int64')

Объект Index как неизменяемый массив

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

Результат:

ind[1]
3

ind[::2]
Int64Index([2, 5, 11], dtype='int64')

ind.size, ind.shape, ind.ndim, ind.dtype
5 (5,) 1 int64

Одно из различий между объектами Index и массивами NumPy — неизменяемость индексов, то есть их нельзя модифицировать стандартными средствами:

import pandas as pd

ind = pd.Index([2, 3, 5, 7, 11])
ind[1] = 0

Результат:

Traceback (most recent call last):
  File "C:/Users/User/Desktop/test.py", line 4, in <module>
    ind[1] = 0
  File "C:\Users\User\AppData\Local\Programs\Python\Python37-32\lib\site-packages\pandas\core\indexes\base.py", line 3938, in __setitem__
    raise TypeError("Index does not support mutable operations")
TypeError: Index does not support mutable operations

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

Выбор подмножеств данных в Pandas

Анатомия Python Pandas DataFrame — Column, Index, Data

Рассмотрим изображение контейнера данных DataFrame (библиотеки Pandas):

Три компонента DataFrame:

DataFrame состоит из трех различных компонентов: индекса , столбцов и данных. Данные также известны как значения.

Индекс — это последовательность значений в левой части DataFrame. Каждое отдельное значение индекса называется index label, Иногда индекс упоминается как заголовки строк. В приведенном выше примере метки строк не очень интересны и представляют собой целые числа, начиная с 0 до n-1, где n — количество строк в таблице.

Столбцы представляют собой последовательность значений в самой верхней части DataFrame.

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

Каждая строка имеет метку, каждая колонка имеет метку

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

Что такое выбор подмножества?

Прежде чем мы начнем делать выбор подмножества, было бы хорошо определить, что это такое. Выбор подмножества — это просто выбор определенных строк и столбцов данных из DataFrame (или Series). Это может означать выбор всех строк и некоторых столбцов, некоторых строк и всех столбцов или некоторых строк и столбцов.

Выбор при помощи []

Загружаем данные из CSV в Pandas DataFrame (Python 3)

В совокупности [], .loc и .iloc называются индексаторами. Это самые распространенные способы выбора данных.

Скачать файл для использования в примерах:

SampleData_Pandas.csv

Код загрузки данных из csv в Pandas DataFrame:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';', index_col=0)
print(df)

Результат:

Вариант 2 загрузки данных из CSV (Index генерируется самостоятельно)

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')
print(df)

Результат:

Извлечение отдельных компонентов DataFrame

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

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

index = df.index
columns = df.columns
values = df.values

index_list = df.index.tolist()
columns_list = df.columns.tolist()
values_list = df.values.tolist()

print('+++++ БЕЗ TOLIST() +++++')
print(index)
print('==========================')
print(columns)
print('==========================')
print(values)
print('==========================')


print('+++++ С TOLIST() +++++')
print(index_list)
print('==========================')
print(columns_list)
print('==========================')
print(values_list)

Результат:

Типы данных компонентов

Давайте выведем тип каждого компонента, чтобы точно понять, что это за объект.

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

index = df.index
columns = df.columns
values = df.values

index_list = df.index.tolist()
columns_list = df.columns.tolist()
values_list = df.values.tolist()

print('+++++ БЕЗ TOLIST() +++++')
print(type(index))
print('==========================')
print(type(columns))
print('==========================')
print(type(values))
print('==========================')


print('+++++ С TOLIST() +++++')
print(type(index_list))
print('==========================')
print(type(columns_list))
print('==========================')
print(type(values_list))

Результат:

+++++ БЕЗ TOLIST() +++++
<class 'pandas.core.indexes.range.RangeIndex'>
==========================
<class 'pandas.core.indexes.base.Index'>
==========================
<class 'numpy.ndarray'>
==========================

+++++ С TOLIST() +++++
<class 'list'>
==========================
<class 'list'>
==========================
<class 'list'>

Понимание этих типов

Интересно, что и индекс, и столбцы имеют одинаковый тип. Они оба Index-объект Pandas. Этот объект сам по себе довольно мощный, но сейчас вы можете думать о нем как о последовательности меток для строк или столбцов.

Значения (ячейки таблицы) — это numpy.ndarray, который обозначает n-мерный массив и является основным контейнером данных в библиотеке NumPy. 

Pandas построен непосредственно поверх NumPy, и именно этот массив отвечает за большую часть рабочей нагрузки.

Выбор одного столбца как серии

Чтобы выбрать один столбец данных, просто поместите имя столбца в скобках. Давайте выберем столбец Подразделение:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df['Подразделение'])

Результат:

0            Отдел продаж
1       Отдел продвижения
2       Отдел продвижения
3       Отдел продвижения
              ...        
2662         Отдел продаж
2663         Отдел продаж
2664         Отдел продаж
2665    Отдел продвижения
2666    Отдел продвижения
2667    Отдел продвижения
2668    Отдел продвижения
Name: Подразделение, Length: 2669, dtype: object

Анатомия Series, возвращаемой при выборе 1 столбца

Выбор одного столбца данных возвращает другой контейнер данных Pandas Series. 

Series — это одномерная последовательность помеченных данных. Существует два основных компонента Серии: указатель и данные (или значения . В серии нет колонок.

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

Вы также заметите две дополнительные части данных в нижней части Series. 

Name из Series становится старое имя колонки. Вы также увидите тип данных или dtype серии. Вы можете игнорировать оба этих элемента на данный момент. А также количество элементов Length.

Выбор нескольких столбцов с помощью оператора индексации

Можно выбрать несколько столбцов только с помощью оператора индексации, передав ему список имен столбцов. Давайте выберем ‘Подразделение’, ‘Менеджер’, ‘Номенклатура’, ‘Продажи’

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df[['Подразделение','Менеджер','Номенклатура','Продажи']])

Результат:

          Подразделение    Менеджер Номенклатура       Продажи
0          Отдел продаж      Петров         Лыжи   956898,3051
1     Отдел продвижения     Сидоров   Велосипеды   1841949,153
2     Отдел продвижения     Сидоров        Доски   1052542,373
3     Отдел продвижения     Сидоров      Палатки   74478,81356
4          Отдел продаж    Илинская   Велосипеды   1649745,763
5          Отдел продаж    Илинская        Доски   1263241,525
...                 ...         ...          ...           ...
2661       Отдел продаж      Петров       Прочее   423,7288136
2662       Отдел продаж    Илинская         Лыжи  -15254,23729
2663       Отдел продаж      Петров         Лыжи   8176271,186
2664       Отдел продаж      Петров       Прочее   171186,4407
2665  Отдел продвижения  Охлобыстин       Прочее   16949,15254
2666  Отдел продвижения    Розницов         Лыжи   15254,23729
2667  Отдел продвижения    Розницов       Одежда   1444915,254
2668  Отдел продвижения    Розницов       Прочее   3389,830508

[2669 rows x 4 columns]

Выбор нескольких столбцов возвращает DataFrame

Выбор нескольких столбцов возвращает DataFrame. На самом деле вы можете выбрать один столбец как DataFrame со списком из одного элемента:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df[['Подразделение']])

Результат:

          Подразделение
0          Отдел продаж
1     Отдел продвижения
2     Отдел продвижения
...                 ...
2666  Отдел продвижения
2667  Отдел продвижения
2668  Отдел продвижения

[2669 rows x 1 columns]

Хотя это напоминает Series, технически это DataFrame, другой объект.

Порядок столбцов не имеет значения

При выборе нескольких столбцов вы можете выбрать их в любом порядке по вашему выбору. Это не должен быть тот же самый порядок как оригинальный DataFrame.

Например, давайте выберем Номенклатура, Подразделение:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df[['Номенклатура','Подразделение']])

Результат:

     Номенклатура      Подразделение
0            Лыжи       Отдел продаж
1      Велосипеды  Отдел продвижения
2           Доски  Отдел продвижения
3         Палатки  Отдел продвижения
4      Велосипеды       Отдел продаж
...           ...                ...
2666         Лыжи  Отдел продвижения
2667       Одежда  Отдел продвижения
2668       Прочее  Отдел продвижения

[2669 rows x 2 columns]

Исключения, при выполнении скрипта

Есть несколько общих исключений, которые возникают при выполнении выборок только с помощью оператора индексации.

• Если вы ошиблись словом, вы получите KeyError
• Если вы забыли использовать список, содержащий несколько столбцов, вы также получите KeyError

print(df['ПодразделениЯ'])
Результат: 
KeyError: 'ПодразделениЯ'

print(df['Номенклатура','Подразделение'])
Результат:
KeyError: ('Номенклатура', 'Подразделение')

В первом случае должно стоять print(df['Подразделение']). А во-втором случае: print(df[['Номенклатура','Подразделение']]).

Выборка данных из Pandas DataFrame с помощью .loc

В .loc индексатор выбирает данные по-другому, чем просто оператор индексации. Он может выбирать подмножества строк и/или столбцов. Самое главное, он выбирает данные только по метке (label) строк и столбцов.

Выберем одну строку как Series с .loc

.loc — Индексатор возвращает одну строку в серии, когда указали одну метку строки (один индекс).

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[0])

Результат:

Дата                 01.01.2016
Подразделение      Отдел продаж
Контрагент           Абакус ООО
Менеджер                 Петров
Номенклатура               Лыжи
Продажи             956898,3051
Себестоимость       621983,8983
Валовая прибыль     334914,4068
Name: 0, dtype: object

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

Выбираем несколько строк из DataFrame с помощью .loc

Чтобы выбрать несколько строк, поместите все метки строк, которые вы хотите выбрать, в список и передайте их .loc. Давайте выберем 3 и 20.

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[[3,20]])

Результат:

          Дата      Подразделение  ... Себестоимость Валовая прибыль
3   01.01.2016  Отдел продвижения  ...   55859,11017     18619,70339
20  01.01.2016       Отдел продаж  ...   80585,27542     26861,75847

[2 rows x 8 columns]

Обозначение среза для выборки диапазона строк с .loc

Можно «нарезать» строки DataFrame с .locпомощью нотации среза. Для обозначения среза используется двоеточие для разделения значений начала, остановки и шага . Например, мы можем выбрать все строки из с 134 по 139:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[134:139])

Результат:

           Дата      Подразделение  ... Себестоимость Валовая прибыль
134  01.01.2016  Отдел продвижения  ...   560,5932203     62,28813559
135  01.01.2016       Отдел продаж  ...   625773,3051     268188,5593
136  01.01.2016  Отдел продвижения  ...   508671,6102     218002,1186
137  01.01.2016  Отдел продвижения  ...   1034427,966     443326,2712
138  01.01.2016  Отдел продвижения  ...   55792,37288     18597,45763
139  01.01.2016  Отдел продвижения  ...   8477,542373     941,9491525

[6 rows x 8 columns]

.loc включает в себя последнее значение из обозначения среза

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

Вывод среза с использованием .loc и шага из DataFrame

Выведем тот же самый результат, только будем выводить каждый второй элемент из среза:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[134:139:2])

Результат:

           Дата      Подразделение  ... Себестоимость Валовая прибыль
134  01.01.2016  Отдел продвижения  ...   560,5932203     62,28813559
136  01.01.2016  Отдел продвижения  ...   508671,6102     218002,1186
138  01.01.2016  Отдел продвижения  ...   55792,37288     18597,45763

[3 rows x 8 columns]

Выбор до указанной позиции .loc

Пример скрипта Python 3 для вывода 139 первых строк из Pandas DataFrame:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[:139])

Результат:

           Дата      Подразделение  ... Себестоимость Валовая прибыль
0    01.01.2016       Отдел продаж  ...   621983,8983     334914,4068
1    01.01.2016  Отдел продвижения  ...   1289364,407     552584,7458
2    01.01.2016  Отдел продвижения  ...    736779,661     315762,7119
3    01.01.2016  Отдел продвижения  ...   55859,11017     18619,70339
..          ...                ...  ...           ...             ...
136  01.01.2016  Отдел продвижения  ...   508671,6102     218002,1186
137  01.01.2016  Отдел продвижения  ...   1034427,966     443326,2712
138  01.01.2016  Отдел продвижения  ...   55792,37288     18597,45763
139  01.01.2016  Отдел продвижения  ...   8477,542373     941,9491525

[140 rows x 8 columns]

Тот же самый пример, но выведем с шагом 25:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[:139:25])

Результат выполнения выборки данных из Pandas DataFrame:

           Дата      Подразделение  ... Себестоимость Валовая прибыль
0    01.01.2016       Отдел продаж  ...   621983,8983     334914,4068
25   01.01.2016       Отдел продаж  ...   12813,55932     5491,525424
50   01.01.2016       Отдел продаж  ...   42978,81356     14326,27119
75   01.01.2016  Отдел продвижения  ...   6246,610169     694,0677966
100  01.01.2016  Отдел продвижения  ...   89694,91525     38440,67797
125  01.01.2016  Отдел продвижения  ...   879864,4068     377084,7458

[6 rows x 8 columns]

Выбор с указанной позиции до конца DataFrame через .loc

Полный код вывода данных из Pandas DataFrame:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[2660:])

Результат запроса к DataFrame:

            Дата      Подразделение  ... Себестоимость Валовая прибыль
2660  01.12.2017       Отдел продаж  ...   762,7118644     84,74576271
2661  01.12.2017       Отдел продаж  ...   381,3559322     42,37288136
2662  01.12.2017       Отдел продаж  ...  -9915,254237    -5338,983051
2663  01.12.2017       Отдел продаж  ...   5314576,271     2861694,915
2664  01.12.2017       Отдел продаж  ...   154067,7966     17118,64407
2665  01.12.2017  Отдел продвижения  ...   15254,23729     1694,915254
2666  01.12.2017  Отдел продвижения  ...   9915,254237     5338,983051
2667  01.12.2017  Отдел продвижения  ...   1083686,441     361228,8136
2668  01.12.2017  Отдел продвижения  ...   3050,847458     338,9830508

[9 rows x 8 columns]

Тот же пример, но с шагом 3 (вывод каждого третьего элемента из Pandas DataFrame с использованием .iloc[]):

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[2660::3])

Результат:

            Дата      Подразделение  ... Себестоимость Валовая прибыль
2660  01.12.2017       Отдел продаж  ...   762,7118644     84,74576271
2663  01.12.2017       Отдел продаж  ...   5314576,271     2861694,915
2666  01.12.2017  Отдел продвижения  ...   9915,254237     5338,983051

[3 rows x 8 columns]

Выбор строк и столбцов одновременно с .loc

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

df.loc [row_selection, column_selection]

Пример запроса на Python 3:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[[150,163],['Подразделение','Менеджер','Продажи']])

Результат:

         Подразделение Менеджер      Продажи
150       Отдел продаж   Петров   1067796,61
163  Отдел продвижения  Сидоров  13665,25424

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

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

• Один ярлык
• Список ярлыков
• slice с метками

Мы можем использовать любой из этих трех вариантов для выбора строки или столбца с помощью .loc. Давайте посмотрим несколько примеров.

Пример 1 «Выборка данных из Pandas DataFrame»:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[150:163:3,['Подразделение','Менеджер','Продажи']])

Результат:

         Подразделение  Менеджер      Продажи
150       Отдел продаж    Петров   1067796,61
153  Отдел продвижения  Добряков  82944,91525
156  Отдел продвижения  Добряков  85023,30508
159       Отдел продаж    Петров  499385,5932
162  Отдел продвижения   Сидоров  130805,0847

Выбор строк и столбцов через переменные

Гораздо проще назначить список строк и столбцов переменным перед использованием в .loc. Это полезно, если вы выбираете много строк или столбцов:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

rows = [59, 134, 1045]
columns = ['Контрагент', 'Номенклатура', 'Продажи'] 
print(df.loc[rows, columns])

Результат:

        Контрагент Номенклатура      Продажи
59        ИП Лусон   Велосипеды  1139110,169
134        Союз АО       Прочее  622,8813559
1045  Эсвольтр ООО       Прочее  2915,254237

Пример параметризации с slice:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

iStart = 59
iEnd = 134
iStep = 7
columns = ['Контрагент', 'Номенклатура', 'Продажи'] 
print(df.loc[iStart:iEnd:iStep, columns])

Результат:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

iStart = 59
iEnd = 134
iStep = 7
columns = ['Контрагент', 'Номенклатура', 'Продажи'] 
print(df.loc[iStart:iEnd:iStep, columns])

Выборка данных из Pandas DataFrame с помощью индексатора .iloc[]

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

Выбор одной строки при помощи .iloc

Передав одно целое число в .iloc, он выберет одну строку в качестве ряда:

Код запроса:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.iloc[5])

Результат:

Дата                  01.01.2016
Подразделение       Отдел продаж
Контрагент         Билли Боб ООО
Менеджер                Илинская
Номенклатура               Доски
Продажи              1263241,525
Себестоимость        884269,0678
Валовая прибыль      378972,4576
Name: 5, dtype: object

Выбор нескольких строк с .iloc

Используйте список целых чисел, чтобы выбрать несколько строк:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.iloc[[5,45,876]])

Результат:

           Дата      Подразделение  ... Себестоимость Валовая прибыль
5    01.01.2016       Отдел продаж  ...   884269,0678     378972,4576
45   01.01.2016       Отдел продаж  ...   162972,4576     69845,33898
876  01.08.2016  Отдел продвижения  ...   444322,0339     190423,7288

[3 rows x 8 columns]

Выборка диапазона строк через указание среза в .iloc

В случае с .iloc нотация слайса работает так же, как и список, и исключает последний элемент.

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.iloc[5:9])

Результат:

         Дата      Подразделение  ... Себестоимость Валовая прибыль
5  01.01.2016       Отдел продаж  ...   884269,0678     378972,4576
6  01.01.2016       Отдел продаж  ...   16517,47881     5505,826271
7  01.01.2016       Отдел продаж  ...   1098,305085     122,0338983
8  01.01.2016  Отдел продвижения  ...   22957,62712     9838,983051

[4 rows x 8 columns]

Выбор строк и столбцов одновременно в .iloc

Рассмотрим несколько примеров, чтобы понять, чем отличается .iloc от .loc.

Выберем две строки и два столбца:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.iloc[[2,3], [0,3]])

Результат:

         Дата Менеджер
2  01.01.2016  Сидоров
3  01.01.2016  Сидоров

Осуществим выборку строк и столбцов с помощью среза:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.iloc[2:9, 0:3])

Результат:

         Дата      Подразделение     Контрагент
2  01.01.2016  Отдел продвижения     Абакус ООО
3  01.01.2016  Отдел продвижения     Абакус ООО
4  01.01.2016       Отдел продаж  Билли Боб ООО
5  01.01.2016       Отдел продаж  Билли Боб ООО
6  01.01.2016       Отдел продаж  Билли Боб ООО
7  01.01.2016       Отдел продаж  Билли Боб ООО
8  01.01.2016  Отдел продвижения  Билли Боб ООО

Выберем 1 значение из столбца и указанной колонки:

import pandas as pd
import numpy as np

df = pd.read_csv('D:\#python#\example\SampleData_Pandas.csv', sep=';')

print(df.loc[3, 4])

Результат:

Палатки

Резюме по .loc и .iloc

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

• .loc — используется для доступа по строковой метке — т.е. фактически по значению индекса и по названию столбца
• .iloc — используется для доступа по числовому значению (начиная от 0) — т.е. по номеру строки и номеру столбца

Как выбрать строки из Pandas DataFrame по условию

Собираем тестовый набор данных для иллюстрации работы выборки по условию

Пишем скрипт:

import pandas as pd

Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'],
         'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'],
         'Price': [10,15,5,5,10,15,15,5]
        }

df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price'])
print (df)

Результат выполнения:

   Color      Shape  Price
0  Green  Rectangle     10
1  Green  Rectangle     15
2  Green     Square      5
3   Blue  Rectangle      5
4   Blue     Square     10
5    Red     Square     15
6    Red     Square     15
7    Red  Rectangle      5

Синтаксис выборки строк из Pandas DataFrame по условию

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

df.loc[df.column name condition]

Например, если вы хотите получить строки с зеленым цветом , вам нужно применить:

df.loc[df.Color == 'Green']

Где:

• Color — это название столбца
• Green — это условие (значение колонки)

А вот полный код Python для нашего примера:

import pandas as pd

Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'],
         'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'],
         'Price': [10,15,5,5,10,15,15,5]
        }

df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price'])
print (df.loc[df.Color == 'Green'])

Результат:

   Color      Shape  Price
0  Green  Rectangle     10
1  Green  Rectangle     15
2  Green     Square      5

Выберем строки, где цена равна или больше 10

Чтобы получить все строки, где цена равна или больше 10, Вам нужно применить следующее условие:

df.loc[df.Price >= 10]

Полный код Python:

import pandas as pd

Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'],
         'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'],
         'Price': [10,15,5,5,10,15,15,5]
        }

df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price'])

print (df.loc[df.Price >= 10])

Результат:

   Color      Shape  Price
0  Green  Rectangle     10
1  Green  Rectangle     15
4   Blue     Square     10
5    Red     Square     15
6    Red     Square     15

Выберем строки, в которых цвет зеленый, а форма — прямоугольник

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

• Color зеленый; а также
• Shape = прямоугольник

Мы будем использовать символ & для применения нескольких условий. В нашем примере код будет выглядеть так:

df.loc[(df.Color == 'Green') & (df.Shape == 'Rectangle')]

Полный код примера Python для выборки Pandas DataFrame:

import pandas as pd

Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'],
         'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'],
         'Price': [10,15,5,5,10,15,15,5]
        }

df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price'])

print (df.loc[(df.Color == 'Green') & (df.Shape == 'Rectangle')])

Результат:

   Color      Shape  Price
0  Green  Rectangle     10
1  Green  Rectangle     15

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

Для достижения этой цели будем использовать символ | следующим образом:

df.loc[(df.Color == 'Green') | (df.Shape == 'Rectangle')]

Полный код Python 3:

import pandas as pd

Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'],
         'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'],
         'Price': [10,15,5,5,10,15,15,5]
        }

df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price'])

print (df.loc[(df.Color == 'Green') | (df.Shape == 'Rectangle')])

Результат:

   Color      Shape  Price
0  Green  Rectangle     10
1  Green  Rectangle     15
2  Green     Square      5
3   Blue  Rectangle      5
7    Red  Rectangle      5

Выберем строки, где цена не равна 15

Мы будем использовать комбинацию символов !=, чтобы выбрать строки, цена которых не равна 15:

df.loc[df.Price != 15]

Полный код Pandas DF на питоне:

import pandas as pd

Boxes = {'Color': ['Green','Green','Green','Blue','Blue','Red','Red','Red'],
         'Shape': ['Rectangle','Rectangle','Square','Rectangle','Square','Square','Square','Rectangle'],
         'Price': [10,15,5,5,10,15,15,5]
        }

df = pd.DataFrame(Boxes, columns= ['Color','Shape','Price'])

print (df.loc[df.Price != 15])

Результат работы скрипта Python:

   Color      Shape  Price
0  Green  Rectangle     10
2  Green     Square      5
3   Blue  Rectangle      5
4   Blue     Square     10
7    Red  Rectangle      5

Data Wrangling with Pandas

• Data Wrangling Pandas Cheat Sheet.pdf
• Data Wrangling With Pandas

Обработка данных с помощью Pandas (Data Wrangling)

Обработка данных является одной из важнейших задач в data science и анализе данных, которая включает такие операции, как:

• Dealing with missing values (Работа с пропущенными значениями) — количественная оценка пропущенных значений для каждого столбца, заполнение и удаление пропущенных значений.
• Reshaping data (Изменение формы данных) — единая кодировка данных, сводные таблицы, объединения, группировка и агрегирование.
• Data Sorting (Сортировка данных): упорядочивание значений в порядке возрастания или убывания.
• Data Filtration (Фильтрация данных): создание подмножества данных согласно тем или иным условиям.
• Data deduplication (Дедупликация данных) — это технология поиска и устранения дубликатов в хранилищах данных. Применяется для снижения накладные расходов на хранение информации.
• Data Reduction (Понижение размерности/Сокращение данных): Уменьшение объема данных, сокращение количества используемых признаков и разнообразия их значений. Применяется в случае, когда данные избыточны. Избыточность возникает тогда, когда задачу анализа можно решить с тем же уровнем эффективности и точности, но используя меньшую размерность данных. Это позволяет сократить время и вычислительные затраты на решение задачи, сделать данные и результаты их анализа более интерпретируемыми и понятными для пользователя.
• Data Access (Доступ к данным): для чтения или записи файлов данных.
• Data Handling/Data Processing (Обработка данных) или Data Transformation (преобразование данных): выполнение агрегации, статистических и подобных операций над конкретными значениями.
• Другое: Создание описательных столбцов, поэлементные условные операции.

Concatenation DataFrame

todo

Joining DataFrame

todo

Merging DataFrame

todo

Pivot & Melt (Unpivot) DataFrame

todo

GroupBy Операции

todo

Применение Lambda функции в DataFrame

todo

10 трюков Python Pandas, которые сделают вашу работу более эффективной

Pandas — это широко используемый пакет Python для структурированных данных.

read_csv

Все знают эту команду. Но данные, которые вы пытаетесь прочитать, велики, попробуйте добавить этот аргумент: nrows = 5, чтобы загружать только часть данных. Тогда вы можете избежать ошибки, выбрав неправильный разделитель (он не всегда может быть разделен запятой).

(Или вы можете использовать команду ‘head’ в linux, чтобы проверить первые 5 строк (скажем) в любом текстовом файле: head -n 5 data.txt)

Затем вы можете извлечь список столбцов, используя df.columns.tolist()для извлечения всех столбцов, а затем добавить аргумент usecols = [‘c1’, ‘c2’,…], чтобы загрузить нужные вам столбцы. 

Кроме того, если вы знаете типы данных нескольких определенных столбцов, вы можете добавить аргумент dtype = {‘c1’: str, ‘c2’: int,…}, чтобы он загружался быстрее. 

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

select_dtypes

Если предварительная обработка данных должна выполняться в Python, эта команда сэкономит вам время. После чтения в таблице типами данных по-умолчанию для каждого столбца могут быть bool, int64, float64, object, category, timedelta64 или datetime64. Вы можете сначала проверить распределение по

df.dtypes.value_counts()

чтобы узнать все возможные типы данных вашего DataFrame

df.select_dtypes(include=['float64', 'int64'])

выбрать sub-dataframe только с числовыми характеристиками.

copy()

Это важная команда, если вы еще не слышали о ней. Если вы выполните следующие команды:

import pandas as pd
df1 = pd.DataFrame({ 'a':[0,0,0], 'b': [1,1,1]})
df2 = df1
df2['a'] = df2['a'] + 1
df1.head()

Вы обнаружите, что df1 изменен. Это потому, что df2 = df1 не делает копию df1 и присваивает ее df2, но устанавливает указатель, указывающий на df1. Таким образом, любые изменения в df2 приведут к изменениям в df1. Чтобы это исправить, вы можете сделать либо

df2 = df1.copy()

или же

from copy import deepcopy
df2 = deepcopy(df1)

map()

Это классная команда для простого преобразования данных. Сначала вы определяете словарь, в котором «ключами» являются старые значения, а «значениями» являются новые значения.

level_map = {1: 'high', 2: 'medium', 3: 'low'}
df['c_level'] = df['c'].map(level_map)

Некоторые примеры:

True, False до 1, 0 (для моделирования); определение уровней; определяемые пользователем лексические кодировки.

apply or not apply?

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

def rule(x, y):
    if x == 'high' and y > 10:
         return 1
    else:
         return 0
df = pd.DataFrame({ 'c1':[ 'high' ,'high', 'low', 'low'], 'c2': [0, 23, 17, 4]})
df['new'] = df.apply(lambda x: rule(x['c1'], x['c2']), axis =  1)
df.head()

В приведенных выше кодах мы определяем функцию с двумя входными переменными и используем функцию apply, чтобы применить ее к столбцам ‘c1’ и ‘c2’.

Но проблема «apply» в том , что иногда он слишком медленный . Скажем, если вы хотите вычислить максимум из двух столбцов «c1» и «c2», конечно, вы можете сделать

df['maximum'] = df.apply(lambda x: max(x['c1'], x['c2']), axis = 1)

но вы найдете это намного медленнее, чем эта команда:

df['maximum'] = df[['c1','c2']].max(axis =1)

Вывод: не используйте apply, если вы можете выполнить ту же работу с другими встроенными функциями (они часто быстрее). Например, если вы хотите округлить колонку «с» целыми числами, делать

round(df[‘c’], 0)

или

df[‘c’].round(0)

Вместо использования функции применяются: 

df.apply(lambda x: round(x['c'], 0), axis = 1)

value counts

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

df['c'].value_counts()

Есть несколько полезных трюков / аргументов:

1. normalize = True: если вы хотите проверить частоту вместо количества.
   
2. dropna = False: если вы также хотите включить пропущенные значения в статистику.
   
3. df['c'].value_counts().reset_index().: если вы хотите преобразовать таблицу статистики в кадр данных pandas и манипулировать ею
   
4. df['c'].value_counts().sort_index(): показать статистику, отсортированную по разным значениям, в столбце «c» вместо счетчиков.

number of missing values — количество пустых значений

При построении моделей может потребоваться исключить строку со слишком большим количеством пропущенных значений / строки со всеми пропущенными значениями. Вы можете использовать .isnull() и .sum() для подсчета количества пропущенных значений в указанных столбцах.

import pandas as pd
import numpy as np
df = pd.DataFrame({ 'id': [1,2,3], 'c1':[0,0,np.nan], 'c2': [np.nan,1,1]})
df = df[['id', 'c1', 'c2']]
df['num_nulls'] = df[['c1', 'c2']].isnull().sum(axis=1)
df.head()

выбрать строки с конкретными идентификаторами (select rows with specific IDs)

В SQL мы можем сделать это, используя SELECT * FROM … WHERE ID in (‘A001’, ‘C022’, …), чтобы получить записи с конкретными идентификаторами. Если вы хотите сделать то же самое с Pandas, вы можете сделать

df_filter = df['ID'].isin(['A001','C022',...])
df[df_filter]

Процентильные группы (Percentile groups)

У вас есть числовой столбец, и вы хотите классифицировать значения в этом столбце по группам, скажем, верхние 5% в группе 1, 5–20% в группе 2, 20–50% в группе 3, нижние 50% в группе 4 Конечно, вы можете сделать это с помощью pandas.cut, но я бы хотел предоставить здесь другую опцию:

import numpy as np
cut_points = [np.percentile(df['c'], i) for i in [50, 80, 95]]
df['group'] = 1
for i in range(3):
    df['group'] = df['group'] + (df['c'] < cut_points[i])
# or <= cut_points[i]

который быстро запускается (не применяется функция apply).

to_csv

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

print(df[:5].to_csv())

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

Еще один трюк — это смешанные целые числа и пропущенные значения. Если столбец содержит как пропущенные значения, так и целые числа, тип данных по-прежнему будет плавающим, а не целым. Когда вы экспортируете таблицу, вы можете добавить float_format=‘%.0f’, чтобы округлить все числа с плавающей точкой до целых чисел. Используйте этот трюк, если вам нужны только целочисленные выходные данные для всех столбцов — вы избавитесь от всех назойливых ‘.0’s.

Сообщение Python 3 Pandas: Объекты Series и DataFrame. Построение Index появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.