Создание интерактивных точечных диаграмм с Plotly: обзор Scatter

import plotly.express as px
import pandas as pd

# Создание тестовых данных
df = pd.DataFrame({
'x': [1, 2, 3, 4, 5],
'y': [10, 11, 12, 13, 14],
'size': [30, 40, 50, 60, 70],
'category': ['A', 'B', 'A', 'B', 'A']
})

# Создание точечной диаграммы
fig = px.scatter(df, x='x', y='y', size='size', color='category',
title='Базовая интерактивная точечная диаграмма')
fig.show()

import plotly.graph_objects as go

# Создание точечной диаграммы с использованием Graph Objects
fig = go.Figure(
data=go.Scatter(
x=df['x'],
y=df['y'],
mode='markers',
marker=dict(
size=df['size'],
color=['red' if cat == 'A' else 'blue' for cat in df['category']]
),
text=df['category'], # Текст для всплывающих подсказок
hoverinfo='x+y+text' # Формат всплывающей подсказки
)
)

# Настройка макета
fig.update_layout(
title='Точечная диаграмма с использованием Graph Objects',
xaxis_title='X Ось',
yaxis_title='Y Ось'
)

fig.show()

import plotly.graph_objects as go

fig = go.Figure(go.Scatter(
x=[1, 2, 3, 4, 5],
y=[10, 11, 12, 13, 14],
mode='markers',
marker=dict(
size=15, # размер маркера
color='rgba(255,0,0,0.5)', # цвет с прозрачностью
line=dict(
color='darkred', # цвет обводки
width=2 # толщина обводки
),
symbol='circle', # форма маркера
opacity=0.8, # прозрачность
gradient=dict(
type='radial', # тип градиента
color='lightblue' # цвет градиента
)
)
))

fig.show()

import numpy as np

# Генерация случайных данных
np.random.seed(42)
random_x = np.random.randint(1, 100, 100)
random_y = np.random.randint(1, 100, 100)
size = np.random.randint(5, 30, 100)
colors = np.random.randint(0, 10, 100)

fig = go.Figure(go.Scatter(
x=random_x,
y=random_y,
mode='markers',
marker=dict(
size=size,
color=colors,
colorscale='Viridis', # выбор цветовой схемы
showscale=True # показывать цветовую шкалу
),
text=[f'ID: {i}' for i in range(100)], # текст для всплывающих подсказок
hoverinfo='text+x+y' # формат всплывающих подсказок
))

# Настройка макета
fig.update_layout(
title='Расширенная настройка маркеров',
xaxis_title='Ось X',
yaxis_title='Ось Y',
hovermode='closest', # режим всплывающих подсказок
template='plotly_dark' # тема оформления
)

fig.show()

fig = go.Figure(go.Scatter(
x=random_x,
y=random_y,
mode='markers',
marker=dict(size=size, color=colors),
customdata=np.column_stack((np.arange(100), np.random.randint(1000, 10000, 100))), # дополнительные данные
hovertemplate='<b>Точка ID:</b> %{customdata[0]}<br>' +
'<b>X:</b> %{x}<br>' +
'<b>Y:</b> %{y}<br>' +
'<b>Значение:</b> %{customdata[1]}<extra></extra>' # настраиваемый формат всплывающей подсказки
))

fig.show()

import plotly.express as px
import pandas as pd
import numpy as np

# Создание данных
n_frames = 20
n_points = 50
data = []

for frame in range(n_frames):
x = np.random.normal(loc=frame/5, scale=1, size=n_points)
y = np.random.normal(loc=frame/10, scale=1, size=n_points)
size = np.random.randint(5, 15, size=n_points)
category = np.random.choice(['Group A', 'Group B', 'Group C'], size=n_points)

for i in range(n_points):
data.append({
'frame': frame,
'x': x[i],
'y': y[i],
'size': size[i],
'category': category[i]
})

df = pd.DataFrame(data)

# Создание анимированной диаграммы
fig = px.scatter(
df, x='x', y='y', 
animation_frame='frame', 
animation_group='category',
size='size', 
color='category',
range_x=[-5, 10], 
range_y=[-3, 5],
title='Анимированная точечная диаграмма'
)

fig.update_layout(
updatemenus=[{
'type': 'buttons',
'showactive': False,
'buttons': [{
'label': 'Воспроизвести',
'method': 'animate',
'args': [None, {'frame': {'duration': 500, 'redraw': True}, 'fromcurrent': True}]
}]
}]
)

fig.show()

import plotly.graph_objects as go

# Создание данных
x = [1, 2, 3, 4, 5]
y1 = [10, 20, 30, 40, 50] # Первая переменная
y2 = [500, 400, 300, 200, 100] # Вторая переменная с другим диапазоном

# Создание графика с двумя осями Y
fig = go.Figure()

# Первый набор данных на первой оси Y
fig.add_trace(go.Scatter(
x=x,
y=y1,
name='Метрика 1',
line=dict(color='blue', width=2)
))

# Второй набор данных на второй оси Y
fig.add_trace(go.Scatter(
x=x,
y=y2,
name='Метрика 2',
yaxis='y2', # Привязка к второй оси Y
line=dict(color='red', width=2, dash='dash')
))

# Настройка макета с двумя осями Y
fig.update_layout(
title='График с двумя осями Y',
xaxis_title='Дни',
yaxis=dict(
title='Метрика 1',
titlefont=dict(color='blue'),
tickfont=dict(color='blue')
),
yaxis2=dict(
title='Метрика 2',
titlefont=dict(color='red'),
tickfont=dict(color='red'),
anchor='x',
overlaying='y',
side='right'
),
legend=dict(x=0.02, y=0.95)
)

fig.show()

from plotly.subplots import make_subplots
import plotly.graph_objects as go
import numpy as np

# Создание сетки субграфиков 2x2
fig = make_subplots(
rows=2, cols=2,
subplot_titles=('Квартал 1', 'Квартал 2', 'Квартал 3', 'Квартал 4'),
shared_xaxes=True,
shared_yaxes=True,
vertical_spacing=0.1
)

# Добавление точечных диаграмм на каждый субграфик
for i, quarter in enumerate([1, 2, 3, 4]):
row = i // 2 + 1
col = i % 2 + 1

# Генерация данных для квартала
np.random.seed(42 * quarter)
x = np.random.normal(loc=quarter, scale=1, size=50)
y = np.random.normal(loc=quarter*2, scale=2, size=50)

# Добавление точечной диаграммы
fig.add_trace(
go.Scatter(
x=x, 
y=y, 
mode='markers',
marker=dict(
color=np.random.randint(0, 255, size=50),
colorscale='Viridis',
showscale=True if i == 0 else False, # Показывать цветовую шкалу только для первого графика
size=10
),
name=f'Q{quarter}'
),
row=row, col=col
)

# Обновление макета
fig.update_layout(
height=800,
title_text='Сравнение данных по кварталам',
showlegend=False
)

fig.show()

from dash import Dash, dcc, html, Input, Output
import plotly.express as px
import pandas as pd
import numpy as np

# Создание тестовых данных
np.random.seed(42)
n_points = 100
df = pd.DataFrame({
'x': np.random.normal(0, 1, n_points),
'y': np.random.normal(0, 1, n_points),
'size': np.random.uniform(5, 20, n_points),
'category': np.random.choice(['A', 'B', 'C'], n_points),
'value': np.random.uniform(0, 1, n_points)
})

# Инициализация приложения Dash
app = Dash(__name__)

# Определение структуры приложения
app.layout = html.Div([
html.H1("Интерактивная точечная диаграмма с фильтрацией"),

html.Div([
html.Label("Выберите категорию:"),
dcc.Dropdown(
id='category-filter',
options=[{'label': cat, 'value': cat} for cat in df['category'].unique()],
value=df['category'].unique().tolist(), # По умолчанию выбраны все категории
multi=True
)
], style={'width': '30%', 'margin': '10px'}),

dcc.Graph(id='scatter-plot')
])

# Определение обратной связи для обновления диаграммы
@app.callback(
Output('scatter-plot', 'figure'),
[Input('category-filter', 'value')]
)
def update_graph(selected_categories):
filtered_df = df[df['category'].isin(selected_categories)]

fig = px.scatter(
filtered_df,
x='x',
y='y',
color='category',
size='size',
hover_data=['value'],
title='Фильтрованная точечная диаграмма'
)

return fig

# Запуск приложения
if __name__ == '__main__':
app.run_server(debug=True)

import plotly.graph_objects as go
import numpy as np
from sklearn.cluster import KMeans
import pandas as pd

# Генерация большого набора данных (100,000 точек)
np.random.seed(42)
n_points = 100000
raw_data = pd.DataFrame({
'x': np.random.normal(0, 1, n_points),
'y': np.random.normal(0, 1, n_points),
'category': np.random.choice(['A', 'B', 'C'], n_points)
})

# Метод 1: Прореживание данных (downsampling)
# Выбираем случайную выборку из 5000 точек
sampled_df = raw_data.sample(5000, random_state=42)

# Метод 2: Агрегация через кластеризацию
# Группируем близкие точки, используя K-means
def cluster_points(df, n_clusters=500):
# Применяем KMeans только к числовым столбцам
numeric_data = df[['x', 'y']]
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
df['cluster'] = kmeans.fit_predict(numeric_data)

# Агрегируем данные по кластерам
cluster_centers = kmeans.cluster_centers_

# Подсчитываем количество точек в каждом кластере
cluster_sizes = df.groupby('cluster').size().reset_index(name='count')

# Создаем DataFrame с центрами кластеров и их размерами
clustered_df = pd.DataFrame({
'x': cluster_centers[:, 0],
'y': cluster_centers[:, 1],
'size': cluster_sizes['count'],
# Определяем доминирующую категорию в каждом кластере
'category': [df[df['cluster'] == i]['category'].mode()[0] for i in range(n_clusters)]
})

return clustered_df

clustered_df = cluster_points(raw_data)

# Создаем оптимизированную диаграмму с кластеризованными данными
fig = go.Figure()

for category, color in zip(['A', 'B', 'C'], ['blue', 'red', 'green']):
category_data = clustered_df[clustered_df['category'] == category]

fig.add_trace(go.Scatter(
x=category_data['x'],
y=category_data['y'],
mode='markers',
marker=dict(
size=category_data['size'] / clustered_df['size'].max() * 20 + 5, # Нормализуем размер
color=color,
opacity=0.7,
line=dict(width=1, color='white')
),
name=f'Категория {category}',
hovertemplate='x: %{x:.2f}<br>y: %{y:.2f}<br>Количество точек: %{marker.size}<extra></extra>'
))

fig.update_layout(
title='Оптимизированная точечная диаграмма (кластеризованные данные)',
xaxis_title='X',
yaxis_title='Y',
legend_title='Категории',
hovermode='closest'
)

# Дополнительные оптимизации производительности
fig.update_layout(
uirevision='constant', # Сохраняет состояние UI между обновлениями
autosize=True,
margin=dict(l=20, r=20, t=40, b=20)
)

fig = go.Figure()

# Добавляем данные
fig.add_trace(go.Scatter(
x=[1, 2, 3, 4, 5],
y=[10, 11, 12, 13, 14],
mode='markers',
marker=dict(size=12, color='blue')
))

# Настройки для адаптивности
fig.update_layout(
# Автоматическая адаптация размера
autosize=True,
# Минимальная высота для мобильных устройств
height=350,
# Уменьшение отступов
margin=dict(l=10, r=10, b=30, t=30, pad=0),
# Настройки легенды для мобильных устройств
legend=dict(
orientation="h", # Горизонтальная легенда
yanchor="bottom",
y=1.02,
xanchor="right",
x=1
)
)

# Оптимизация элементов управления для сенсорных экранов
fig.update_layout(
# Увеличение размера кнопок для сенсорных экранов
updatemenus=[dict(
buttons=[
dict(
label="Сбросить масштаб",
method="relayout",
args=[{"xaxis.range": None, "yaxis.range": None}]
)
],
direction="down",
pad={"r": 10, "t": 10},
showactive=False,
x=0.1,
y=1.15,
xanchor="left",
yanchor="top"
)]
)

# Настройка поведения оси для сенсорного взаимодействия
fig.update_xaxes(
fixedrange=False, # Разрешаем масштабирование по оси X
constrain="domain" # Ограничиваем область для предотвращения выхода за границы
)
fig.update_yaxes(
fixedrange=False, # Разрешаем масштабирование по оси Y
scaleanchor="x", # Сохраняем пропорции при масштабировании
scaleratio=1
)

# Пример с использованием Dash для асинхронной загрузки данных
from dash import Dash, dcc, html, Input, Output, callback_context
import plotly.graph_objects as go
import pandas as pd
import time
import random

app = Dash(__name__)

# Имитация получения данных из API
def fetch_data(n_points=100):
# Имитация задержки сетевого запроса
time.sleep(0.5)

# Генерация случайных данных
return pd.DataFrame({
'x': [random.normalvariate(0, 1) for _ in range(n_points)],
'y': [random.normalvariate(0, 1) for _ in range(n_points)],
'size': [random.uniform(5, 20) for _ in range(n_points)],
'timestamp': pd.Timestamp.now()
})

app.layout = html.Div([
html.H1("Асинхронное обновление точечной диаграммы"),

dcc.Loading(
id="loading-1",
type="default", # Тип анимации загрузки
children=html.Div(id="loading-output")
),

dcc.Graph(id="live-scatter-plot"),

dcc.Interval(
id='interval-component',
interval=5*1000, # Обновление каждые 5 секунд
n_intervals=0
),

html.Button('Обновить данные', id='update-button')
])

@app.callback(
Output("live-scatter-plot", "figure"),
Output("loading-output", "children"),
[Input('interval-component', 'n_intervals'),
Input('update-button', 'n_clicks')],
prevent_initial_call=False
)
def update_graph(n_intervals, n_clicks):
# Определяем, что вызвало обратный вызов
ctx = callback_context
trigger = ctx.triggered[0]['prop_id'].split('.')[0] if ctx.triggered else None

# Получаем новые данные
df = fetch_data(n_points=100 if trigger == 'update-button' else 50)

# Создаем фигуру
fig = go.Figure(go.Scatter(
x=df['x'],
y=df['y'],
mode='markers',
marker=dict(
size=df['size'],
color=df['x'],
colorscale='Viridis',
showscale=True
),
hovertemplate='x: %{x:.3f}<br>y: %{y:.3f}<extra></extra>'
))

# Обновляем макет
fig.update_layout(
title=f'Обновлено: {df["timestamp"][0].strftime("%H:%M:%S")}',
xaxis_title='X',
yaxis_title='Y',
autosize=True,
uirevision='constant' # Сохраняет состояние просмотра при обновлениях
)

return fig, f"Данные обновлены в {df['timestamp'][0].strftime('%H:%M:%S')}"

import plotly.express as px
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# Предположим, что у нас есть данные о клиентах
df = pd.DataFrame({
'Возраст': [25, 45, 32, 60, 37, 28, 55, 33, 42, 58, 27, 40],
'Доход': [30000, 60000, 45000, 70000, 52000, 35000, 65000, 48000, 56000, 72000, 32000, 50000],
'Частота_покупок': [5, 8, 12, 3, 10, 7, 4, 15, 9, 2, 8, 6],
'Средний_чек': [1500, 3000, 1800, 4500, 2200, 1600, 3800, 1700, 2500, 5000, 1400, 2800],
'Сегмент': ['Молодежь', 'Средний', 'Активный', 'Премиум', 'Средний', 'Молодежь',
'Премиум', 'Активный', 'Средний', 'Премиум', 'Молодежь', 'Средний']
})

# Нормализация данных для PCA
features = ['Возраст', 'Доход', 'Частота_покупок', 'Средний_чек']
scaler = StandardScaler()
scaled_features = scaler.fit_transform(df[features])

# Применение PCA для уменьшения размерности до 2D
pca = PCA(n_components=2)
pca_result = pca.fit_transform(scaled_features)

# Добавление результатов PCA к исходным данным
df['PCA1'] = pca_result[:, 0]
df['PCA2'] = pca_result[:, 1]

# Создание интерактивной точечной диаграммы с сегментацией
fig = px.scatter(
df, x='PCA1', y='PCA2',
color='Сегмент',
size='Средний_чек',
hover_data=features,
title='Сегментация клиентов (PCA)',
labels={
'PCA1': 'Главный компонент 1',
'PCA2': 'Главный компонент 2'
}
)

# Добавление векторов признаков (biplot)
for i, feature in enumerate(features):
fig.add_shape(
type='line',
x0=0, y0=0,
x1=pca.components_[0, i] * 3, # Масштабирование для видимости
y1=pca.components_[1, i] * 3,
line=dict(color='red', width=1, dash='dash'),
)
fig.add_annotation(
x=pca.components_[0, i] * 3.2,
y=pca.components_[1, i] * 3.2,
text=feature,
showarrow=False,
font=dict(color='red')
)

fig.update_layout(
height=700,
legend_title='Сегмент клиента',
)

import plotly.express as px
from sklearn.datasets import load_boston
import pandas as pd
import numpy as np

# Загружаем данные о ценах на жильё в Бостоне
boston = load_boston()
df = pd.DataFrame(boston.data, columns=boston.feature_names)
df['PRICE'] = boston.target

# Вычисляем корреляционную матрицу
correlation_matrix = df.corr()

# Создаём матрицу точечных диаграмм
fig = px.scatter_matrix(
df,
dimensions=df.columns.tolist(),
color='PRICE',
color_continuous_scale=px.colors.sequential.Viridis,
title='Матрица точечных диаграмм для анализа корреляций',
labels={col: col.replace('_', ' ') for col in df.columns},
opacity=0.7
)

# Настройка дополнительных параметров
fig.update_layout(
height=1000,
width=1000,
coloraxis_colorbar=dict(title='Цена'),
autosize=True
)

# Другой вариант: создание интерактивной тепловой карты корреляций
fig_heatmap = px.imshow(
correlation_matrix,
text_auto='.2f',
color_continuous_scale='RdBu_r',
aspect="auto",
title='Тепловая карта корреляций'
)

import plotly.graph_objects as go
import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest

# Генерация временного ряда с аномалиями
np.random.seed(42)
dates = pd.date_range(start='2024-01-01', periods=100, freq='D')
values = np.sin(np.linspace(0, 10, 100)) * 10 + np.random.normal(0, 1, 100)

# Добавляем искусственные аномалии
anomaly_indices = [10, 35, 65, 80]
for idx in anomaly_indices:
values[idx] += np.random.choice([-15, 15])

# Создаём DataFrame
df = pd.DataFrame({
'date': dates,
'value': values
})

# Обнаружение аномалий с помощью Isolation Forest
model = IsolationForest(contamination=0.05)
df['anomaly'] = model.fit_predict(df[['value']])
df['anomaly'] = df['anomaly'].map({1: 'Normal', -1: 'Anomaly'})

# Создание интерактивной диаграммы для мониторинга
fig = go.Figure()

# Добавляем обычные точки
fig.add_trace(go.Scatter(
x=df[df['anomaly'] == 'Normal']['date'],
y=df[df['anomaly'] == 'Normal']['value'],
mode='lines+markers',
name='Нормальные данные',
marker=dict(color='blue', size=8),
line=dict(color='skyblue', width=2)
))

# Добавляем аномалии
fig.add_trace(go.Scatter(
x=df[df['anomaly'] == 'Anomaly']['date'],
y=df[df['anomaly'] == 'Anomaly']['value'],
mode='markers',
name='Аномалии',
marker=dict(color='red', size=12, symbol='circle-open', line=dict(width=2, color='red'))
))

# Настройка макета
fig.update_layout(
title='Мониторинг временного ряда с обнаружением аномалий',
xaxis_title='Дата',
yaxis_title='Значение',
hovermode='closest',
legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1)
)

# Добавляем вертикальные линии и аннотации для аномалий
for date, value in zip(
df[df['anomaly'] == 'Anomaly']['date'],
df[df['anomaly'] == 'Anomaly']['value']
):
fig.add_shape(
type='line',
x0=date, y0=min(df['value']) – 2,
x1=date, y1=value,
line=dict(color='red', width=1, dash='dot')
)
fig.add_annotation(
x=date, y=value+2,
text='Аномалия',
showarrow=True,
arrowhead=2,
arrowcolor='red',
arrowsize=1,
arrowwidth=1
)

import plotly.express as px
import pandas as pd
import numpy as np

# Создаём данные о локациях
np.random.seed(42)
n_stores = 50

df = pd.DataFrame({
'store_id': [f'S{i:03d}' for i in range(1, n_stores+1)],
'lat': np.random.uniform(55.5, 56.0, n_stores), # Широта (Московский регион)
'lon': np.random.uniform(37.4, 38.0, n_stores), # Долгота (Московский регион)
'revenue': np.random.lognormal(mean=12, sigma=1, size=n_stores),
'customers': np.random.randint(500, 5000, n_stores),
'category': np.random.choice(['Продукты', 'Одежда', 'Электроника', 'Рестораны'], n_stores)
})

# Создаём интерактивную карту
fig = px.scatter_mapbox(
df,
lat='lat',
lon='lon',
color='category',
size='revenue',
hover_name='store_id',
hover_data=['customers', 'revenue'],
zoom=9,
mapbox_style='carto-positron', # или 'open-street-map'
title='Распределение магазинов по Москве и окрестностям',
color_discrete_sequence=px.colors.qualitative.Bold
)

# Настройка макета
fig.update_layout(
height=800,
legend_title='Категория магазина',
mapbox=dict(center=dict(lat=55.75, lon=37.6)), # Центр Москвы
margin=dict(l=0, r=0, t=40, b=0)
)