В этой статье будет разобрана природа возникновения папки __pycache__, которая создается при запуске кода Python.

Введение

Наверное, вы заметили, что при выполнении кода Python __pycache__ (иногда) создается каталог с именем, который содержит множество файлов с .pyc расширением.

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

Файлы .pyc и папка __pycache__

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

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

Таким образом, после первого выполнения вашего исходного кода будет создана папка __pycache__, содержащая несколько .pyc файлов байт-кода с теми же именами, что и ваши .py файлы. Как уже упоминалось, они будут использоваться в последующих исполнениях, чтобы ваша программа запускалась немного быстрее.

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

Подавление/запрет создания __pycache__

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

Первый вариант — передать -B флаг при запуске файла Python. Когда флаг указан, Python не будет пытаться записывать .pyc файлы при импорте исходных модулей:

python3 -B my_python_app.py

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

export PYTHONDONTWRITEBYTECODE=abc

Обратите внимание, что оба подхода эквивалентны.

Добавление __pycache__ в файл .gitignore

При работе в локальном репозитории Git будет отслеживать каждый файл в репозитории Git. Каждый файл может быть отслежен (т.е. уже подготовлен и зафиксирован), не отслежен (не подготовлен или зафиксирован) или проигнорирован.

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

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

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

# .gitignore
__pycache__/

Важное

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

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

Python List vs. Tuple

В этой статье будет рассмотрена разница между списком и кортежем (List vs. Tuple).

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

Важные различия между List и Tuple в Python

Список против кортежа

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

# Creating a List with
# the use of Numbers
# code to test that tuples are mutable
List = [1, 2, 4, 4, 3, 3, 3, 6, 5]
print("Original list ", List)
 
List[3] = 77
print("Example to show mutablity ", List)

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

Исходный список [1, 2, 4, 4, 3, 3, 3, 6, 5] 
Пример для демонстрации изменчивости [1, 2, 4, 77, 3, 3, 3, 6, 5]

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

tuple1 = (0, 1, 2, 3)
tuple1[0] = 4
print(tuple1)

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

Traceback (most recent call last):
  File "tuple_example.py", line 3, in
    tuple1[0]=4
TypeError: 'tuple' object does not support item assignment

Проверка эффективности работы кортежей с памятью

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

import sys
a_list = []
a_tuple = ()
a_list = ["Lemons", "And", "Apples"]
a_tuple = ("Lemons", "And", "Apples")
print(sys.getsizeof(a_list))
print(sys.getsizeof(a_tuple))

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

120
64

Проверка скорости итераций в Tuple по сравнению с List

import sys, platform
import time
 
l=list(range(100000001))
t=tuple(range(100000001))
 
start = time.time_ns()
for i in range(len(t)):
    a = t[i]
end = time.time_ns()
print("Total lookup time for Tuple: ", end - start)
 
start = time.time_ns()
for i in range(len(l)):
    a = l[i]
end = time.time_ns()
print("Total lookup time for LIST: ", end - start)

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

Общее время поиска для Tuple: 7038208700 
Общее время поиска для LIST: 19646516700

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

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

Использование объекта (object)

Это похоже на C/C++ и Java, мы можем создать класс (в C, структуру) для хранения нескольких значений и возврата объекта класса.

# A Python program to return multiple 
# values from a method using class
class Test:
    def __init__(self):
        self.str = "string example"
        self.x = 20   
  
# This function returns an object of Test
def fun():
    return Test()
      
# Driver code to test above method
t = fun() 
print(t.str)
print(t.x)

Результат работы кода:

string example
20

Использование кортежа (tuple)

Кортеж представляет собой последовательность элементов, разделенных запятыми. Он создается с или без (). Кортежи неизменны.

# A Python program to return multiple 
# values from a method using tuple
  
# This function returns a tuple
def fun():
    str = "string example"
    x   = 20
    return str, x;  # Return tuple, we could also
                    # write (str, x)
  
# Driver code to test above method
str, x = fun() # Assign returned tuple
print(str)
print(x)

Результат работы кода:

string example
20

Использование списка (list)

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

# A Python program to return multiple 
# values from a method using list
  
# This function returns a list
def fun():
    str = "string example"
    x = 20   
    return [str, x];  
  
# Driver code to test above method
list = fun() 
print(list)

Результат работы кода:

['string example', 20]

Использование словаря (dictionary)

Словарь похож на хэш или карту на других языках.

# A Python program to return multiple 
# values from a method using dictionary
  
# This function returns a dictionary
def fun():
    d = dict(); 
    d['str'] = "string example"
    d['x']   = 20
    return d
  
# Driver code to test above method
d = fun() 
print(d)

Результат работы кода:

{'x': 20, 'str': 'string example'}

Использование класса данных (Data Class)

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

from dataclasses import dataclass
  
@dataclass
class Book_list:
    name: str
    perunit_cost: float
    quantity_available: int = 0
          
    # function to calculate total cost    
    def total_cost(self) -> float:
        return self.perunit_cost * self.quantity_available
      
book = Book_list("Introduction to programming.", 300, 3)
x = book.total_cost()
  
# print the total cost
# of the book
print(x)
  
# print book details
print(book)
  
# 900
Book_list(name='Python programming.',
          perunit_cost=200,
          quantity_available=3)

Результат работы кода:

900
Book_list(name='Introduction to programming.', perunit_cost=300, quantity_available=3)
Book_list(name='Python programming.', perunit_cost=200, quantity_available=3)

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

Краткое введение в Flask

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

Flask разрабатывает Армин Ронахер, возглавляющий международную группу энтузиастов Python под названием Pocco. Flask основан на наборе инструментов Werkzeug WSGI и механизме шаблонов Jinja2. Оба являются проектами Pocco.

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

Jinja2 — популярный движок шаблонов для Python. Система веб-шаблонов объединяет шаблон с определенным источником данных для отображения динамических веб-страниц.

Что будет рассмотрено в статье «Python Flask App — Docker — Tutorial»

В этой статье будет рассмотрено создание простого web-приложения Flask, build образа с помощью Dockerfile & Docker, а также развертывание образа в контейнере с помощью Docker-Compose.

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

Создание приложения Flask

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

Создадим папку с именем flask_docker для нашего приложения:

mkdir flask_docker

Переходим внутрь папки:

cd flask_docker

Если у Вас не установлена виртуальная среда venv, то необходимо ее исталлировать командой:

sudo apt install python3.8-venv

Далее создаем виртуальную среду myenv

python3 -m venv myenv

Должна появиться директория myenv. Запускаем команду активации виртуальной среды:

source myenv/bin/activate

Внутри активированной виртуальной среды запускаем установку библиотеки Flask:

pip install Flask

После успешной установки Flask следующим шагом будет создание файла Python app.py, который будет получать запросы и отправлять ответы для нашего web-приложения. Для этого создадим директорию webapp:

mkdir webapp

cd webapp

Далее нам нужно в директории webapp создать файл файл app.py со следущим кодом внутри:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return '<h1>Hello, World!</h1>'

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0', port=5000)

В приведенном выше фрагменте кода аннотация служит для направления запроса на URL-адрес. В указанном примере URL-адрес представляет собой домашнюю страницу @app.route/

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

Вот пример того, как вы можете указать, что ваш маршрут должен разрешать оба метода GET и POST для запроса HTTP:

@app.route('/', methods=['POST', 'GET'])

Функция home(), связанная с URL-адресом, указанным в аннотации, будет выполняться при отправке запроса на этот маршрут. Функция возвращает строку текста '<h1>Hello, World!</h1>'.

Как создать Python requirement.txt файл для Docker

Файл requirement.txt содержит список пакетов и зависимостей, необходимых для запуска вашего проекта, а также их соответствующие версии, требуемые для корректной работы приложения.

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

pip freeze > requirements.txt

Эта команда сгенерирует имена пакетов и их соответствующих версий, которые вы установили, а также некоторые другие встроенные зависимости, которые запускают ваше приложение Flask. Затем он сохраняет их в файле с именем requirements.txt

click==8.1.2
Flask==2.1.1
importlib-metadata==4.11.3
itsdangerous==2.1.2
Jinja2==3.1.1
MarkupSafe==2.1.1
Werkzeug==2.1.1
zipp==3.8.0

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

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

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

python app.py

Настройка Dockerfile для создания образа приложения Flask

Создайте файл Dockerfile внутри webapp. Добавьте в файл следующий фрагмент кода:

# start by pulling the python image
FROM python:3.8-alpine

# copy the requirements file into the image
COPY ./requirements.txt /app/requirements.txt

# switch working directory
WORKDIR /app

# install the dependencies and packages in the requirements file
RUN pip install -r requirements.txt

# copy every content from the local file to the image
COPY . /app

# configure the container to run in an executed manner
ENTRYPOINT ["python"]

CMD ["app.py"]

Давайте рассмотрим инструкции в этом Dockerfile:

• FROM python:3.8-alpine — Поскольку Docker позволяет нам наследовать существующие образы, мы устанавливаем образ Python и устанавливаем его в наш образ Docker. Alpine — это легкий дистрибутив Linux, который будет служить ОС, на которую мы устанавливаем наш образ
• COPY ./requirements.txt /app/requirements.txt — Здесь мы копируем requirements файл и его содержимое (сгенерированные пакеты и зависимости) в app папку образа.
• WORKDIR /app — мы приступаем к установке рабочего каталога как app, который будет корневым каталогом нашего приложения в контейнере.
• RUN pip install -r requirements.txt — эта команда устанавливает все зависимости, определенные в файле requirements.txt в наше приложение внутри контейнера.
• COPY . /app — это копирует все остальные файлы и их соответствующее содержимое в app папку, которая является корневым каталогом нашего приложения в контейнере.
• ENTRYPOINT ["python"] — это команда, которая запускает приложение в контейнере.
• CMD ["app.py"] — Наконец, это добавляет список параметров к EntryPoint параметру для выполнения команды, запускающей приложение. Это похоже на то, как вы запускаете приложение Python на своем терминале с помощью команды python app.py

Создадим образ (image) Docker

Выйдем из активированной среды venv:

deactivate

Для этого необходимо в командном окне (не в активированной среде), запустить команду:

sudo docker image build -t flask_docker .

Точка в конце обязательна, не пропустите её.

Запуск контейнера из образа в Docker

После успешного билда образа необходимо запустить экземляр образа в Docker. Сделать это можно следующей командой:

sudo docker run -p 5000:5000 -d flask_docker

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

Вот вывод нашего приложения, когда мы отправляем запрос в нашем браузере:

localhost:5000

Предупреждение

WARNING: Running pip as the ‘root’ user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv

туду

Развертывание Flask App, PostgreSQL, PGAdmin с помощью Docker-Compose

Для создания приложения необходимо добавить базу данных postgresql, панель управления pgadmin, а также пропишем процесс сборки образа на основе нашего Dockerfile.

Файл docker-compose.yml:

version: '3.9'

services:  
  flask_web:
    container_name: flask_web_container
    build: .
    ports:
      - 5000:5000
    restart: unless-stopped

  postgres:
    env_file: ./docker/.env-postgresql
    container_name: postgres_flask_container
    image: postgres:14
    volumes:
       - flaskdb:/var/lib/postgresql/data
    ports:
      - 5432:5432
    restart: unless-stopped
    networks:
      - backend
  
  pgadmin:
    container_name: pgadmin_container
    image: dpage/pgadmin4
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL:-qlik@ivan-shamaev.ru}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD:-A->V9>pS6HJ~xY8d}
      PGADMIN_CONFIG_SERVER_MODE: 'False'
    volumes:
       - pgadmin:/var/lib/pgadmin
    ports:
      - "${PGADMIN_PORT:-5050}:80"
    restart: unless-stopped
    networks:
      - backend

volumes:
    flaskdb:
      driver: local
    pgadmin:
      driver: local

networks:
  backend:
    driver: bridge

Файл docker/.env-postgresql:

# database engine specific environment variables
DATABASE_PORT=5432
DATABASE_DIALECT=postgresql
POSTGRES_DB=flaskdb
POSTGRES_USER=flaskuser
POSTGRES_PASSWORD=flaskpassword

Доступ в pgadmin http://localhost:5050/browser/

Скачать код первого этапа для развертывания flask приложения в docker

Получить код пройденного этапа можно в github deploy-python-flask-app-tutorial/Example 1/.

Сообщение Создание Web-приложения Flask и деплой с помощью Docker Compose & Dockerfile появились сначала на Python 3 | Data Science | Нейронные сети | AI - Искусственный Интеллект.

Есть библиотека для расчета индикаторов по техническому анализу. Ниже пример (не все идеально, как ориентир). Ссылка на библиотеку https://github.com/mrjbq7/ta-lib

#=====================================================
# Импорт библиотек
#=====================================================
from iexfinance.stocks import get_historical_data
import datetime
import pandas as pd
from pandas import DataFrame
import talib as ta
import matplotlib.pyplot as plt
import seaborn as sns
import psycopg2
import csv
from sqlalchemy import create_engine
import json
import requests
from sys import argv
from scipy.signal import argrelextrema
import numpy as np

#=====================================================
# ЗАГРУЗКА ДАННЫХ ИЗ API
#=====================================================
symbol = argv[1]
interval = argv[2]
urltext = 'https://api.binance.com/api/v1/klines?symbol='+symbol+'&interval='+interval
result_req = requests.get(urltext)

result_json = result_req.json()

# Получаем наименования колонок
array_data = []
for row in result_json:
    array_data.append({
                        'open_time':row[0],
                        'date_time':datetime.datetime.fromtimestamp(row[0] / 1e3).strftime('%Y-%m-%d %H:%M:%S'), #utcfromtimestamp fromtimestamp #utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
            'dateformat':datetime.datetime.fromtimestamp(row[0] / 1e3).strftime('%Y.%m.%d %H:%M'),
                        'open':(row[1]),
                        'high':(row[2]),
                        'low':(row[3]),
                        'close':(row[4]),
                        'volume':(row[5])
                        })
    

# Формируем массив data
data = pd.DataFrame(array_data)

multipleCoeff = 1000
data['open']=pd.to_numeric(data['open']).mul(multipleCoeff)
data['high']=pd.to_numeric(data['high']).mul(multipleCoeff)
data['low']=pd.to_numeric(data['low']).mul(multipleCoeff)
data['close']=pd.to_numeric(data['close']).mul(multipleCoeff)
data['volume']=pd.to_numeric(data['volume']).mul(multipleCoeff)

data.index = pd.to_datetime(data.date_time)

#==============================================
# ПОЛУЧАЕМ ПАРАМЕТРЫ ИЗ БАЗЫ ДАННЫХ
#==============================================

# 1. Подключаемся к базе данных PGSQL
conn = psycopg2.connect(dbname='dbname', user='username', 
                        password='your_password', host='96.154.12.134')
# 2. Получаем данные, кладем их в курсор
cursor = conn.cursor()
cursor.execute('select trim(parameter) parameter,value from ddt.calc_settings')

# 3. Пишем paramData[]
paramData = []
for paramRow in cursor:
    paramData.append(paramRow)

# 4. Закрываем курсор
cursor.close()
conn.close()

# 5. Устанавливаем переменные
for row in enumerate(paramData):
    exec("%s=%s" % (row[1][0],row[1][1]))


#=====================================================
# Расчет
#=====================================================

#Фрактал
n_min_max = 5
data['Fractal_UP'] = data.iloc[argrelextrema(data.low.values, np.less_equal, order=n_min_max)[0]]['low']
data['Fractal_Down'] = data.iloc[argrelextrema(data.high.values, np.greater_equal, order=n_min_max)[0]]['high']

# Обнуляем последний элемент массива по фракталу
data['Fractal_UP'].iloc[-1] = np.nan
data['Fractal_Down'].iloc[-1] = np.nan

# Simple Moving Average
data['SMA'] = ta.SMA(data.close, timeperiod = SMA_TimePeriod)

# Exponential Moving Average
data['EMA'] = ta.EMA(data.close, timeperiod = EMA_TimePeriod)

# Bollinger Bands
data['upper_band'], data['middle_band'], data['lower_band'] = ta.BBANDS(data.close, timeperiod = Bollinger_Bands_TimePeriod)

# MACD
data['macd'], data['macdsignal'], data['macdhist'] = ta.MACD(data.close, fastperiod=MACD_fastperiod, slowperiod=MACD_slowperiod, signalperiod=MACD_signalperiod)

# RSI
data['RSI'] = ta.RSI(data.close, timeperiod=RSI_TimePeriod)

# OBV (On Balance Volume)
data['OBV'] = ta.OBV(data.close, data.volume)

#Alligator SMA
data['SMA_green'] = ta.SMA(data.close, timeperiod = SMA_Green_TimePeriod)
data['SMA_red'] = ta.SMA(data.close, timeperiod = SMA_Red_TimePeriod)
data['SMA_blue'] = ta.SMA(data.close, timeperiod = SMA_Blue_TimePeriod)

#Alligator EMA
data['EMA_green'] = ta.EMA(data.close, timeperiod = EMA_Green_TimePeriod)
data['EMA_red'] = ta.EMA(data.close, timeperiod = EMA_Red_TimePeriod)
data['EMA_blue'] = ta.EMA(data.close, timeperiod = EMA_Blue_TimePeriod)

#ADX
data['ADX'] = ta.ADX(data.high, data.low, data.close, timeperiod=ADX_TimePeriod)
data['MINUS_DI'] = ta.MINUS_DI(data.high, data.low, data.close, timeperiod=ADX_TimePeriod)
data['PLUS_DI'] = ta.PLUS_DI(data.high, data.low, data.close, timeperiod=ADX_TimePeriod)

data['TEMA'] = ta.TEMA(data.close, timeperiod=TEMA_TimePeriod)

# Убираем масштабирование
data['open'] = pd.to_numeric(data['open'])/multipleCoeff
data['high'] = pd.to_numeric(data['high'])/multipleCoeff
data['low'] = pd.to_numeric(data['low'])/multipleCoeff
data['close'] = pd.to_numeric(data['close'])/multipleCoeff
data['upper_band'] = pd.to_numeric(data['upper_band'])/multipleCoeff
data['middle_band'] = pd.to_numeric(data['middle_band'])/multipleCoeff
data['lower_band'] = pd.to_numeric(data['lower_band'])/multipleCoeff
data['volume'] = pd.to_numeric(data['volume'])/multipleCoeff
data['OBV'] = pd.to_numeric(data['OBV'])/multipleCoeff
data['SMA'] = pd.to_numeric(data['SMA'])/multipleCoeff
data['EMA'] = pd.to_numeric(data['EMA'])/multipleCoeff
data['macd'] = pd.to_numeric(data['macd'])/multipleCoeff
data['macdsignal'] = pd.to_numeric(data['macdsignal'])/multipleCoeff
data['macdhist'] = pd.to_numeric(data['macdhist'])/multipleCoeff

data['SMA_green'] = pd.to_numeric(data['SMA_green'].shift(periods=SMA_Green_Offset))/multipleCoeff
data['SMA_red'] = pd.to_numeric(data['SMA_red'].shift(periods=SMA_Red_Offset))/multipleCoeff
data['SMA_blue'] = pd.to_numeric(data['SMA_blue'].shift(periods=SMA_Blue_Offset))/multipleCoeff

data['EMA_green'] = pd.to_numeric(data['EMA_green'].shift(periods=EMA_Green_Offset))/multipleCoeff
data['EMA_red'] = pd.to_numeric(data['EMA_red'].shift(periods=EMA_Red_Offset))/multipleCoeff
data['EMA_blue'] = pd.to_numeric(data['EMA_blue'].shift(periods=EMA_Blue_Offset))/multipleCoeff

data['TEMA'] = pd.to_numeric(data['TEMA'])/multipleCoeff

data['Fractal_UP'] = pd.to_numeric(data['Fractal_UP'])/multipleCoeff
data['Fractal_Down'] = pd.to_numeric(data['Fractal_Down'])/multipleCoeff

#=====================================================
# JSON
#=====================================================

jsonstring = data.to_json(orient='records')
print(jsonstring)

Вызвать скрипт можно из PHP, вот скрипт:

<?php	

  //Получаем переменные из URL запроса
  if (isset($_GET['symbol']) and isset($_GET['interval'])) {
    $symbol   = htmlspecialchars($_GET["symbol"]);
    $interval   = htmlspecialchars($_GET["interval"]);
  }
  else {
    err();
  }        

  echo exec("python3 /home/admin/web/domain-name.ru/public_html/panel/98hlkjg987gtkbjbIUYG98iub/python_api/5_indicators.py ".$symbol." ".$interval);
                                                                                                                                                     
?>

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

Привет!

Эта статья является кратким справочником по различным инструментам обработки данных, построения 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 для исследователей данных и разработчиков программного обеспечения

1. В чем разница между списком и кортежем?

Этот вопрос звучит очень часто на каждом интервью по Python / Data Science. Обязательно запомните правильный ответ.

• Списки изменчивы. Они могут быть изменены после создания.
• Кортежи неизменны. Как только кортеж создан, он не может быть изменен.
• Списки имеют порядок. Они представляют собой упорядоченную последовательность объектов одного типа. Т.е.: все имена пользователей упорядочены по дате создания,["Seth", "Ema", "Eli"]
• Кортежи имеют структуру. Различные типы данных могут существовать в каждом индексе. Т.е.: запись базы данных в памяти (2, "Ema", "2020–04–16") # id, name, created_at

2. Как выполняется интерполяция строк (string interpolation)?

Без импорта Template класса есть 3 способа интерполировать строки.

name = 'Chris'

# 1. f strings
print(f'Hello {name}')

# 2. % operator
print('Hey %s %s' % (name, name))

# 3. format
print(
 "My name is {}".format((name))
)

3. В чем разница между «is» и «==»?

Запись is проверяет идентичность, а запись == проверяет равенство.

Рассмотрим пример. Создайте несколько списков и присвойте им имена. Обратите внимание, что b указывает на тот же объект, что и a ниже.

a = [1,2,3] 
b = a 
c = [1,2,3]

Проверьте равенство и отметьте, что все они равны.

print (a == b) 
print (a == c) 
# => True 
# => True

Но они имеют одинаковую идентичность? Нет.

print (a is b) 
print (a is c) 
# => True 
# => False

Мы можем проверить это, напечатав их идентификаторы объектов.

print(id(a))
print(id(b))
print(id(c))
#=> 4369567560
#=> 4369567560
#=> 4369567624

c has a different id than a and b.

4. Что такое декоратор (decorator)?

Декоратор позволяет добавить функциональность к существующей функции, передав эту существующую функцию декоратору, который выполнит её и дополнительный код. Как бы это надстройка над существующей функцией.

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

Напишите функцию декоратора. Декоратор принимает функцию func, в качестве аргумента. Он также определяет функцию log_function_called, которая вызывает func()и выполняет некоторый код print(f'{func} called.'). Затем он возвращает функцию, которую он определил.

def logging(func):
  def log_function_called():
    print(f'{func} called.')
    func()
  return log_function_called

Давайте напишем другие функции, к которым мы затем добавим декоратор:

def my_name():
  print('chris')
def friends_name():
  print('naruto')

my_name()
friends_name()

#=> chris
#=> naruto

Теперь добавим декоратор к обоим функциям.

@logging
def my_name():
 print('chris')
@logging
def friends_name():
 print('naruto')

my_name()
friends_name()

#=> <function my_name at 0x10fca5a60> called.
#=> chris
#=> <function friends_name at 0x10fca5f28> called.
#=> naruto

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

5. Объясните, как работает функция диапазона (range function)

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

Функция принимает от 1 до 3 аргументов. Рассмотрим три случая — запись с одним, двумя и тремя аргументами.

range(stop): генерирует целые числа от 0 до целого числа «stop».

for i in range(10)
#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range(start, stop): генерирует целые числа от «start» до «stop».

for i in range(2,10)
#=> [2, 3, 4, 5, 6, 7, 8, 9]

range(start, stop, step): генерирует целые числа от «start» до «stop» с интервалами «step».

for i in range(2,10,2)
#=> [2, 4, 6, 8]

Во всех случаях stop (верхняя граница) не включается в список.

6. Определите класс с именем car и с 2 свойствами, «color» и «speed». Затем создайте экземпляр и верните свойство speed

class Car :
    def __init__(self, color, speed):
        self.color = color
        self.speed = speed

car = Car('red','100mph')
car.speed

#=> '100mph'

7. В чем разница между методом класса, методом экземпляра и статическим методом в Python?

Методы экземпляра: принимают параметр self и относятся к конкретному экземпляру класса.

Статические методы: используйте декоратор @staticmethod для методов, которые не связаны с конкретными экземплярами и являются автономными (не изменяют свойств класса или экземпляра).

Методы класса: принимают параметр cls и могут изменять сам класс.

Проиллюстрируем разницу вокруг вымышленного CoffeeShop класса.

class CoffeeShop:
    specialty = 'espresso'
    
    def __init__(self, coffee_price):
        self.coffee_price = coffee_price
    
    # instance method
    def make_coffee(self):
        print(f'Making {self.specialty} for ${self.coffee_price}')
    
    # static method    
    @staticmethod
    def check_weather():
        print('Its sunny')

    # class method
    @classmethod
    def change_specialty(cls, specialty):
        cls.specialty = specialty
        print(f'Specialty changed to {specialty}')

CoffeeShop У класса есть свойство specialty, установленное значение по умолчанию 'espresso'. Каждый экземпляр CoffeeShop инициализируется со свойством coffee_price. Он также имеет 3 метода: метод экземпляра, статический метод и метод класса.

Давайте инициализируем экземпляр кофейни с coffee_price = 5. Затем вызовем метод экземпляра make_coffee.

coffee_shop = CoffeeShop('5')
coffee_shop.make_coffee()
#=> Making espresso for $5

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

coffee_shop.check_weather()
#=> Its sunny

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

coffee_shop.change_specialty('drip coffee')
#=> Specialty changed to drip coffee

coffee_shop.make_coffee()
#=> Making drip coffee for $5

Обратите внимание, как метод make_coffee раньше изготавливал espresso, но теперь делает drip coffee!

8. В чем разница между «func» и «func()»?

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

def func():
    print('Im a function')
    
func
#=> function __main__.func>

func()    
#=> Im a function

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

9. Объясните, как работает функция map()

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

def add_three(x):
    return x + 3
li = [1,2,3]
list_data = [i for i in map(add_three, li)]
print(list_data)
# [4, 5, 6]

10. Объясните, как работает функция reduce()

Эту функцию довольно сложно сразу понять, пока вы не используете её несколько раз.

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

from functools import reduce

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

li = [1,2,3,5]

reduce(add_three, li)
#=> 11

Возвращается значение 11, которое является суммой 1+2+3+5.

11. Объясните, как работает функция фильтра filter()

Функция filter() буквально делает то, о чем говорится в её названии: Фильтрует элементы в последовательности/списке.

Каждый элемент передается функции, которая возвращается в выведенной последовательности, если функция возвращается, True и отбрасывается, если функция возвращается False.

def add_three(x):
    if x % 2 == 0:
        return True        
    else:
        return False

li = [1,2,3,4,5,6,7,8]
new_listdata = [i for i in filter(add_three, li)]
print(new_listdata)
#=> [2, 4, 6, 8]

Обратите внимание, что все элементы, не делимые на 2, были удалены.

12. Питон вызывает по ссылке или по значению?

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

name = 'chr'
def add_chars(s):
    s += 'is'
    print(s)
    
add_chars(name)    
print(name)
#=> chris
#=> chr

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

li = [1,2]
def add_element(seq):
    seq.append(3)
    print(seq)
    
add_element(li)    
print(li)
#=> [1, 2, 3]
#=> [1, 2, 3]

13. Как перевернуть список?

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

li = ['a','b','c']
print(li)
li.reverse()
print(li)
#=> ['a', 'b', 'c']
#=> ['c', 'b', 'a']

14. Как работает умножение строк?

Давайте посмотрим результаты умножения строки 'cat' на 3.

'cat' * 3
#=> 'catcatcat'

Строка соединяется сама с собой 3 раза.

15. Как работает умножение списков?

Давайте посмотрим результат умножения списка [1,2,3] на 2.

[1,2,3] * 2 
# => [1, 2, 3, 1, 2, 3]

Выводится список, содержащий задвоенное содержимое [1,2,3].

16. Что означает «self» в классе?

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

Ниже передача self для __init__() дает возможность установить color для экземпляра при инициализации.

class Shirt:
    def __init__(self, color):
        self.color = color
        
s = Shirt('yellow')
s.color
#=> 'yellow'

17. Как объединить списки в Python?

Сумма 2х списков объединяет их:

a = [1,2]
b = [3,4,5]
c = a + b
print(c)
print(a + b)
#=> [1, 2, 3, 4, 5]
#=> [1, 2, 3, 4, 5]

18. В чем разница между мелкой и глубокой копией (shallow copy vs. deep copy)?

Мы обсудим это в контексте изменяемого объекта — списка. Для неизменных объектов, shallow copy против deep copy не столь актуально.

Мы пройдемся по 3-м сценариям.

1) Ссылка на оригинальный объект. Она указывает на новое имя, li2 указывает на то же место в памяти, на которое указывает li1. Таким образом, любое изменение, которое мы делаем в li1 также происходит в li2.

li1 = [['a'],['b'],['c']]
li2 = li1
li1.append(['d'])
print(li2)
#=> [['a'], ['b'], ['c'], ['d']]

2) Создать shallow copy оригинала. Мы можем сделать это с помощью list() конструктора или более питонического mylist.copy().
shallow copy создает новый объект, но заполняет его ссылками на оригинал. Таким образом, добавление нового объекта в исходную коллекцию li3 не распространяется на li4, а изменение одного из объектов li3 будет распространяться на li4.

li3 = [['a'],['b'],['c']]
li4 = list(li3)
li3.append([4])
print(li4)
#=> [['a'], ['b'], ['c']]
li3[0][0] = ['X']
print(li4)
#=> [[['X']], ['b'], ['c']]

3) Создать deep copy. Это сделано с copy.deepcopy(). 2 объекта теперь полностью независимы, и изменения одного из них не влияют на другой список.

import copy
li5 = [['a'],['b'],['c']]
li6 = copy.deepcopy(li5)
li5.append([4])
li5[0][0] = ['X']
print(li6)
#=> [['a'], ['b'], ['c']]

19. В чем разница между списками и массивами?

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

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

20. Как объединить два массива Numpy?

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

import numpy as np

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

np.concatenate((a,b))

#=> array([1, 2, 3, 4, 5, 6])

21. Назовите изменяемые и неизменяемые объекты в Python

Неизменяемые объекты — означает, что состояние не может быть изменено после создания. Примеры: int, float, bool, string и tuple.

Изменяемый объект — означает, что состояние может быть изменено после создания. Примерами являются list, dict и set.

22. Как округлить число до 3 десятичных знаков в Python?

Используйте функцию round(value, decimal_places).

a = 5.12345
round(a,3)
#=> 5.123

23. Как вывести кусок списка — slice a list?

Синтаксис slice следующий, необходимо list передать 3 аргумента, list[start:stop:step], где step (шаг) — это интервал, через который возвращаются элементы.

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

print(a[8:])
#=> [8, 9]

print(a[2:8])
#=> [2, 3, 4, 5, 6, 7]

print(a[2:8:2])
#=> [2, 4, 6]

24. Что такое pickling (маринование)?

Pickling — это метод сериализации и десериализации объектов в Python.

В приведенном ниже примере мы сериализуем и десериализуем список словарей.

import pickle
obj = [
    {'id':1, 'name':'Stuffy'},
    {'id':2, 'name': 'Fluffy'}
]
with open('file.p', 'wb') as f:
    pickle.dump(obj, f)
with open('file.p', 'rb') as f:
    loaded_obj = pickle.load(f)
print(loaded_obj)
#=> [{'id': 1, 'name': 'Stuffy'}, {'id': 2, 'name': 'Fluffy'}]

25. В чем разница между словарями (dictionaries) и JSON?

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

JSON — это просто строка, которая следует заданному формату и предназначена для передачи данных.

26. Какие ORM вы использовали в Python?

ORM (объектно-реляционное отображение или object relational mapping) отображают модели данных (обычно в приложении) в таблицы базы данных и упрощают транзакции базы данных.

SQLAlchemy обычно используется для фреймворка Flask, а Django имеет собственный ORM.

27. Как работает any() и all()?

Any() принимает последовательность и возвращает true, если какой-либо элемент в последовательности равен true.
All() возвращает истину, только если все элементы в последовательности истинны.

a = [False, False, False]
b = [True, False, False]
c = [True, True, True]

print( any(a) )
print( any(b) )
print( any(c) )
#=> False
#=> True
#=> True

print( all(a) )
print( all(b) )
print( all(c) )
#=> False
#=> False
#=> True

28. Что быстрее для поиска элемента — словарь или список в Python?

Поиск значения в списке занимает O(n) времени, потому что весь список необходимо перебирать до тех пор, пока значение не будет найдено.

Поиск ключа в словаре занимает O(1) времени, потому что это хеш-таблица.

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

29. В чем разница между модулем и пакетом?

Модуль — это файл (или набор файлов), который можно импортировать вместе.

import sklearn

Пакет — это каталог модулей.

from sklearn import cross_validation

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

30. Как увеличить и уменьшить целое число в Python?

Увеличение и уменьшение может быть сделано с += и -=.

value = 5

value += 1
print(value)
#=> 6

value -= 1
value -= 1
print(value)
#=> 4

31. Как преобразовать целое число в двоичное?

Используйте bin() функцию.

bin(5)
#=> '0b101'

32. Как удалить дубликаты элементов из списка?

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

a = [1,1,1,2,3]
a = list(set(a))
print(a)

#=> [1, 2, 3]

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

33. Как проверить, существует ли значение в списке?

Использование in.

'a' in ['a','b','c']
#=> True

'a' in [1,2,3]
#=> False

34. В чем разница между дополнением и расширением?

append добавляет значение в список, а extend добавляет в список значения из другого списка.

a = [1,2,3]
b = [1,2,3]
a.append(6)
print(a)
#=> [1, 2, 3, 6]

b.extend([4,5])
print(b)
#=> [1, 2, 3, 4, 5]

35. Как получить абсолютное значение (модуль) целого числа?

Это можно сделать с помощью abs() функции.

abs(2)
#=> 2

abs(-2)
#=> 2

36. Как объединить два списка (2 lists) в список кортежей (list of tuples)?

Вы можете использовать zip() функцию для объединения списков в список кортежей. Функция zip() не ограничена для объединения только 2 списков. zip() также можно вызвать с 3 или большим числом списков.

a = ['a','b','c']
b = [1,2,3]
[(k,v) for k,v in zip(a,b)]
#=> [('a', 1), ('b', 2), ('c', 3)]

37. Как отсортировать словарь по ключу в алфавитном порядке?

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

d = {'c':3, 'd':4, 'b':2, 'a':1}
sorted(d.items())
#=> [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

38. Как класс наследуется от другого класса в Python?

В приведенном ниже примере Audi наследуется от Car. И с этим наследованием приходят методы экземпляра родительского класса (т.е. из класса Car в класс Audi).

class Car():
    def drive(self):
        print('vroom')

class Audi(Car):
    pass

audi = Audi()
audi.drive()

39. Как можно удалить все пробелы из строки?

Применяем функцию replace

s = 'A string with     white space'
s.replace(' ', '')
#=> 'Astringwithwhitespace'

40. Почему следует использовать enumerate() для выполнения итерации последовательности?

Функция enumerate() позволяет отслеживать индекс при итерации по последовательности. Это более pythonic, чем определение и увеличение целого числа, представляющего индекс.

li = ['a','b','c','d','e']

for idx,val in enumerate(li):
    print(idx, val)

#=> 0 a
#=> 1 b
#=> 2 c
#=> 3 d
#=> 4 e

41. В чем разница между pass, continue и break?

pass — значит ничего не делать. Обычно его используют, потому что Python не позволяет создавать класс, функцию или оператор if без кода внутри.
В приведенном ниже примере будет выдана ошибка без кода внутри i > 3, поэтому следует использовать pass.

a = [1,2,3,4,5]
for i in a:
    if i > 3:
        pass
    print(i)
#=> 1
#=> 2
#=> 3
#=> 4
#=> 5

continue — переводит цикл на следующий элемент и останавливает выполнение цикла для текущего элемента. Так print(i) никогда не выполнится для значений, где i < 3.

for i in a:
    if i < 3:
        continue
    print(i)
#=> 3
#=> 4
#=> 5

break — прекращает цикл и последовательность больше не повторяется. Таким образом, элементы i со значения 3 не выводятся.

for i in a:
    if i == 3:
        break
    print(i)    
#=> 1
#=> 2

42. Как перевести цикл (loop) в запись одной строки для списка (list)?

Рассмотрим цикл for (for loop) — Как было до

a = [1,2,3,4,5]
 
a2 = []
for i in a:
     a2.append(i + 1)
print(a2)
#=> [2, 3, 4, 5, 6]

Как можно преобразовать — Как стало после

a3 = [i+1 for i in a]
print(a3)
#=> [2, 3, 4, 5, 6]

Понимание списка обычно считается более pythonic, когда оно все еще читаемо.

43. Приведите пример троичного оператора (ternary operator)

Тернарный оператор (ternary operator) — это однострочный оператор if / else.
Синтаксис выглядит так ‘a if condition else b’.

x = 5
y = 10

'greater' if x > 6 else 'less'
#=> 'less'

'greater' if y > 6 else 'less'
#=> 'greater'

44. ​​Как проверить, что строка содержит только цифры?

Для этих целей Вы можете использовать функцию isnumeric()

'123a'.isnumeric()
#=> False

'123'.isnumeric()
#=> True

45. Как проверить, что строка содержит только буквы

Для этих целей Вы можете использовать функцию isalpha().

'123a'.isalpha()
#=> False

'a'.isalpha()
#=> True

46. Как проверить, что строка содержит только цифры и буквы

Для этих целей Вы можете использовать функцию isalnum().

'123abc...'.isalnum()
#=> False

'123abc'.isalnum()
#=> True

47. Как вернуть список ключей из словаря

Это может быть сделано путем передачи словарю питона list() конструктора list()

d = {'id':7, 'name':'Shiba', 'color':'brown', 'speed':'very slow'}

list(d)
#=> ['id', 'name', 'color', 'speed']

48. Как строку преобразовать в верхний и нижний регистр?

Вы можете использовать строковые методы upper() и lower() для преобразования регистра

small_word = 'potatocake'
big_word = 'FISHCAKE'

small_word.upper()
#=> 'POTATOCAKE'

big_word.lower()
#=> 'fishcake'

49. В чем разница между remove, del и pop?

remove() удаляет первое совпадающее значение

li = ['a','b','c','d']
li.remove('b')
li
#=> ['a', 'c', 'd']

del() удаляет элемент по индексу

li = ['a','b','c','d']
del li[0]
li
#=> ['b', 'c', 'd']

pop() удаляет элемент по индексу и возвращает этот элемент.

li = ['a','b','c','d']
li.pop(2)
#=> 'c'
li
#=> ['a', 'b', 'd']

50. Приведите пример словарного понимания (dictionary comprehension)

Ниже мы создадим словарь с буквами алфавита в качестве ключей и индекс в алфавите в качестве значений.

# creating a list of letters
import string
list(string.ascii_lowercase)
alphabet = list(string.ascii_lowercase)
# list comprehension
d = {val:idx for idx,val in enumerate(alphabet)} 
d
#=> {'a': 0,
#=>  'b': 1,
#=>  'c': 2,
#=> ...
#=>  'x': 23,
#=>  'y': 24,
#=>  'z': 25}

51. Как выполняется обработка исключений в Python?

Python предоставляет 3 слова для обработки исключений try, except и finally.
Синтаксис выглядит следующим образом.

try:
    # try to do this
except:
    # if try block fails then do this
finally:
    # always do this

В следующем примере блок try завершается ошибкой, потому что мы не можем складывать целые числа со строками. В except блоке val = 10 и затем finally блок печатает complete.

try:
    val = 1 + 'A'
except:
    val = 10
finally:
    print('complete')
    
print(val)
#=> complete
#=> 10

Сообщение 51 Python Interview вопрос/ответ на собеседовании для Data Scientist появились сначала на 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 - Искусственный Интеллект.