Python Data Visualization | Create A Stacked Bar Chart In Matplotlib

Stacked bar charts offer several benefits for visualizing data, including: Clear representation of part-to-whole relationships, Easy comparison of categories, Visualization of multiple data series, and Effective trend analysis. In this tutorial, we will learn how to put together a stacked bar graph using matplotlib in Python.

📑 Data File & Source Code Download: https://wp.me/payCAw-1m2 

Subscribe: https://www.youtube.com/@jiejenn/featured 

#matplotlib  #datavisualizations  #python 

Учебное пособие по визуализации данных Seaborn Python

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

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

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

Знакомство с набором данных

Чтобы попрактиковаться в построении морских линий, мы сначала загрузим набор данных с Kaggle под названием Daily Exchange Rates Per Euro 1999-2023 . Далее мы импортируем все необходимые пакеты, прочитаем и очистим фрейм данных. Не вдаваясь в подробности процесса очистки, приведенный ниже код демонстрирует шаги, которые необходимо выполнить:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv('euro-daily-hist_1999_2022.csv')
df = df.iloc[:, [0, 1, 4, -2]]
df.columns = ['Date', 'Australian dollar', 'Canadian dollar', 'US dollar']
df = pd.melt(df, id_vars='Date', value_vars=['Australian dollar', 'Canadian dollar', 'US dollar'], value_name='Euro rate', var_name='Currency')
df['Date'] = pd.to_datetime(df['Date'])
df = df[df['Date']>='2022-12-01'].reset_index(drop=True)
df['Euro rate'] = pd.to_numeric(df['Euro rate'])
print(f'Currencies: {df.Currency.unique()}\n')
print(df.head())
print(f'\n{df.Date.dt.date.min()}/{ df.Date.dt.date.max()}')

Выход :

Currencies: ['Australian dollar' 'Canadian dollar' 'US dollar']

        Date           Currency  Euro rate
0 2023-01-27  Australian dollar     1.5289
1 2023-01-26  Australian dollar     1.5308
2 2023-01-25  Australian dollar     1.5360
3 2023-01-24  Australian dollar     1.5470
4 2023-01-23  Australian dollar     1.5529

2022-12-01/2023-01-27

Полученный кадр данных содержит ежедневные (рабочие дни) курсы евро для австралийского, канадского и доллара США за период с 01.12.2022 по 27.01.2023 включительно.

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

Основы построения линейных графиков Seaborn

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

В этом уроке мы в основном будем использовать функцию lineplot().

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

Создание единой морской линейной диаграммы

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

usd = df[df['Currency']=='US dollar'].reset_index(drop=True)
sns.lineplot(x='Date', y='Euro rate', data=usd)

Выход :

На графике выше показана динамика курса евро-доллар США. Мы определяем переменные для построения по осям x и y ( параметры x и y ) и кадр данных (данные), чтобы получить эти переменные.

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

sns.relplot(x='Date', y='Euro rate', data=usd, kind='line')

Выход :

В этом случае мы передаем функции replot() еще один конкретный аргумент: kind='line'. По умолчанию эта функция создает диаграмму рассеяния.

Настройка однолинейной морской карты

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

Регулировка размера фигуры

Поскольку Seaborn построен на основе matplotlib, мы можем использовать matplotlib.pyplot для настройки размера фигуры:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd)

Выход :

Вместо этого с помощью relplot() мы можем использовать параметры высоты и аспекта (отношение ширины к высоте) для той же цели:

sns.relplot(x='Date', y='Euro rate', data=usd, kind='line', height=6, aspect=4)

Выход :

Добавление заголовка оси и меток

Чтобы добавить заголовок графика и метки осей, мы можем использовать функцию set() для объекта графика морской линии, передавая аргументы title, xlabel и ylabel:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')

Выход :

Настройка размера шрифта

Удобный способ настроить размер шрифта — использовать функцию set_theme() и поэкспериментировать с различными значениями параметра font_scale:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

Обратите внимание, что мы также добавили style='white', чтобы избежать переопределения исходного стиля.

Изменение цвета, стиля и размера линии

Чтобы настроить линию графика, мы можем передать некоторые дополнительные параметры, общие с matplotlib.pyplot.plot, такие как цвет, стиль линии или ширина линии:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd, linestyle='dotted', color='magenta', linewidth=5).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

Добавление маркеров и настройка их цвета, стиля и размера

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd, marker='*', markerfacecolor='limegreen', markersize=20).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

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

В нашей шпаргалке по Seaborn вы найдете другие способы настройки линейной диаграммы в Seaborn.

Линейные диаграммы Seaborn с несколькими линиями

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

Создание морской линейной диаграммы с несколькими линиями

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

aud = df[df['Currency']=='Australian dollar'].reset_index(drop=True)
cad = df[df['Currency']=='Canadian dollar'].reset_index(drop=True)

sns.lineplot(x='Date', y='Euro rate', data=usd)
sns.lineplot(x='Date', y='Euro rate', data=aud)
sns.lineplot(x='Date', y='Euro rate', data=cad)

Выход :

Выше мы извлекаем еще два подмножества нашего исходного фрейма данных df — для австралийского и канадского долларов — и строим график каждого курса евро в зависимости от времени. Однако для этого есть более эффективные решения: используйте параметры hue, style или size, доступные в lineplot() и relplot().

Использование параметра оттенка

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

sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency')

Выход :

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

Использование параметра стиля

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

sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency')

Выход :

Использование параметра размера

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

sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency')

Выход :

Настройка морской линейной карты с несколькими линиями

Давайте теперь поэкспериментируем с эстетикой нашего графика. Некоторые методы здесь идентичны тем, которые мы применяли к одному линейному графику Seaborn. Другие относятся только к многолинейным графикам.

общие корректировки

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

Изменение цвета, стиля и размера каждой линии

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

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette=['magenta', 'deepskyblue', 'yellowgreen']).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

Также можно напрямую применить существующую палитру matplotlib:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette='spring').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

В то же время при использовании hue мы по-прежнему можем настроить стиль линии и ширину всех линий, передаваемых в аргументах linestyle и linewidth:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette=['magenta', 'deepskyblue', 'yellowgreen'], linestyle='dashed', linewidth=5).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', dashes=[[4, 4], [6, 1], [3, 9]]).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

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

Примечание: чтобы представить сплошную линию, нам нужно установить длину пробела равной нулю, например: [1, 0].

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', dashes=[[4, 4], [6, 1], [3, 9]], color='darkviolet', linewidth=4).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency', sizes=[2, 10, 5]).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency', sizes=[2, 10, 5], linestyle='dotted', color='teal').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

Добавление маркеров и настройка их цвета, стиля и размера

Мы можем захотеть добавить маркеры на нашу морскую многолинейную карту.

Чтобы добавить маркеры одного цвета, стиля и размера во все строки, нам нужно использовать параметры matplotlib, такие как marker, markerfacecolor, markersize и т. д., точно так же, как мы делали это для однолинейного графика:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', marker='o', markerfacecolor='orangered', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

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

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', markers=['o', 'X', '*'], markerfacecolor='brown', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

На приведенном выше рисунке мы можем сделать все линии сплошными, указав аргумент тире и установив шаблон стиля [1, 0] для каждой строки:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', markers=['o', 'X', '*'], dashes=[[1, 0], [1, 0], [1, 0]], markerfacecolor='brown', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Выход :

Заключение

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

В дальнейшем с Seaborn мы можем сделать гораздо больше, чтобы еще лучше настроить линейный график. Например, мы можем:

• Группировать строки по более чем одной категориальной переменной
• Персонализируйте легенду
• Создание линейных диаграмм с несколькими линиями на разных фасетах
• Просмотр и настройка доверительного интервала
• Настройка делений оси времени и их меток для линейной диаграммы временных рядов

Оригинальный источник статьи: https://www.datacamp.com

#python #datavisualizations 

Tutorial de visualização de dados do Python Seaborn

Neste tutorial Python, aprenderemos sobre Python Seaborn Line Plot Tutorial: Criar visualizações de dados. Descubra como usar Seaborn, uma popular biblioteca de visualização de dados em Python, para criar e personalizar gráficos de linha em Python.

Um gráfico de linha é uma visualização de dados relacionais que mostra como uma variável contínua muda quando outra muda. É um dos gráficos mais comuns amplamente utilizados em finanças, vendas, marketing, saúde, ciências naturais e muito mais.

Neste tutorial, discutiremos como usar Seaborn, uma popular biblioteca de visualização de dados Python, para criar e personalizar gráficos de linha em Python.

Apresentando o conjunto de dados

Para ter algo para praticar os gráficos de linhas marítimas, primeiro baixaremos um conjunto de dados do Kaggle chamado Taxas de câmbio diárias por Euro 1999-2023 . Em seguida, importaremos todos os pacotes necessários, leremos e limparemos o dataframe. Sem entrar em detalhes do processo de limpeza, o código abaixo demonstra os passos a serem executados:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv('euro-daily-hist_1999_2022.csv')
df = df.iloc[:, [0, 1, 4, -2]]
df.columns = ['Date', 'Australian dollar', 'Canadian dollar', 'US dollar']
df = pd.melt(df, id_vars='Date', value_vars=['Australian dollar', 'Canadian dollar', 'US dollar'], value_name='Euro rate', var_name='Currency')
df['Date'] = pd.to_datetime(df['Date'])
df = df[df['Date']>='2022-12-01'].reset_index(drop=True)
df['Euro rate'] = pd.to_numeric(df['Euro rate'])
print(f'Currencies: {df.Currency.unique()}\n')
print(df.head())
print(f'\n{df.Date.dt.date.min()}/{ df.Date.dt.date.max()}')

Saída :

Currencies: ['Australian dollar' 'Canadian dollar' 'US dollar']

        Date           Currency  Euro rate
0 2023-01-27  Australian dollar     1.5289
1 2023-01-26  Australian dollar     1.5308
2 2023-01-25  Australian dollar     1.5360
3 2023-01-24  Australian dollar     1.5470
4 2023-01-23  Australian dollar     1.5529

2022-12-01/2023-01-27

O dataframe resultante contém taxas de euro diárias (dias úteis) para dólares australianos, canadenses e americanos para o período de 01.12.2022 até 27.01.2023 inclusive.

Agora, estamos prontos para mergulhar na criação e personalização de plotagens de linhas marítimas em Python.

Noções básicas de plotagem de linha Seaborn

Para criar um gráfico de linha no Seaborn, podemos usar uma das duas funções: lineplot()ou relplot(). No geral, eles têm muitas funcionalidades em comum, juntamente com nomes de parâmetros idênticos. A principal diferença é que relplot() nos permite criar gráficos de linha com várias linhas em diferentes facetas. Em vez disso, lineplot() permite trabalhar com intervalos de confiança e agregação de dados.

Neste tutorial, usaremos principalmente a função lineplot().

O curso Introdução à Visualização de Dados com Seaborn ajudará você a aprender e praticar as principais funções e métodos da biblioteca seaborn. Você também pode conferir nosso tutorial Seaborn para iniciantes para se familiarizar mais com a popular biblioteca Python. 

Criando um único gráfico de linha marítima

Podemos criar um gráfico de linhas mostrando as relações entre duas variáveis ​​contínuas da seguinte maneira:

usd = df[df['Currency']=='US dollar'].reset_index(drop=True)
sns.lineplot(x='Date', y='Euro rate', data=usd)

Saída :

O gráfico acima mostra a dinâmica da taxa EUR-USD. Definimos as variáveis ​​para plotar nos eixos x e y (os parâmetros x e y ) e o dataframe (dados) para obter essas variáveis.

Para comparação, para criar o mesmo gráfico usando relplot(), escreveríamos o seguinte:

sns.relplot(x='Date', y='Euro rate', data=usd, kind='line')

Saída :

Neste caso, passamos mais um argumento específico para a função relplot(): kind='line'. Por padrão, esta função cria um gráfico de dispersão.

Personalizando um único gráfico de linha marítima

Podemos personalizar o gráfico acima de várias maneiras para torná-lo mais legível e informativo. Por exemplo, podemos ajustar o tamanho da figura, adicionar rótulos de títulos e eixos, ajustar o tamanho da fonte, personalizar a linha, adicionar e personalizar marcadores, etc. Vejamos como implementar essas melhorias no seaborn.

Ajustando o tamanho da figura

Como o Seaborn é construído sobre o matplotlib, podemos usar o matplotlib.pyplot para ajustar o tamanho da figura:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd)

Saída :

Em vez disso, com relplot(), podemos usar os parâmetros height e aspect (a relação largura-altura) para o mesmo propósito:

sns.relplot(x='Date', y='Euro rate', data=usd, kind='line', height=6, aspect=4)

Saída :

Adicionando um título e rótulos de eixo

Para adicionar um título de gráfico e rótulos de eixo, podemos usar a função set() no objeto seaborn line plot passando os argumentos title, xlabel e ylabel:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')

Saída :

Ajustando o tamanho da fonte

Uma maneira conveniente de ajustar o tamanho da fonte é usar a função set_theme() e experimentar diferentes valores do parâmetro font_scale:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Observe que também adicionamos style='white' para evitar substituir o estilo inicial.

Alterar a cor, o estilo e o tamanho da linha

Para personalizar a linha de plotagem, podemos passar alguns parâmetros opcionais em comum com matplotlib.pyplot.plot, como cor, estilo de linha ou largura de linha:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd, linestyle='dotted', color='magenta', linewidth=5).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Adicionando marcadores e personalizando sua cor, estilo e tamanho

É possível adicionar marcadores na linha e personalizar sua aparência. Além disso, neste caso, podemos usar alguns parâmetros do matplotlib, como marcador, marcadorfacecolor ou marcadoresize:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd, marker='*', markerfacecolor='limegreen', markersize=20).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

A documentação nos fornece a lista definitiva dos parâmetros a serem usados ​​para melhorar a estética de uma plotagem de linha marítima. Em particular, podemos ver todas as escolhas possíveis de marcadores .

Em nossa folha de dicas do Seaborn , você encontrará outras maneiras de personalizar um gráfico de linha no Seaborn.

Gráficos de linha Seaborn com várias linhas

Frequentemente, precisamos explorar como várias variáveis ​​contínuas mudam dependendo de outra variável contínua. Para isso, podemos construir um gráfico de linhas marítimas com várias linhas. As funções lineplot() e relplot() também são aplicáveis ​​a esses casos.

Criando um gráfico de linha marítima com várias linhas

Tecnicamente, é possível criar um gráfico de linhas marítimas com várias linhas apenas construindo um objeto de eixos separado para cada variável dependente, ou seja, cada linha:

aud = df[df['Currency']=='Australian dollar'].reset_index(drop=True)
cad = df[df['Currency']=='Canadian dollar'].reset_index(drop=True)

sns.lineplot(x='Date', y='Euro rate', data=usd)
sns.lineplot(x='Date', y='Euro rate', data=aud)
sns.lineplot(x='Date', y='Euro rate', data=cad)

Saída :

Acima, extraímos mais dois subconjuntos de nosso dataframe inicial df – para dólares australianos e canadenses – e plotamos cada taxa do euro em relação ao tempo. No entanto, existem soluções mais eficientes para isso: usar os parâmetros hue, style ou size, disponíveis em lineplot() e relplot().

Usando o parâmetro matiz

Este parâmetro funciona da seguinte forma: atribuímos a ele o nome de uma coluna do dataframe contendo valores categóricos, e então seaborn gera um gráfico de linha para cada categoria dando uma cor diferente para cada linha:

sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency')

Saída :

Com apenas uma linha de código simples, criamos um gráfico de linhas marítimas para três categorias. Observe que passamos o dataframe inicial df em vez de seus subconjuntos para diferentes moedas.

Usando o parâmetro de estilo

O parâmetro style funciona da mesma forma que matiz, só que distingue entre as categorias usando diferentes estilos de linha (sólido, tracejado, pontilhado, etc.), sem afetar a cor:

sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency')

Saída :

Usando o parâmetro de tamanho

Assim como matiz e estilo, o parâmetro de tamanho cria uma linha separada para cada categoria. Não afeta a cor e o estilo das linhas, mas torna cada uma delas de largura diferente:

sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency')

Saída :

Personalizando um gráfico de linha marítima com várias linhas

Vamos agora experimentar a estética do nosso gráfico. Algumas técnicas aqui são idênticas àquelas que aplicamos a um único gráfico de linha Seaborn. Os outros são específicos apenas para plotagens de linha com múltiplas linhas.

Ajustes gerais

Podemos ajustar o tamanho da figura, adicionar um título e rótulos de eixo e alterar o tamanho da fonte do gráfico acima da mesma forma que fizemos para um gráfico de linha única:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Alterar a cor, o estilo e o tamanho de cada linha

Anteriormente, vimos que quando os parâmetros matiz, estilo ou tamanho são usados, seaborn fornece um conjunto padrão de cores/estilos/tamanhos para um gráfico de linha com várias linhas. Se necessário, podemos substituir esses padrões e selecionar cores/estilos/tamanhos por nós mesmos.

Quando usamos o parâmetro hue, também podemos passar o argumento da paleta como uma lista ou tupla de nomes de cores matplotlib:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette=['magenta', 'deepskyblue', 'yellowgreen']).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Também é possível aplicar diretamente uma paleta matplotlib existente:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette='spring').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Ao mesmo tempo, ao usar matiz, ainda podemos ajustar o estilo de linha e a largura de todas as linhas que passam nos argumentos estilo de linha e largura de linha:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette=['magenta', 'deepskyblue', 'yellowgreen'], linestyle='dashed', linewidth=5).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Em vez disso, quando criamos um gráfico de linhas marítimas com várias linhas usando o parâmetro de estilo, podemos atribuir uma lista (ou uma tupla) de listas (ou tuplas) a um parâmetro chamado traços:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', dashes=[[4, 4], [6, 1], [3, 9]]).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Na lista acima de listas atribuídas a traços, o primeiro item de cada sublista representa o comprimento de um segmento da linha correspondente, enquanto o segundo item – o comprimento de uma lacuna.

Nota: para representar uma linha sólida, precisamos definir o comprimento de uma lacuna para zero, por exemplo: [1, 0].

Para ajustar a cor e a largura de todas as linhas deste gráfico, fornecemos os argumentos color e linewidth, assim como fizemos ao personalizar um único gráfico de linha marítima:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', dashes=[[4, 4], [6, 1], [3, 9]], color='darkviolet', linewidth=4).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Finalmente, quando usamos o parâmetro de tamanho para criar um gráfico de linhas múltiplas marítimas, podemos regular a largura de cada linha através do parâmetro de tamanhos. Leva em uma lista (ou uma tupla) de inteiros:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency', sizes=[2, 10, 5]).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Para personalizar a cor e o estilo de todas as linhas deste gráfico, precisamos fornecer os argumentos estilo de linha e cor:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency', sizes=[2, 10, 5], linestyle='dotted', color='teal').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Adicionando marcadores e personalizando sua cor, estilo e tamanho

Podemos querer adicionar marcadores em nosso gráfico de linhas múltiplas marítimas.

Para adicionar marcadores da mesma cor, estilo e tamanho em todas as linhas, precisamos usar os parâmetros do matplotlib, como marcador, marcadorfacecolor, marcadorsize, etc., assim como fizemos para um gráfico de linha única:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', marker='o', markerfacecolor='orangered', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

As coisas são diferentes, porém, quando queremos marcadores diferentes para cada linha. Neste caso, precisamos utilizar o parâmetro markers, que, porém, conforme as funcionalidades seaborn, só funciona quando o parâmetro style é especificado:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', markers=['o', 'X', '*'], markerfacecolor='brown', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

No gráfico acima, podemos tornar todas as linhas sólidas fornecendo o argumento de traços e definindo o padrão de estilo [1, 0] para cada linha:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', markers=['o', 'X', '*'], dashes=[[1, 0], [1, 0], [1, 0]], markerfacecolor='brown', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Saída :

Conclusão

Para recapitular, neste tutorial, aprendemos várias maneiras de criar e personalizar um gráfico de linha Seaborn com uma ou várias linhas.

Como um caminho a seguir, com seaborn, podemos fazer muito mais para ajustar ainda mais um gráfico de linha. Por exemplo, podemos:

• Agrupar linhas por mais de uma variável categórica
• Personalize a legenda
• Crie gráficos de linha com várias linhas em diferentes facetas
• Exibir e personalizar o intervalo de confiança
• Personalize os tiques do eixo de tempo e seus rótulos para um gráfico de linha de série temporal

Fonte do artigo original em: https://www.datacamp.com

#python #datavisualizations 

Python Seaborn Data Visualization Tutorial

In this Python tutorial we will learn about Python Seaborn Line Plot Tutorial: Create Data Visualizations. Discover how to use Seaborn, a popular Python data visualization library, to create and customize line plots in Python.

A line plot is a relational data visualization showing how one continuous variable changes when another does. It's one of the most common graphs widely used in finance, sales, marketing, healthcare, natural sciences, and more.

In this tutorial, we'll discuss how to use Seaborn, a popular Python data visualization library, to create and customize line plots in Python.

Introducing the Dataset

To have something to practice seaborn line plots on, we'll first download a Kaggle dataset called Daily Exchange Rates per Euro 1999-2023. Then, we'll import all the necessary packages and read in and clean the dataframe. Without getting into details of the cleaning process, the code below demonstrates the steps to perform:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv('euro-daily-hist_1999_2022.csv')
df = df.iloc[:, [0, 1, 4, -2]]
df.columns = ['Date', 'Australian dollar', 'Canadian dollar', 'US dollar']
df = pd.melt(df, id_vars='Date', value_vars=['Australian dollar', 'Canadian dollar', 'US dollar'], value_name='Euro rate', var_name='Currency')
df['Date'] = pd.to_datetime(df['Date'])
df = df[df['Date']>='2022-12-01'].reset_index(drop=True)
df['Euro rate'] = pd.to_numeric(df['Euro rate'])
print(f'Currencies: {df.Currency.unique()}\n')
print(df.head())
print(f'\n{df.Date.dt.date.min()}/{ df.Date.dt.date.max()}')

Output:

Currencies: ['Australian dollar' 'Canadian dollar' 'US dollar']

        Date           Currency  Euro rate
0 2023-01-27  Australian dollar     1.5289
1 2023-01-26  Australian dollar     1.5308
2 2023-01-25  Australian dollar     1.5360
3 2023-01-24  Australian dollar     1.5470
4 2023-01-23  Australian dollar     1.5529

2022-12-01/2023-01-27

The resulting dataframe contains daily (business days) Euro rates for Australian, Canadian, and US dollars for the period from 01.12.2022 until 27.01.2023 inclusive.

Now, we're ready to dive into creating and customizing Python seaborn line plots.

Seaborn Line Plot Basics

To create a line plot in Seaborn, we can use one of the two functions: lineplot() or relplot(). Overall, they have a lot of functionality in common, together with identical parameter names. The main difference is that relplot() allows us to create line plots with multiple lines on different facets. Instead, lineplot() allows working with confidence intervals and data aggregation.

In this tutorial, we'll mostly use the lineplot() function.

The course Introduction to Data Visualization with Seaborn will help you learn and practice the main functions and methods of the seaborn library. You can also check out our Seaborn tutorial for beginners to get more familiar with the popular Python library. 

Creating a single seaborn line plot

We can create a line plot showing the relationships between two continuous variables as follows:

usd = df[df['Currency']=='US dollar'].reset_index(drop=True)
sns.lineplot(x='Date', y='Euro rate', data=usd)

Output:

The above graph shows the EUR-USD rate dynamics. We defined the variables to plot on the x and y axes (the x and y parameters) and the dataframe (data) to take these variables from.

For comparison, to create the same plot using relplot(), we would write the following:

sns.relplot(x='Date', y='Euro rate', data=usd, kind='line')

Output:

In this case, we passed in one more argument specific to the relplot() function: kind='line'. By default, this function creates a scatter plot.

Customizing a single seaborn line plot

We can customize the above chart in many ways to make it more readable and informative. For example, we can adjust the figure size, add title and axis labels, adjust the font size, customize the line, add and customize markers, etc. Let's see how to implement these improvements in seaborn.

Adjusting the figure size

Since Seaborn is built on top of matplotlib, we can use matplotlib.pyplot to adjust the figure size:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd)

Output:

Instead, with relplot(), we can use the height and aspect (the width-to-height ratio) parameters for the same purpose:

sns.relplot(x='Date', y='Euro rate', data=usd, kind='line', height=6, aspect=4)

Output:

Adding a title and axis labels

To add a graph title and axis labels, we can use the set() function on the seaborn line plot object passing in the title, xlabel, and ylabel arguments:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')

Output:

Adjusting the font size

A convenient way to adjust the font size is to use the set_theme() function and experiment with different values of the font_scale parameter:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Note that we also added style='white' to avoid overriding the initial style.

Changing the line color, style, and size

To customize the plot line, we can pass in some optional parameters in common with matplotlib.pyplot.plot, such as color, linestyle, or linewidth:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd, linestyle='dotted', color='magenta', linewidth=5).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Adding markers and customizing their color, style, and size

It's possible to add markers on the line and customize their appearance. Also, in this case, we can use some parameters from matplotlib, such as marker, markerfacecolor, or markersize:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=usd, marker='*', markerfacecolor='limegreen', markersize=20).set(title='Euro-USD rate', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

The documentation provides us with the ultimate list of the parameters to use for improving the aesthetics of a seaborn line plot. In particular, we can see all the possible choices of markers.

In our Seaborn cheat sheet, you'll find other ways to customize a line plot in Seaborn.

Seaborn Line Plots With Multiple Lines

Often, we need to explore how several continuous variables change depending on another continuous variable. For this purpose, we can build a seaborn line plot with multiple lines. The functions lineplot() and relplot() are also applicable to such cases.

Creating a seaborn line plot with multiple lines

Technically, it's possible to create a seaborn line plot with multiple lines just by building a separate axes object for each dependent variable, i.e., each line:

aud = df[df['Currency']=='Australian dollar'].reset_index(drop=True)
cad = df[df['Currency']=='Canadian dollar'].reset_index(drop=True)

sns.lineplot(x='Date', y='Euro rate', data=usd)
sns.lineplot(x='Date', y='Euro rate', data=aud)
sns.lineplot(x='Date', y='Euro rate', data=cad)

Output:

Above, we extracted two more subsets from our initial dataframe df – for Australian and Canadian dollars – and plotted each euro rate against time. However, there are more efficient solutions to it: using the hue, style, or size parameters, available in both lineplot() and relplot().

Using the hue parameter

This parameter works as follows: we assign to it the name of a dataframe column containing categorical values, and then seaborn generates a line plot for each category giving a different color to each line:

sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency')

Output:

With just one line of simple code, we created a seaborn line plot for three categories. Note that we passed in the initial dataframe df instead of its subsets for different currencies.

Using the style parameter

The style parameter works in the same way as hue, only that it distinguishes between the categories by using different line styles (solid, dashed, dotted, etc.), without affecting the color:

sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency')

Output:

Using the size parameter

Just like hue and style, the size parameter creates a separate line for each category. It doesn't affect the color and style of the lines but makes each of them of different width:

sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency')

Output:

Customizing a seaborn line plot with multiple lines

Let's now experiment with the aesthetics of our graph. Some techniques here are identical to those we applied to a single Seaborn line plot. The others are specific only to line plots with multiple lines.

Overall adjustments

We can adjust the figure size, add a title and axis labels, and change the font size of the above graph in the same way as we did for a single line plot:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Changing the color, style, and size of each line

Earlier, we saw that when the hue, style, or size parameters are used, seaborn provides a default set of colors/styles/sizes for a line plot with multiple lines. If necessary, we can override these defaults and select colors/styles/sizes by ourselves.

When we use the hue parameter, we can also pass in the palette argument as a list or tuple of matplotlib color names:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette=['magenta', 'deepskyblue', 'yellowgreen']).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

It's also possible to apply directly an existing matplotlib palette:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette='spring').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

At the same time, when using hue, we can still adjust the line style and width of all the lines passing in the arguments linestyle and linewidth:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', palette=['magenta', 'deepskyblue', 'yellowgreen'], linestyle='dashed', linewidth=5).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Instead, when we create a seaborn line plot with multiple lines using the style parameter, we can assign a list (or a tuple) of lists (or tuples) to a parameter called dashes:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', dashes=[[4, 4], [6, 1], [3, 9]]).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

In the above list of lists assigned to dashes, the first item of each sublist represents the length of a segment of the corresponding line, while the second item – the length of a gap.

Note: to represent a solid line, we need to set the length of a gap to zero, e.g.: [1, 0].

To adjust the color and width of all the lines of this graph, we provide the arguments color and linewidth, just like we did when customizing a single seaborn line plot:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', dashes=[[4, 4], [6, 1], [3, 9]], color='darkviolet', linewidth=4).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Finally, when we use the size parameter to create a seaborn multiple line plot, we can regulate the width of each line through the sizes parameter. It takes in a list (or a tuple) of integers:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency', sizes=[2, 10, 5]).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

To customize the color and style of all the lines of this plot, we need to provide the arguments linestyle and color:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, size='Currency', sizes=[2, 10, 5], linestyle='dotted', color='teal').set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Adding markers and customizing their color, style, and size

We may want to add markers on our seaborn multiple line plot.

To add markers of the same color, style, and size on all the lines, we need to use the parameters from matplotlib, such as marker, markerfacecolor, markersize, etc., just as we did for a single line plot:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, hue='Currency', marker='o', markerfacecolor='orangered', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Things are different, though, when we want different markers for each line. In this case, we need to use the markers parameter, which, however, according to seaborn functionalities, works only when the style parameter is specified:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', markers=['o', 'X', '*'], markerfacecolor='brown', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

On the above plot, we can make all the lines solid by providing the dashes argument and setting the [1, 0] style pattern to each line:

fig = plt.subplots(figsize=(20, 5))
sns.lineplot(x='Date', y='Euro rate', data=df, style='Currency', markers=['o', 'X', '*'], dashes=[[1, 0], [1, 0], [1, 0]], markerfacecolor='brown', markersize=10).set(title='Euro rates for different currencies', xlabel='Date', ylabel='Rate')
sns.set_theme(style='white', font_scale=3)

Output:

Conclusion

To recap, in this tutorial, we learned a range of ways to create and customize a Seaborn line plot with either a single or multiple lines.

As a way forward, with seaborn, we can do much more to further adjust a line plot. For example, we can:

• Group lines by more than one categorical variable
• Customize the legend
• Create line plots with multiple lines on different facets
• Display and customize the confidence interval
• Customize time axis ticks and their labels for a time series line plot

Original article source at: https://www.datacamp.com

#python #datavisualizations 

How to Create a Complex Visualization using D3.js and TypeScript

This tutorial will be a step-by-step guide that will show you how to create a complex visualization using D3.js and TypeScript.

This article will chronicle my experiences studying D3.js, a JavaScript framework that produces high-quality diagrams and graphics fueled by data.

Although D3 is a JavaScript library, we will use TypeScript because it handles data and data types more efficiently than plain old JavaScript.

This tutorial will show you how to create visualizations using D3 and TypeScript. First, we’ll create a simple boilerplate project, add data, and then build a fully interactive example. We will host the code on CodePen for maximum interactivity as a stylistic decision.

Each example will run in the browser, saving you the fuss of installing anything onto your computer. Of course, you’ll be able to fork a Pen and work on your code version.

• Creating and exporting the boilerplate project
• Adding visualization data to D3
• Binding the data to graphics
• Interacting with the visualizations with D3 and TypeScript

Creating and exporting the boilerplate project in D3

We will mainly focus on adding dependencies and getting acquainted with the environment with the boilerplate Pen. There will be HTML on the left, CSS in the middle, and TypeScript on the right. This is where most of the action will take place.

Next, ensure that the JavaScript pane is set to TypeScript and add D3 as a dependency. You can do this by selecting the gear icon on the top right.

Here’s an interactive example of the code

The code is straightforward, so we will only focus on TypeScript because the HTML and CSS are irrelevant.

import * as d3 from "https://cdn.skypack.dev/d3@7.6.1";

const svg = d3.select("body")
  .append("svg")
  .attr("width", 500)
  .attr("height", 500);

svg
  .append("text")
  .attr("x", 100)
  .attr("y", 100)
  .text("Hello d3js");

svg
  .append("circle")
  .attr("r", 30)
  .attr("cx", 60)
  .attr("cy", 50);

The import addresses the D3 library dependency. In the following block of code, we added the svg component to the body tag to accommodate our graphics in each code example.

The last two lines of code add the text and circle to produce the results seen in the Pen. That is everything we need to set up the environment to play with D3.

Adding data to D3

To stay true to the D3 philosophy, we have to add data to our graphics. To do this, we’ll use the code below. This downloads a CSV file and manipulates it to visualize it as a scatter plot.

Codepen

import * as d3 from "https://cdn.skypack.dev/d3@7.6.1";

// set the dimensions and margins of the graph
const margin = { top: 10, right: 30, bottom: 30, left: 60 },
  width = 460 - margin.left - margin.right,
  height = 400 - margin.top - margin.bottom;

// append the svg object to the body of the page
const svg = d3
  .select("body")
  .append("svg")
  .attr("width", width + margin.left + margin.right)
  .attr("height", height + margin.top + margin.bottom)
  .append("g")
  .attr("transform", `translate(${margin.left}, ${margin.top})`);

// Read the data
d3.csv(
"https://raw.githubusercontent.com/holtzy/D3-graph-gallery/master/DATA/iris.csv"
).then(function (csvdata) {
  // Add X axis
  const x = d3.scaleLinear().domain([3, 9]).range([0, width]);
  const xAxis = svg
    .append("g")
    .attr("transform", `translate(0, ${height})`)
    .call(d3.axisBottom(x));

  // Add Y axis
  const y = d3.scaleLinear().domain([0, 9]).range([height, 0]);
  svg.append("g").call(d3.axisLeft(y));

  // Add dots
  svg.append("g")
     .selectAll("circle")
     .data(csvdata)
     .join("circle")
     .attr("cx", function (d) {
       return x(d.Sepal_Length);
    })
    .attr("cy", function (d) {
       return y(d.Petal_Length);
    })
    .attr("r", 5);
});

After we’ve done the import, we will define the surface to draw our graphics on. We can do this by calculating the area’s width and height along with the margins. These values add svg to the HTML body and specify a transformation. In this case, it’s a translate operation to place g under svg.

Our last operation is to map the points in the scatterplot. The data is directly downloaded from a URL as a CSV file. D3 can manipulate CSV data, which comes in handy most of the time. Once the data is available, three operations are performed: adding the x-axis, adding the y-axis, and plotting the data.

The first two operations are performed consecutively to define the x and y-axes as scaleLinear. Then, for each axis, the range is specified by the number of pixels that such axes will occupy. The x-axis will have a domain of 3 to 9, and the y-axis will be 0 to 9.

Binding data to graphics using D3

Adding the dots to the scatter plot may appear a little convoluted, but we can do it with a specific sequence of operations. The idea is to bind a graphic component — a circle, a point, and a line — to data. Then, the data will modify some aspects of the graphic component, such as color, thickness, pattern, and position. In the source code above, we:

• Use .selectAll to define the type of element that will join each element of the data
• Use .data to define the array
• Use .join to join the data and the graphics elements. This is where HTML or SVG are dynamically added and removed

Now, we define how the value of the data influences the graphics element. In the example above, you can see that we .selectAll circle elements, we call .data to assign the csvdata as the data source of the join, and then we .join the data to the graphics element.

Our final and most creative step is defining how the data influence graphics. At this point, we only have a circle for each entry in the csvdata. To modify the circles, we use .attr. The first two will modify the attributes cx and cy at the center of the circle coordinates, then modify the radius by setting it to 5.

Interacting with the visualizations with D3

Next, let’s add an interaction to explore the real possibilities of D3. First, let’s look at the final result

Together with the scatterplot, we have a button to remove one circle from the data. This is done in D3 without access to external sources. The button is added in HTML but is bound to the code it will execute in the TypeScript source.

The interaction occurs in popCircle() and will remove the last element from the csvdata array. This will then join the circles in the scatterplot to data, but with a little addition — the .exit operation. This defines what happens when a datum exits the graphics array.

The semantics of the code is simple: everything after .exit() will apply to the graphics elements exiting from the array. Here, we ask D3 to apply a transition on the circle radius specified by .attr that will become 0 before removing graphics from the representation.

The final effect is visually satisfying. Once you click the button, the scatterplot circles disappear, and the transition alerts the user to where modifications are happening.

Conclusion

In this tutorial, we learned how to set up a stripped-down project based on TypeScript and D3. We also saw how to go from a basic representation to an advanced and interactive data-driven one. Although the example is simple, I hope it clearly shows where to intervene to produce data-driven graphical representations.

Original article source at https://blog.logrocket.com

#d3 #typescript #datavisualizations

Popular Python Data Visualization Libraries

In this Python article, let's learn about Data Visualization: Popular Python Data Visualization Libraries

Table of contents:

• Altair - Declarative statistical visualization library for Python.
• Bokeh - Interactive Web Plotting for Python.
• bqplot - Interactive Plotting Library for the Jupyter Notebook.
• Cartopy - A cartographic python library with matplotlib support.
• Dash - Built on top of Flask, React and Plotly aimed at analytical web applications
• diagrams - Diagram as Code.
• Matplotlib - A Python 2D plotting library.
• plotnine - A grammar of graphics for Python based on ggplot2.
• Pygal - A Python SVG Charts Creator.
• PyGraphviz - Python interface to Graphviz.
• PyQtGraph - Interactive and realtime 2D/3D/Image plotting and science/engineering widgets.
• Seaborn - Statistical data visualization using Matplotlib.
• VisPy - High-performance scientific visualization based on OpenGL.

What is data visualization using Python?

Data visualization is the discipline of trying to understand data by placing it in a visual context so that patterns, trends, and correlations that might not otherwise be detected can be exposed. Python offers multiple great graphing libraries packed with lots of different features.

Popular Python Data Visualization Libraries

1. Altair

The Vega-Altair open source project is not affiliated with Altair Engineering, Inc.

Vega-Altair is a declarative statistical visualization library for Python. With Vega-Altair, you can spend more time understanding your data and its meaning. Vega-Altair's API is simple, friendly and consistent and built on top of the powerful Vega-Lite JSON specification. This elegant simplicity produces beautiful and effective visualizations with a minimal amount of code. Vega-Altair was originally developed by Jake Vanderplas and Brian Granger in close collaboration with the UW Interactive Data Lab.

Example

Here is an example using Vega-Altair to quickly visualize and display a dataset with the native Vega-Lite renderer in the JupyterLab:

import altair as alt

# load a simple dataset as a pandas DataFrame
from vega_datasets import data
cars = data.cars()

alt.Chart(cars).mark_point().encode(
    x='Horsepower',
    y='Miles_per_Gallon',
    color='Origin',
)

One of the unique features of Vega-Altair, inherited from Vega-Lite, is a declarative grammar of not just visualization, but interaction. With a few modifications to the example above we can create a linked histogram that is filtered based on a selection of the scatter plot.

import altair as alt
from vega_datasets import data

source = data.cars()

brush = alt.selection(type='interval')

points = alt.Chart(source).mark_point().encode(
    x='Horsepower',
    y='Miles_per_Gallon',
    color=alt.condition(brush, 'Origin', alt.value('lightgray'))
).add_selection(
    brush
)

bars = alt.Chart(source).mark_bar().encode(
    y='Origin',
    color='Origin',
    x='count(Origin)'
).transform_filter(
    brush
)

points & bars

View on GitHub

2.  Bokeh

Bokeh is an interactive visualization library for modern web browsers. It provides elegant, concise construction of versatile graphics and affords high-performance interactivity across large or streaming datasets. Bokeh can help anyone who wants to create interactive plots, dashboards, and data applications quickly and easily.

Installation

To install Bokeh and its required dependencies using conda, enter the following command at a Bash or Windows command prompt:

conda install bokeh

To install using pip, enter the following command at a Bash or Windows command prompt:

pip install bokeh

Refer to the installation documentation for more details.

View on GitHub

3.  bqplot

bqplot is a 2-D visualization system for Jupyter, based on the constructs of the Grammar of Graphics.

Installation

Using pip:

$ pip install bqplot

Using conda

$ conda install -c conda-forge bqplot

If you are using JupyterLab <=2:

$ jupyter labextension install @jupyter-widgets/jupyterlab-manager bqplot

Development installation

For a development installation (requires JupyterLab (version >= 3) and yarn):

$ git clone https://github.com/bqplot/bqplot.git
$ cd bqplot
$ pip install -e .
$ jupyter nbextension install --py --overwrite --symlink --sys-prefix bqplot
$ jupyter nbextension enable --py --sys-prefix bqplot

Note for developers: the --symlink argument on Linux or OS X allows one to modify the JavaScript code in-place. This feature is not available with Windows.

For the experimental JupyterLab extension, install the Python package, make sure the Jupyter widgets extension is installed, and install the bqplot extension:

$ pip install "ipywidgets>=7.6"
$ jupyter labextension develop . --overwrite

Whenever you make a change of the JavaScript code, you will need to rebuild:

cd js
yarn run build

Then refreshing the JupyterLab/Jupyter Notebook is enough to reload the changes.

Running tests

You can install the dependencies necessary to run the tests with:

    conda env update -f test-environment.yml

And run it with for Python tests:

    pytest

And cd js to run the JS tests with:

yarn run test

Every time you make a change on your tests it's necessary to rebuild the JS side:

yarn run build

View on GitHub

4.  Cartopy

Cartopy is a Python package designed to make drawing maps for data analysis and visualisation easy.

Overview

Cartopy is a Python package designed to make drawing maps for data analysis and visualisation easy.

It features:

• object oriented projection definitions
• point, line, polygon and image transformations between projections
• integration to expose advanced mapping in Matplotlib with a simple and intuitive interface
• powerful vector data handling by integrating shapefile reading with Shapely capabilities

Documentation can be found at https://scitools.org.uk/cartopy/docs/latest/.

Get in touch

• Ask usage questions on StackOverflow.
• For less well defined questions, ideas, general discussion or announcements of related projects use the Google Group.
• Report bugs, suggest features or view the source code on GitHub.
• To chat with developers and other users you can use the Gitter Chat

View on GitHub

5.  Dash

A curated list of awesome Dash (plotly) resources

Dash is a productive Python framework for building web applications. Written on top of Flask, Plotly.js, and React.js, Dash is ideal for building data visualization apps with highly custom user interfaces in pure Python. It's particularly suited for anyone who works with data in Python.

View on GitHub

6.  Diagrams

🎨 Diagram as Code for prototyping cloud system architectures

Diagrams lets you draw the cloud system architecture in Python code. It was born for prototyping a new system architecture design without any design tools. You can also describe or visualize the existing system architecture as well. Diagrams currently supports main major providers including: AWS, Azure, GCP, Kubernetes, Alibaba Cloud, Oracle Cloud etc... It also supports On-Premise nodes, SaaS and major Programming frameworks and languages.

Diagram as Code also allows you to track the architecture diagram changes in any version control system.

Getting Started

It requires Python 3.6 or higher, check your Python version first.

It uses Graphviz to render the diagram, so you need to install Graphviz to use diagrams. After installing graphviz (or already have it), install the diagrams.

macOS users can download the Graphviz via brew install graphviz if you're using Homebrew.

# using pip (pip3)
$ pip install diagrams

# using pipenv
$ pipenv install diagrams

# using poetry
$ poetry add diagrams

You can start with quick start. Check out guides for more details, and you can find all available nodes list in here.

View on GitHub

7.  Matplotlib 

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python.

Matplotlib produces publication-quality figures in a variety of hardcopy formats and interactive environments across platforms. Matplotlib can be used in Python scripts, Python/IPython shells, web application servers, and various graphical user interface toolkits.

Install

For installation instructions and requirements, see the install documentation or installing.rst in the source.

Contribute

You've discovered a bug or something else you want to change - excellent!

You've worked out a way to fix it – even better!

You want to tell us about it – best of all!

Start at the contributing guide!

Contact

Discourse is the discussion forum for general questions and discussions and our recommended starting point.

Our active mailing lists (which are mirrored on Discourse) are:

• Users mailing list: matplotlib-users@python.org
• Announcement mailing list: matplotlib-announce@python.org
• Development mailing list: matplotlib-devel@python.org

Gitter is for coordinating development and asking questions directly related to contributing to matplotlib.

Citing Matplotlib

If Matplotlib contributes to a project that leads to publication, please acknowledge this by citing Matplotlib.

A ready-made citation entry is available.

View on GitHub

8.  plotnine

plotnine is an implementation of a grammar of graphics in Python, it is based on ggplot2. The grammar allows users to compose plots by explicitly mapping data to the visual objects that make up the plot.

Example

from plotnine import *
from plotnine.data import mtcars

Building a complex plot piece by piece.

1.  Scatter plot

(ggplot(mtcars, aes('wt', 'mpg'))
 + geom_point())

Scatter plot colored according some variable

(ggplot(mtcars, aes('wt', 'mpg', color='factor(gear)'))
 + geom_point())

Scatter plot colored according some variable and smoothed with a linear model with confidence intervals.

(ggplot(mtcars, aes('wt', 'mpg', color='factor(gear)'))
 + geom_point()
 + stat_smooth(method='lm'))

Scatter plot colored according some variable, smoothed with a linear model with confidence intervals and plotted on separate panels.

(ggplot(mtcars, aes('wt', 'mpg', color='factor(gear)'))
 + geom_point()
 + stat_smooth(method='lm')
 + facet_wrap('~gear'))

Adjust the themes

5.1 Make it playful

(ggplot(mtcars, aes('wt', 'mpg', color='factor(gear)'))
 + geom_point()
 + stat_smooth(method='lm')
 + facet_wrap('~gear')
 + theme_xkcd())

5.2 Or professional

(ggplot(mtcars, aes('wt', 'mpg', color='factor(gear)'))
 + geom_point()
 + stat_smooth(method='lm')
 + facet_wrap('~gear')
 + theme_tufte())

View on GitHub

9.  Pygal

Description

pygal is a dynamic SVG charting library written in python. All the documentation is on www.pygal.org

Installation

As simple as:

    $ pip install pygal

Test

Pygal is tested with py.test:

    $ pip install pytest
    $ py.test

Contribute

You are welcomed to fork the project and make pull requests. Be sure to create a branch for each feature, write tests if needed and run the current tests !

View on GitHub

10.  PyGraphviz 

PyGraphviz is a Python interface to the Graphviz graph layout and visualization package. With PyGraphviz you can create, edit, read, write, and draw graphs using Python to access the Graphviz graph data structure and layout algorithms. PyGraphviz provides a similar programming interface to NetworkX (https://networkx.org).

Simple example

>>> import pygraphviz as pgv
>>> G = pgv.AGraph()
>>> G.add_node("a")
>>> G.add_edge("b", "c")
>>> print(G)
strict graph "" {
        a;
        b -- c;
}

Install

PyGraphviz requires Graphviz. Please see INSTALL.txt for details.

License

Released under the 3-Clause BSD license (see LICENSE):

Copyright (C) 2006-2022 PyGraphviz Developers
Aric Hagberg <aric.hagberg@gmail.gov>
Dan Schult <dschult@colgate.edu>
Manos Renieris

View on GitHub

11.  PyQtGraph

PyQtGraph is intended for use in mathematics / scientific / engineering applications. Despite being written entirely in python, the library is fast due to its heavy leverage of numpy for number crunching, Qt's GraphicsView framework for 2D display, and OpenGL for 3D display.

Requirements

PyQtGraph has adopted NEP 29.

This project supports:

• All minor versions of Python released 42 months prior to the project, and at minimum the two latest minor versions.
• All minor versions of numpy released in the 24 months prior to the project, and at minimum the last three minor versions.
• Qt5 5.15, and Qt6 6.2+

Currently this means:

• Python 3.8+
• Qt 5.15, 6.2+
• PyQt5, PyQt6, PySide2, or PySide6
• numpy 1.20+

Installation Methods

• From PyPI
  • Last released version: pip install pyqtgraph
  • Latest development version: pip install git+https://github.com/pyqtgraph/pyqtgraph@master
• From conda
  • Last released version: conda install -c conda-forge pyqtgraph
• To install system-wide from source distribution: python setup.py install
• Many linux package repositories have release versions.
• To use with a specific project, simply copy the PyQtGraph subdirectory anywhere that is importable from your project.

View on GitHub

12.  seaborn

Seaborn is a Python visualization library based on matplotlib. It provides a high-level interface for drawing attractive statistical graphics.

Installation

The latest stable release (and required dependencies) can be installed from PyPI:

pip install seaborn

It is also possible to include optional statistical dependencies (only relevant for v0.12+):

pip install seaborn[stats]

Seaborn can also be installed with conda:

conda install seaborn

Note that the main anaconda repository lags PyPI in adding new releases, but conda-forge (-c conda-forge) typically updates quickly.

Citing

A paper describing seaborn has been published in the Journal of Open Source Software. The paper provides an introduction to the key features of the library, and it can be used as a citation if seaborn proves integral to a scientific publication.

Testing

Testing seaborn requires installing additional dependencies; they can be installed with the dev extra (e.g., pip install .[dev]).

To test the code, run make test in the source directory. This will exercise the unit tests (using pytest) and generate a coverage report.

Code style is enforced with flake8 using the settings in the setup.cfg file. Run make lint to check. Alternately, you can use pre-commit to automatically run lint checks on any files you are committing: just run pre-commit install to set it up, and then commit as usual going forward.

View on GitHub

13.  VisPy

VisPy is a high-performance interactive 2D/3D data visualization library. VisPy leverages the computational power of modern Graphics Processing Units (GPUs) through the OpenGL library to display very large datasets. Applications of VisPy include:

• High-quality interactive scientific plots with millions of points.
• Direct visualization of real-time data.
• Fast interactive visualization of 3D models (meshes, volume rendering).
• OpenGL visualization demos.
• Scientific GUIs with fast, scalable visualization widgets (Qt or IPython notebook with WebGL).

Using VisPy

VisPy is a young library under heavy development at this time. It targets two categories of users:

1. Users knowing OpenGL, or willing to learn OpenGL, who want to create beautiful and fast interactive 2D/3D visualizations in Python as easily as possible.
2. Scientists without any knowledge of OpenGL, who are seeking a high-level, high-performance plotting toolkit.

If you're in the first category, you can already start using VisPy. VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL ES 2.0 called gloo. You can focus on writing your GLSL code instead of dealing with the complicated OpenGL API - VisPy takes care of that automatically for you.

If you're in the second category, we're starting to build experimental high-level plotting interfaces. Notably, VisPy now ships a very basic and experimental OpenGL backend for matplotlib.

Installation

Please follow the detailed installation instructions on the VisPy website.

View on GitHub

Frequently asked questions about Data Visualization python

• Why we use data visualization in Python?

Data visualization provides a good, organized pictorial representation of the data which makes it easier to understand, observe, analyze. In this tutorial, we will discuss how to visualize data using Python. Python provides various libraries that come with different features for visualizing data.

• What is meant by data visualization?

Data visualization is the graphical representation of information and data. By using visual elements like charts, graphs, and maps, data visualization tools provide an accessible way to see and understand trends, outliers, and patterns in data.

• Is Python good for data visualization?

Python today is one of the most popular simple universal languages for data visualization and even more. It is often the best choice for solving problems in Machine Learning, Deep Learning, Artificial Intelligence, and so on. It is object-oriented, easy to use, and developer-friendly due to its highly readable code.

• Why is data visualization important?

Data visualization allows business users to gain insight into their vast amounts of data. It benefits them to recognize new patterns and errors in the data. Making sense of these patterns helps the users pay attention to areas that indicate red flags or progress. This process, in turn, drives the business ahead.

Related videos:

Introduction To Data Analysis Using Python | Data Analysis And Visualization With python

Related posts:

• Step-by-step guide to Data Visualizations in Python
• 5 Quick and Easy Data Visualizations in Python with Code
• Data Visualization in Python using matplotlib Tutorial
• Data Visualization in Python using Plotly
• Data Visualization with Python Seaborn and Pandas

#python #datavisualizations 

Ad3lie: Create Responsive and Elegant Data Visualizations with React

ad3lie

ad3lie is an open-source application and package for creating elegant and responsive data visualizations built with React and D3.

The focus of this application is to generate user customized charts that can be used in any React project.

Installation

Download ad3lie Application

Begin by downloading the app from our website.

After opening the app, choose which graph to create. Don't worry, if you decide to chose another graph, simply click on the home button and choose another graph from the home page. All of your input data will be saved for the duration of the application's life span.

Input the required fields (i.e. Data, xKey, and yKey) and adjust the graph based on the inputs given

Click the export button and select the file directory of your project for both the data file and React component.

Install ad3lie Package

Downloading ad3lie will include other necessary dependencies in order to generate your data visualizations. This allows for the use of the React component exported from the ad3lie application.

Simply download the npm package

npm i ad3lie

OR

yarn add ad3lie

From here, import the React component as a child component.

import Chart from "./file/path/to/component"

From here, simply use the componet as you would any other child component in your React app.

Happy visualizing! <|^o^|>

Documentation

For more detailed information, please check the related package documentation or go directly to our npm package.

How to Setup React App

Make sure to install these npm packages

npm i d3
npm i postcss
npm i postcss-loader
npm i autoprefixer

tailwind.config.js

module.exports = {
  content: ["./client/src/**/*.{html,js}"],
  theme: {
    extend: {},
  },
  plugins: [],
}

webpack.config.js

const path = require('path');
const HtmlWebpackPlugin = require('html-webpack-plugin');

module.exports = (env) => {
  return {
    mode: env.mode,
    entry: './client/src/index.js',
    output: {
      path: path.resolve(__dirname, 'client', 'build'),
      filename: 'bundle.js'
    },
    module: {
      rules: [{
        test: /\.jsx?/, 
        use: {
          loader: 'babel-loader',
          options: {
            presets: ['@babel/preset-env', 
            '@babel/preset-react'],
             targets: {chrome: "100"}
            
          }
        }
      },
      {
        test: /.+\.css$/i,
        // exclude: /node_modules/,
        use: [
          'style-loader', 
          'css-loader', 
           {
             loader: 'postcss-loader',
             options: {
               postcssOptions: {
                 plugins: {
                  tailwindcss: {},
                  autoprefixer: {},
                }
               }
             }
           }
          ]
      }
    ]
    },
    resolve: {
      extensions: ['', '.js', '.jsx'],
      alias: {
        'react': path.resolve(__dirname, 'node_modules/react'),
      }
    },
    
    plugins: [new HtmlWebpackPlugin({
      template: './client/src/index.html'
    })],
    devServer: {
      static: './client/build',
      port: 8888
    }
  }
}

Checkout our website to see incoming features, how to get involved, and meet our team!

Author: oslabs-beta
Source code: https://github.com/oslabs-beta/ad3lie
License: MIT license
#react #typescript #javascript  #datavisualizations 

Julia Programming: Data Visualizations with Makie.jl

Interactive data visualizations with Makie.jl

Makie.jl is a Julia-native interactive data visualization library. In this workshop, participants will learn how to create complex interactive and static plots, using the full range of tools Makie has to offer. Topics could include writing custom recipes, understanding the scene graph, mastering the layout system, handling complex observable structures and tweaking visual styles. The workshop will also be an opportunity to learn about the architecture and underlying ideas of Makie.

#julia #datavisualizations

Data Visualizations Tutorial | Web App Dashboards with Python & Dash

Learn how to use Python and Dash library to create, style, and host an interactive data analysis web application.

If not long ago the creation of analytical web applications required knowledge of several programming languages, today you can create a data visualization interface in pure Python. One popular tool for this has become Dash, which allows data scientists to display results in interactive web applications.

In this guide, we’ll cover:

• How to create a Dash app
• Main library components
• How to customize the app style
• How to make an application interactive
• How to deploy an application to a remote server (using Heroku as an example)

What is Dash?

Dash is an open-source framework for building data visualization interfaces. After being released in 2017 as a Python library, Dash was soon extended for R and Julia.

The library was created and maintained by a Canadian company called Plotly. Perhaps you know about her from the popular graphics libraries that bear her name. Plotly opened source Dash and released it under the MIT license, so the library is free to use.

Dash is based on and integrates three frameworks:

1. Flask provides web server functionality.
2. React renders the web interface.
3. Plotly.js generates charts.

You don’t have to worry about these technologies working together. You just need to write the code in Python, R, or Julia and add some CSS.

If you are used to analyzing data using Python, Dash is a useful addition to your toolbox. Here are some practical examples of the library’s capabilities:

• A dashboard for analyzing trading positions in real-time.
• Visualization of millions of Uber rides.
• Interactive financial report.

Setting up a virtual environment

To develop your application, you need a directory to store your code and data, as well as a clean Python 3 virtual environment. To create them, follow the instructions for your operating system.

Windows. Open a command prompt and run the following commands:

mkdir avocado_analytics && cd avocado_analytics
python -m venv venv venv\Scripts\activate.bat

The first command will create a project directory and change the current working directory. The second command will create the virtual environment, and the last command will activate it. You may need to specify a file path to python.exe instead of a command python .

MacOS or Linux. The meaning of the following terminal commands is identical to those for Windows:

mkdir avocado_analytics && cd avocado_analytics
python3 -m venv venv source venv/bin/activate

Next, you need to install the following libraries into the virtual environment:

python -m pip install dash==1.13.3 pandas==1.0.5

The Dash and pandas libraries will be installed in the virtual environment. The virtual environment allows the use of specific versions of the libraries, similar to those used in this tutorial.

Finally, you will need some data that can be downloaded from the accompanying lesson materials.

Save the data file in the root directory of the project. By now, you should have a virtual environment with the required libraries and data in the project root folder. The project structure looks like this: avocado.csv

avocado_analytics/
├── venv/
└── avocado.csv

How to create an app with Dash

Let’s break down the process of creating a Dash application into two steps:

1. We initialize the application and define the appearance using the application layout ( layout).
2. We determine through callbacks ( callbacks) which parts of the application are interactive and what they react to.

Initializing the Dash Application

First, let’s create an empty file called app.py. Next, we will fill it out step by step and explain what is happening, and at the end of the section, you will find its entire contents.

Here are the first few lines of app.py:

import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd

data = pd.read_csv("avocado.csv")
data = data.query("type == 'conventional' and region == 'Albany'")
data["Date"] = pd.to_datetime(data["Date"], format="%Y-%m-%d")
data.sort_values("Date", inplace=True)

app = dash.Dash(__name__)

First, we import the required libraries:

• dash will help initialize the application
• dash_core_components allows you to create interactive components: charts, drop-down lists, date ranges, etc.
• dash_html_components allows you to access HTML tags
• pandas helps to read and display data in an organized manner

Next, we read the data and process it for use in the control panel. On the last line, we create an instance of the Dash class.

If you’ve used Flask before, then the initialization of the Dash class is already familiar to you. In Flask, we usually initialize a WSGI (short for Web Server Gateway Interface) application with Flask(__name__). For Dash apps, we use Dash(__name__).

Defining the Dash Application Layout

Now we will define the layout of the application, its appearance. In our case, the layout will consist of a title, description and two diagrams.

app.layout = html.Div(
    children=[
        html.H1(children="Avocado Analytics",),
        html.P(
            children="Analyze the behavior of avocado prices"
            " and the number of avocados sold in the US"
            " between 2015 and 2018",
        ),
        dcc.Graph(
            figure={
                "data": [
                    {
                        "x": data["Date"],
                        "y": data["AveragePrice"],
                        "type": "lines",
                    },
                ],
                "layout": {"title": "Average Price of Avocados"},
            },
        ),
        dcc.Graph(
            figure={
                "data": [
                    {
                        "x": data["Date"],
                        "y": data["Total Volume"],
                        "type": "lines",
                    },
                ],
                "layout": {"title": "Avocados Sold"},
            },
        ),
    ]
)

Well, let’s go step-by-step what’s going on here.

This code defines layout property of app object . The appearance of the application is described using a tree structure consisting of Dash components.

We start by defining the parent component html.Div, then add a heading html.H1and paragraph html.Pas children. These components are equivalent to HTML tags div, h1and p accordingly. Component arguments are used to change the attributes or content of tags. For example, to indicate what is inside a div tag , we use in html.Div an argument children.

Components also have other arguments, such as style, className or id that refer to attributes of HTML tags. In the next section, we’ll see how to use these properties to style the toolbar.

Thus, the Python code will be converted to the following HTML code:

<div>
  <h1>Avocado Analytics</h1>
  <p>
    Analyze the behavior of avocado prices and the number
    of avocados sold in the US between 2015 and 2018
  </p>
  <!-- The rest of the app -->
</div>

Next two components of dcc.Graph are described below. The first chart displays the average avocado prices over the study period, and the second shows the number of avocados sold in the US during the same period.

Under the hood, Dash uses Plotly.js to create graphs. The dcc.Graph components expect a figure object or a Python dictionary containing the graph data and layout that we are passing in our case.

There are two lines of code left to help launch the application:

if __name__ == "__main__":
    app.run_server(debug=True,
                   host = '127.0.0.1')

These lines allow you to run your Dash application locally using Flask’s built-in server. The debug = Trueparameter from app.run_server allows hot reloads: when we make changes to the application, it automatically reloads without restarting the server.

Finally, the full version of app.py. You can copy the code to blank app.py and check the result.

import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd

data = pd.read_csv("avocado.csv")
data = data.query("type == 'conventional' and region == 'Albany'")
data["Date"] = pd.to_datetime(data["Date"], format="%Y-%m-%d")
data.sort_values("Date", inplace=True)

app = dash.Dash(__name__)

app.layout = html.Div(
    children=[
        html.H1(children="Avocado Analytics",),
        html.P(
            children="Analyze the behavior of avocado prices"
            " and the number of avocados sold in the US"
            " between 2015 and 2018",
        ),
        dcc.Graph(
            figure={
                "data": [
                    {
                        "x": data["Date"],
                        "y": data["AveragePrice"],
                        "type": "lines",
                    },
                ],
                "layout": {"title": "Average Price of Avocados"},
            },
        ),
        dcc.Graph(
            figure={
                "data": [
                    {
                        "x": data["Date"],
                        "y": data["Total Volume"],
                        "type": "lines",
                    },
                ],
                "layout": {"title": "Avocados Sold"},
            },
        ),
    ]
)

if __name__ == "__main__":
    app.run_server(debug=True,
                   host = '127.0.0.1')

It’s time to finally ✨launch the application ✨.

Open a terminal in the project root and in the virtual project environment. Run python app.py, then go to the address http://localhost:8050in your browser.

The control panel should look something like this:

We now have a working version, but we will improve it further.

🌟Controlling panel appearance

The reason why I liked Dash is that it becomes very flexible in customizing the look and feel of your application. We can use our own CSS or JavaScript files, embed images, and configure additional options.

How to style Dash components

You can style components in two separate ways:

• Use a style argument of distinct components.
• Provide an external CSS file.

The style argument takes a Python dictionary with key-value pairs consisting of the CSS property names and the values ​​we want to set.

When we want to change the size and color of the H1 element in app.py, we can set the style argument like this:

html.H1(
    children="Avocado Analytics",
    style={"fontSize": "48px", "color": "red"},
),

In this case, the title will be formatted in 48 pixels.

The downside to ease of use styleis that code like this will become more difficult to maintain as the codebase grows. If there are several of the same components on the control panel, most of the code will be repeated. You can use a CSS file instead.

If you want to include your own local CSS or JavaScript files, you must create a folder named assets/ in the root directory of the project and save the necessary files in it.

You can then use the className arguments or id of components to style them using CSS. When converted to HTML tags, these arguments match the class and id attributes .

When we want to customize the font size and text color of an H1 element in app.py, we can use an className argument:

html.H1(
    children="Avocado Analytics",
    className="header-title",
),

Setting the argument specifies the className class attribute for the H1element. Then, in the CSS file (style.css) in the assets/ folder, we specify how we want it to look:

.header-title {
  font-size: 48px;
  color: red;
}

How to improve the toolbar appearance

Let’s find out how to customize the appearance of the toolbar. Let’s make the following improvements:

• Add the site icon ( favicon) and title.
• Let’s change the font family.
• We use an external CSS file to style the Dash components.

Adding external resources to the application

Let’s create assets/folder in the root of the project. Save the favicon.ico icon and the style.css.

By now, the project structure should look like this:

avocado_analytics/
├── assets/
│   ├── favicon.ico
│   └── style.css
├── venv/
├── app.py
└── avocado.csv

app.py requires several changes. You need to include an external style sheet, add a title to the toolbar, and style the components using the style.cssfile:

external_stylesheets = [
    {
        "href": "https://fonts.googleapis.com/css2?"
                "family=Lato:wght@400;700&display=swap",
        "rel": "stylesheet",
    },
]
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.title = "Avocado Analytics: Understand Your Avocados!"

Here we specify the CSS file and font family that we want to load into the application. External files are loaded before the application body is loaded. The external_stylesheets argument is used to add external CSS files, and external_scripts is used for external JavaScript files such as a Google Analytics script.

Customizing component styles

In the code below, we add className with the appropriate class selector to each of the components representing the title of the dashboard:

app.layout = html.Div(
    children=[
        html.Div(
            children=[
                html.P(children="🥑", className="header-emoji"),
                html.H1(
                    children="Avocado Analytics", className="header-title"
                ),
                html.P(
                    children="Analyze the behavior of avocado prices"
                    " and the number of avocados sold in the US"
                    " between 2015 and 2018",
                    className="header-description",
                ),
            ],
            className="header",
        ),

The header-description class assigned to the paragraph component has a matching selector in style.css:

.header-description {
    color: #CFCFCF;
    margin: 4px auto;
    text-align: center;
    max-width: 384px;
}

Another significant change is the graphics. New code for the price chart:

html.Div(
    children=[
        html.Div(
            children=dcc.Graph(
                id="price-chart",
                config={"displayModeBar": False},
                figure={
                    "data": [
                        {
                            "x": data["Date"],
                            "y": data["AveragePrice"],
                            "type": "lines",
                            "hovertemplate": "$%{y:.2f}"
                                                "<extra></extra>",
                        },
                    ],
                    "layout": {
                        "title": {
                            "text": "Average Price of Avocados",
                            "x": 0.05,
                            "xanchor": "left",
                        },
                        "xaxis": {"fixedrange": True},
                        "yaxis": {
                            "tickprefix": "$",
                            "fixedrange": True,
                        },
                        "colorway": ["#17B897"],
                    },
                },
            ),
            className="card",
        ),

We removed the default bar that appears on the chart and set the hover pattern so that when you hover over the data point, the price is displayed in dollars. So $2.5 will be displayed instead of 2.5.

We also set up the axis, the color of the picture, the format of the title in the section of the chart layout. We also wrapped the schedule in html.Div with the class card class. This will give the graphic a white background and add a little shadow underneath. Similar changes have been made to the sales and volume schedules. Here is the complete code of the updated app.py:

import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
data = pd.read_csv("avocado.csv")
data = data.query("type == 'conventional' and region == 'Albany'")
data["Date"] = pd.to_datetime(data["Date"], format="%Y-%m-%d")
data.sort_values("Date", inplace=True)
external_stylesheets = [
    {
        "href": "https://fonts.googleapis.com/css2?"
        "family=Lato:wght@400;700&display=swap",
        "rel": "stylesheet",
    },
]
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.title = "Avocado Analytics: Understand Your Avocados!"
app.layout = html.Div(
    children=[
        html.Div(
            children=[
                html.P(children="🥑", className="header-emoji"),
                html.H1(
                    children="Avocado Analytics", className="header-title"
                ),
                html.P(
                    children="Analyze the behavior of avocado prices"
                    " and the number of avocados sold in the US"
                    " between 2015 and 2018",
                    className="header-description",
                ),
            ],
            className="header",
        ),
        html.Div(
            children=[
                html.Div(
                    children=dcc.Graph(
                        id="price-chart",
                        config={"displayModeBar": False},
                        figure={
                            "data": [
                                {
                                    "x": data["Date"],
                                    "y": data["AveragePrice"],
                                    "type": "lines",
                                    "hovertemplate": "$%{y:.2f}"
                                                     "<extra></extra>",
                                },
                            ],
                            "layout": {
                                "title": {
                                    "text": "Average Price of Avocados",
                                    "x": 0.05,
                                    "xanchor": "left",
                                },
                                "xaxis": {"fixedrange": True},
                                "yaxis": {
                                    "tickprefix": "$",
                                    "fixedrange": True,
                                },
                                "colorway": ["#17B897"],
                            },
                        },
                    ),
                    className="card",
                ),
                html.Div(
                    children=dcc.Graph(
                        id="volume-chart",
                        config={"displayModeBar": False},
                        figure={
                            "data": [
                                {
                                    "x": data["Date"],
                                    "y": data["Total Volume"],
                                    "type": "lines",
                                },
                            ],
                            "layout": {
                                "title": {
                                    "text": "Avocados Sold",
                                    "x": 0.05,
                                    "xanchor": "left",
                                },
                                "xaxis": {"fixedrange": True},
                                "yaxis": {"fixedrange": True},
                                "colorway": ["#E12D39"],
                            },
                        },
                    ),
                    className="card",
                ),
            ],
            className="wrapper",
        ),
    ]
)
if __name__ == "__main__":
    app.run_server(debug=True)

The panel of the updated version looks like this: app.py

Adding interactive elements to your Dash application

Dash’s interactivity is based on the paradigm of reactive programming. This means that we can link the components and elements of the application that we want to update. If the user interacts with an input component, such as a drop-down list or slider, then the data output object, such as a graph, will automatically respond to input changes.

Let’s make the control panel interactive. The new version will allow the user to interact with the following filters:

• Production region.
• Avocado type.
• Date range.

Let’s start by replacing the local version of app.pywith the new version:

import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
import numpy as np
from dash.dependencies import Output, Input

data = pd.read_csv("avocado.csv")
data["Date"] = pd.to_datetime(data["Date"], format="%Y-%m-%d")
data.sort_values("Date", inplace=True)

external_stylesheets = [
    {
        "href": "https://fonts.googleapis.com/css2?"
        "family=Lato:wght@400;700&display=swap",
        "rel": "stylesheet",
    },
]
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.title = "Avocado Analytics: Understand Your Avocados!"

app.layout = html.Div(
    children=[
        html.Div(
            children=[
                html.P(children="🥑", className="header-emoji"),
                html.H1(
                    children="Avocado Analytics", className="header-title"
                ),
                html.P(
                    children="Analyze the behavior of avocado prices"
                    " and the number of avocados sold in the US"
                    " between 2015 and 2018",
                    className="header-description",
                ),
            ],
            className="header",
        ),
        html.Div(
            children=[
                html.Div(
                    children=[
                        html.Div(children="Region", className="menu-title"),
                        dcc.Dropdown(
                            id="region-filter",
                            options=[
                                {"label": region, "value": region}
                                for region in np.sort(data.region.unique())
                            ],
                            value="Albany",
                            clearable=False,
                            className="dropdown",
                        ),
                    ]
                ),
                html.Div(
                    children=[
                        html.Div(children="Type", className="menu-title"),
                        dcc.Dropdown(
                            id="type-filter",
                            options=[
                                {"label": avocado_type, "value": avocado_type}
                                for avocado_type in data.type.unique()
                            ],
                            value="organic",
                            clearable=False,
                            searchable=False,
                            className="dropdown",
                        ),
                    ],
                ),
                html.Div(
                    children=[
                        html.Div(
                            children="Date Range",
                            className="menu-title"
                            ),
                        dcc.DatePickerRange(
                            id="date-range",
                            min_date_allowed=data.Date.min().date(),
                            max_date_allowed=data.Date.max().date(),
                            start_date=data.Date.min().date(),
                            end_date=data.Date.max().date(),
                        ),
                    ]
                ),
            ],
            className="menu",
        ),
        html.Div(
            children=[
                html.Div(
                    children=dcc.Graph(
                        id="price-chart", config={"displayModeBar": False},
                    ),
                    className="card",
                ),
                html.Div(
                    children=dcc.Graph(
                        id="volume-chart", config={"displayModeBar": False},
                    ),
                    className="card",
                ),
            ],
            className="wrapper",
        ),
    ]
)


@app.callback(
    [Output("price-chart", "figure"), Output("volume-chart", "figure")],
    [
        Input("region-filter", "value"),
        Input("type-filter", "value"),
        Input("date-range", "start_date"),
        Input("date-range", "end_date"),
    ],
)
def update_charts(region, avocado_type, start_date, end_date):
    mask = (
        (data.region == region)
        & (data.type == avocado_type)
        & (data.Date >= start_date)
        & (data.Date <= end_date)
    )
    filtered_data = data.loc[mask, :]
    price_chart_figure = {
        "data": [
            {
                "x": filtered_data["Date"],
                "y": filtered_data["AveragePrice"],
                "type": "lines",
                "hovertemplate": "$%{y:.2f}<extra></extra>",
            },
        ],
        "layout": {
            "title": {
                "text": "Average Price of Avocados",
                "x": 0.05,
                "xanchor": "left",
            },
            "xaxis": {"fixedrange": True},
            "yaxis": {"tickprefix": "$", "fixedrange": True},
            "colorway": ["#17B897"],
        },
    }

    volume_chart_figure = {
        "data": [
            {
                "x": filtered_data["Date"],
                "y": filtered_data["Total Volume"],
                "type": "lines",
            },
        ],
        "layout": {
            "title": {"text": "Avocados Sold", "x": 0.05, "xanchor": "left"},
            "xaxis": {"fixedrange": True},
            "yaxis": {"fixedrange": True},
            "colorway": ["#E12D39"],
        },
    }
    return price_chart_figure, volume_chart_figure


if __name__ == "__main__":
    app.run_server(debug=True,
                   host='127.0.0.1')

Then you need to update style.css with the following code:

body {
    font-family: "Lato", sans-serif;
    margin: 0;
    background-color: #F7F7F7;
}

.header {
    background-color: #222222;
    height: 288px;
    padding: 16px 0 0 0;
}

.header-emoji {
    font-size: 48px;
    margin: 0 auto;
    text-align: center;
}

.header-title {
    color: #FFFFFF;
    font-size: 48px;
    font-weight: bold;
    text-align: center;
    margin: 0 auto;
}

.header-description {
    color: #CFCFCF;
    margin: 4px auto;
    text-align: center;
    max-width: 384px;
}

.wrapper {
    margin-right: auto;
    margin-left: auto;
    max-width: 1024px;
    padding-right: 10px;
    padding-left: 10px;
    margin-top: 32px;
}

.card {
    margin-bottom: 24px;
    box-shadow: 0 4px 6px 0 rgba(0, 0, 0, 0.18);
}

.menu {
    height: 112px;
    width: 912px;
    display: flex;
    justify-content: space-evenly;
    padding-top: 24px;
    margin: -80px auto 0 auto;
    background-color: #FFFFFF;
    box-shadow: 0 4px 6px 0 rgba(0, 0, 0, 0.18);
}

.Select-control {
    width: 256px;
    height: 48px;
}

.Select--single > .Select-control .Select-value, .Select-placeholder {
    line-height: 48px;
}

.Select--multi .Select-value-label {
    line-height: 32px;
}

.menu-title {
    margin-bottom: 6px;
    font-weight: bold;
    color: #079A82;
}

How to create interactive components

New html.Div above charts includes two dropdowns and a date range selector that the user can use to filter data and update charts.

This is how it looks in app.py:

html.Div(
    children=[
        html.Div(
            children=[
                html.Div(children="Region", className="menu-title"),
                dcc.Dropdown(
                    id="region-filter",
                    options=[
                        {"label": region, "value": region}
                        for region in np.sort(data.region.unique())
                    ],
                    value="Albany",
                    clearable=False,
                    className="dropdown",
                ),
            ]
        ),
        html.Div(
            children=[
                html.Div(children="Type", className="menu-title"),
                dcc.Dropdown(
                    id="type-filter",
                    options=[
                        {"label": avocado_type, "value": avocado_type}
                        for avocado_type in data.type.unique()
                    ],
                    value="organic",
                    clearable=False,
                    searchable=False,
                    className="dropdown",
                ),
            ],
        ),
        html.Div(
            children=[
                html.Div(
                    children="Date Range",
                    className="menu-title"
                    ),
                dcc.DatePickerRange(
                    id="date-range",
                    min_date_allowed=data.Date.min().date(),
                    max_date_allowed=data.Date.max().date(),
                    start_date=data.Date.min().date(),
                    end_date=data.Date.max().date(),
                ),
            ]
        ),
    ],
    className="menu",
),

The drop-down lists and date range selector serve as menus for interacting with the data:

The first component in the menu is the Region dropdown. Component code:

html.Div(
    children=[
        html.Div(children="Region", className="menu-title"),
        dcc.Dropdown(
            id="region-filter",
            options=[
                {"label": region, "value": region}
                for region in np.sort(data.region.unique())
            ],
            value="Albany",
            clearable=False,
            className="dropdown",
        ),
    ]
),

Here’s what each parameter means:

• id - element identifier.
• options - options displayed when selecting the dropdown list. Waits for a dictionary with labels and values.
• value - the default value when loading the page.
• clearable - Allows the user to leave the field blank if set True.
• className - class selector used to apply styles

The Type and Data Range selectors have the same structure as the Region drop-down menu.

Now let’s take a look at the components of dcc.Graphs:

html.Div(
    children=[
        html.Div(
            children=dcc.Graph(
                id="price-chart", config={"displayModeBar": False},
            ),
            className="card",
        ),
        html.Div(
            children=dcc.Graph(
                id="volume-chart", config={"displayModeBar": False},
            ),
            className="card",
        ),
    ],
    className="wrapper",
),

Components lack figureargument compared to the previous version of the figuretoolbar. This is because the argument will now be generated by the callback function using the input that the user sets with the Region, Type, and Data Range selectors.

💬How to define callbacks

We have defined how the user will interact with the application. Now we need to make the application respond to user actions. For this we will use the callback functions ( callbacks).

Dash callback functions are regular Python functions with a decorator called app.callback.

When the input changes, a callback function runs, performs predefined operations (such as filtering a dataset), and returns the result to the application. Basically, callbacks bind input and output data in an application.

Here is the callback function used to update the graphs:

@app.callback(
    [Output("price-chart", "figure"), Output("volume-chart", "figure")],
    [
        Input("region-filter", "value"),
        Input("type-filter", "value"),
        Input("date-range", "start_date"),
        Input("date-range", "end_date"),
    ],
)
def update_charts(region, avocado_type, start_date, end_date):
    mask = (
        (data.region == region)
        & (data.type == avocado_type)
        & (data.Date >= start_date)
        & (data.Date <= end_date)
    )
    filtered_data = data.loc[mask, :]
    price_chart_figure = {
        "data": [
            {
                "x": filtered_data["Date"],
                "y": filtered_data["AveragePrice"],
                "type": "lines",
                "hovertemplate": "$%{y:.2f}<extra></extra>",
            },
        ],
        "layout": {
            "title": {
                "text": "Average Price of Avocados",
                "x": 0.05,
                "xanchor": "left",
            },
            "xaxis": {"fixedrange": True},
            "yaxis": {"tickprefix": "$", "fixedrange": True},
            "colorway": ["#17B897"],
        },
    }

    volume_chart_figure = {
        "data": [
            {
                "x": filtered_data["Date"],
                "y": filtered_data["Total Volume"],
                "type": "lines",
            },
        ],
        "layout": {
            "title": {
                "text": "Avocados Sold",
                "x": 0.05,
                "xanchor": "left"
            },
            "xaxis": {"fixedrange": True},
            "yaxis": {"fixedrange": True},
            "colorway": ["#E12D39"],
        },
    }
    return price_chart_figure, volume_chart_figure

First, we define the output using Output objects. These objects take two arguments:

• The identifier of the element that they will change when they execute the function.
• Property of the item being changed. For example, Output("price-chart", "figure") update the figure property of the "price-chart" item.

Then we define the inputs using Input objects, they also take two arguments:

• The ID of the item that they will watch for changes.
• The property of the observed element that they should accept when a change occurs.

That is Input("region-filter", "value"), it will monitor the "region-filter"element’s changes and will accept its property if the element changes.

Note

The object discussed here is Input imported from dash.dependencies. Do not confuse it with a component coming from dash_core_components. These objects are not interchangeable and have different purposes.

In the last lines of the above block, we define the body of the function. In the above example, the function takes input (region, avocado type, and date range), filters it, and generates objects for price and volume charts.

This is the latest version of our toolbar. We made it not only beautiful but also interactive. The only missing step is to make the result shareable with others.

Deploying a Dash application on Heroku

We have finished building the application. We have a beautiful, fully interactive dashboard. Now we will learn how to deploy it.

In fact, Dash apps are the same as Flask apps, so they have the same deployment capabilities. In this section, we will deploy the application to Heroku hosting (with a free plan).

Before starting, make sure you have installed the Heroku Command Line Interface (CLI) and Git. To make sure that both programs are present on the system, run the version check commands in the terminal:

git --version
heroku --version

Next, we need to make a small change to app.py. After initializing the application, add a variable named server:

app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
server = app.server

This add-on is required to run the application using a WSGI server. The built-in Flask server is not recommended for use in a production environment as it cannot handle a lot of traffic.

In the root directory of the project, create a file with a name in which we specify the Python version for the Heroku application: runtime.txt

python-3.8.6

When deployed, Heroku will automatically detect that this is a Python application and use the appropriate build package. If you provide the runtime.txt file as well, the server will determine the Python version that the application will use.

Then, in the root directory of the project, create requirements.txt file where we list the libraries required to install the Dash application on the web server:

dash==1.13.3
pandas==1.0.5
gunicorn==20.0.4

In the requirements.txt file there is a gunicornpackage, which we have not mentioned before. Gunicorn is basically a HTTP server that is often used to deploy Flask applications in a production environment.

Now let’s create a file named Procfile with the following content:

web: gunicorn app:server

This file tells the Heroku application what commands to run to launch our application.

Then you need to initialize the Git repository. To do this, go to the root directory of the project and run the following command:

git init

This command will initiate the creation of a Git repository for avocado_analytics/. That is, Git will keep track of the changes we make to files in that directory.

However, there are files that are not worth tracking with Git. For example, we usually do not want to track the contents of the virtual environment directory, bytecode files, and metadata files such as .DS_Store.

Create a file in the root directory named .gitignore and the following contents:

# Only if you are using macOS
venv *.pyc .DS_Store

This ensures that the repository does not track unnecessary files. Now let’s fix the state of the project:

git add . git commit -m 'Add dashboard files'

Make sure everything is in place before the last step. The project structure should look like this:

avocado_analytics/
├── assets/
│   ├── favicon.ico
│   └── style.css
├── venv/
├── app.py
├── avocado.csv
├── Procfile
├── requirements.txt
└── runtime.txt

Finally, you need to create an application in Heroku, upload your code there using Git, and run the application on one of the free Heroku server options. To do this, run the following commands:

heroku create APP-NAME  # Insert your app name instead of APP-NAME
git push heroku master
heroku ps:scale web=1

That’s it. We created and deployed a data dashboard. To access the application, just copy the link: https://APP-NAME.herokuapp.com/ and replace it with the name you defined in the previous step. APP-NAME

Conclusion

Congratulations! You have just created, configured and deployed your dashboard using Dash. We’ve gone from a simple dashboard to fully interactive and deployed on a remote server. With this knowledge, we can use Dash to create analytic applications that can be shared with colleagues and customers.

#webapp #dashboards #python #dash #datavisualizations

Bokeh: Interactive Data Visualization In The Browser, From Python

Bokeh is an interactive visualization library for modern web browsers. It provides elegant, concise construction of versatile graphics, and affords high-performance interactivity over large or streaming datasets. Bokeh can help anyone who would like to quickly and easily make interactive plots, dashboards, and data applications.

Latest Release		Downloads
License		People
Sponsorship		Live Tutorial
Build Status		Static Analysis
Support		Twitter

If you like Bokeh and would like to support our mission, please consider making a donation.

Installation

The easiest way to install Bokeh is using the Anaconda Python distribution and its included Conda package management system. To install Bokeh and its required dependencies, enter the following command at a Bash or Windows command prompt:

conda install bokeh

To install using pip, enter the following command at a Bash or Windows command prompt:

pip install bokeh

For more information, refer to the installation documentation.

Resources

Once Bokeh is installed, check out the first steps guides.

Visit the full documentation site to view the User's Guide or launch the Bokeh tutorial to learn about Bokeh in live Jupyter Notebooks.

Community support is available on the Project Discourse.

If you would like to contribute to Bokeh, please review the Contributor Guide and request an invitation to the Bokeh Dev Slack workspace.

Note: Everyone interacting in the Bokeh project's codebases, issue trackers and discussion forums is expected to follow the Code of Conduct.

Follow us

Follow us on Twitter @bokeh

Support

Fiscal Support

The Bokeh project is grateful for individual contributions sponsorship as well as support by the organizations and companies below:

If your company uses Bokeh and is able to sponsor the project, please contact info@bokeh.org

Bokeh is a Sponsored Project of NumFOCUS, a 501(c)(3) nonprofit charity in the United States. NumFOCUS provides Bokeh with fiscal, legal, and administrative support to help ensure the health and sustainability of the project. Visit numfocus.org for more information.

Donations to Bokeh are managed by NumFOCUS. For donors in the United States, your gift is tax-deductible to the extent provided by law. As with any donation, you should consult with your tax adviser about your particular tax situation.

In-kind Support

The Bokeh project is grateful for the donation of services supporting our collaboration, infrastructure, security, and vulnerability management from the following companies:

• Amazon Web Services
• GitGuardian
• GitHub
• Pentest Tools
• Pingdom
• Slack
• QuestionScout
• 1Password

Author: bokeh
Source Code: https://github.com/bokeh/bokeh
License: BSD-3-Clause License

#python #datavisualizations #jupyter 

Data analytics: How to Use Complex Data Visualization

This video is part four in a five-part video series, where we take you from being a complete data novice to having a grasp of the fundamental terms, techniques, and day-to-day tasks that a data analyst would undertake in the real world.

In this video, you’ll be led through the fundamentals of data visualization, and how to craft a compelling narrative using complex data by CareerFoundry mentor Dr. Humera Noor Minhas, a professional data analyst with more than 20 years of experience in the field!

Interested in learning more about data analytics? We have a whole section dedicated to the profession, as well as career change opportunities for data analytics over on our blog: https://bit.ly/DataAnalyticsForBeginnersV4

Video Structure / Chapters:
(00:00) - Introduction 
(00:35) - What is data visualization
(01:00) - Key example of the importance of data visualization
(03:00) - A practical introduction to data visualization
(12:03) - Round up and outro

#datavisualizations #data 

Graphic: A Declarative, interactive Grammar Of Data Visualization

Graphic 

Graphic is a declarative, interactive grammar of data visualization. It provides a Flutter charting library.

• A Grammar of Graphics: Graphic derives from Leland Wilkinson's book The Grammar of Graphics, and tries to balance between theoretical beauty and practicability. It inherits most concepts, like the graphic algebra.
• Declarative and Reactive: As is encouraged in Flutter, the chart widget of Graphic is declarative and reactive. The grammar of data visualization is implemented by a declarative specification and the chart will reevaluate automatically on widget update.
• Interactive: With the signal and selection mechanism, the chart is highly interactive. It is easy to pop a tooltip or scale the coordinate.
• Customizable: With the shape and figure classes, it's easy to custom your own element, tooltip, annotation, etc.
• Dataflow Graph and Operators: Graphic has a internal structure of a dataflow graph and operators. That is how the reactive reevaluation and interaction is implemented.

Documentation

See in the documentation.

Examples

Example of charts can be seen in the Example App. Please clone this repository and run the example project in example directory.

Tutorials

The Versatility of the Grammar of Graphics

Reference

Besides The Grammar of Graphics, the API terminology also referes to AntV and Vega. The dataflow structure is inspired by Vega.

Keep Informed

Twitter

Medium

Zhihu

Author: Entronad
Source Code: https://github.com/entronad/graphic 
License: View license

#flutter #dart #datavisualizations 

Heatmap.js: JavaScript Library for HTML5 Canvas Based Heatmaps

heatmap.js

Dynamic Heatmaps for the Web.

How to get started

The fastest way to get started is to install heatmap.js with bower. Just run the following command:

bower install heatmap.js-amd

This will download the latest working version of heatmap.js and put it in your bower_components folder.

Alternatively you could just download the latest release from github and unzip it.

The file you're ultimately looking for is heatmap.js or heatmap.min.js

heatmap.js is also hosted on npm:

npm install heatmap.js

How to run the local examples

Start a webserver (e.g. python SimpleHTTPServer from the project directory root):

python -m SimpleHTTPServer 1337 &

Then browse to

http://localhost:1337/examples/

Get involved

Please have a look at the contribution guidelines before submitting contributions.

Disclaimer: PRs can take time to receive feedback or be merged ( I'm only one person with very little time ) but I'm trying to get back to everyone eventually

Questions?

In order to keep technical questions in a central place where other people can learn from it, the best thing you can do is post your question to stackoverflow with the tag heatmap.js.

If you do have a very specific question (or need commercial support) don't hesitate to contact me directly via email.

Mailing list

Want to receive the latest updates and news about heatmap.js?

There is a mailing list. No spam, just news and important updates.

Author: Pa7
Source Code: https://github.com/pa7/heatmap.js 
License: MIT License

#datavisualizations #javascript #angularjs 

Envisionjs: Dynamic HTML5 Visualization

Envision.js

Fast interactive HTML5 charts.

http://groups.google.com/group/envisionjs/

Features

• Modern Browsers, IE 6+
• Mobile / Touch Support
• Pre-built Templates
• Adaptable to Existing Libraries

Dependencies

Envision.js ships with all it's dependencies. It uses:

• underscore.js
• bean
• bonzo
• Flotr2

Usage

To use Envision.js, include envision.min.js and envision.min.css in your page. To display a visualization, either use a Template or create a custom visualization with the Envision.js API.

Templates

Templates are pre-built visualizations for common use-cases.

Example:

  var
    container = document.getElementById('container'),
    x = [],
    y1 = [],
    y2 = [],
    data, options, i;

  // Data Format:
  data = [
    [x, y1], // First Series
    [x, y2]  // Second Series
  ];

  // Sample the sine function for data
  for (i = 0; i < 4 * Math.PI; i += 0.05) {
    x.push(i);
    y1.push(Math.sin(i));
    y2.push(Math.sin(i + Math.PI));
  }

  // TimeSeries Template Options
  options = {
    // Container to render inside of
    container : container,
    // Data for detail (top chart) and summary (bottom chart)
    data : {
      detail : data,
      summary : data
    }
  };

  // Create the TimeSeries
  new envision.templates.TimeSeries(options);

Custom

Developers can use the envision APIs to build custom visualizations. The existing templates are a good reference for this.

Example:

  var
    container = document.getElementById('container'),
    x = [],
    y1 = [],
    y2 = [],
    data, i,
    detail, detailOptions,
    summary, summaryOptions,
    vis, selection,

  // Data Format:
  data = [
    [x, y1], // First Series
    [x, y2]  // Second Series
  ];

  // Sample the sine function for data
  for (i = 0; i < 4 * Math.PI; i += 0.05) {
    x.push(i);
    y1.push(Math.sin(i));
    y2.push(Math.sin(i + Math.PI));
  }
  x.push(4 * Math.PI)
  y1.push(Math.sin(4 * Math.PI));
  y2.push(Math.sin(4 * Math.PI));

  // Configuration for detail:
  detailOptions = {
    name : 'detail',
    data : data,
    height : 150,
    flotr : {
      yaxis : {
        min : -1.1,
        max : 1.1
      }
    }
  };

  // Configuration for summary:
  summaryOptions = {
    name : 'summary',
    data : data,
    height : 150,
    flotr : {
      yaxis : {
        min : -1.1,
        max : 1.1
      },
      selection : {
        mode : 'x'
      }
    }
  };

  // Building a custom vis:
  vis = new envision.Visualization();
  detail = new envision.Component(detailOptions);
  summary = new envision.Component(summaryOptions);
  interaction = new envision.Interaction();

  // Render Visualization
  vis
    .add(detail)
    .add(summary)
    .render(container);

  // Wireup Interaction
  interaction
    .leader(summary)
    .follower(detail)
    .add(envision.actions.selection);

API

Class envision.Component

Defines a visualization component.

Components are the building blocks of a visualization, representing one typically graphical piece of the vis. This class manages the options, DOM and API construction for an adapter which handles the actual drawing of the visualization piece.

Adapters can take the form of an actual object, a constructor function or a function returning an object. Only one of these will be used. If none is submitted, the default adapter Flotr2 is used.

Configuration:

An object is submitted to the constructor for configuration.

• name A name for the component.
• element A container element for the component.
• height An explicit component height.
• width An explicit component width.
• data An array of data. Data may be formatted for envision or for the adapter itself, in which case skipPreprocess will also need to be submitted.
• skipPreprocess Skip data preprocessing. This is useful when using the native data format for an adapter.
• adapter An adapter object.
• adapterConstructor An adapter constructor to be instantiated by the component.
• adapterCallback An callback invoked by the component returning an adapter.
• config Configuration for the adapter.

Methods:

render ([element])

Render the component.

If no element is submitted, the component will render in the element configured in the constructor.

draw ([data], [options])

Draw the component.

trigger ()

Trigger an event on the component's API.

Arguments are passed through to the API.

attach ()

Attach to an event on the component's API.

Arguments are passed through to the API.

detach ()

Detach a listener from an event on the component's API.

Arguments are passed through to the API.

destroy ()

Destroy the component.

Empties the container and calls the destroy method on the component's API.

Class envision.Visualization

Defines a visualization of componenents.

This class manages the rendering of a visualization. It provides convenience methods for adding, removing, and reordered components dynamically as well as convenience methods for working with a logical group of components.

Configuration:

An object is submitted to the constructor for configuration.

• name A name for the visualization.
• element A container element for the visualization.

Methods:

render ([element])

Render the visualization.

If no element is submitted, the visualization will render in the element configured in the constructor.

This method is chainable.

add (component)

Add a component to the visualization.

If the visualization has already been rendered, it will render the new component.

This method is chainable.

remove ()

Remove a component from the visualization.

This removes the components from the list of components in the visualization and removes its container from the DOM. It does not destroy the component.

This method is chainable.

setPosition (component, newIndex)

Reorders a component.

This method is chainable.

indexOf (component)

Gets the position of a component.

getComponent (component)

Gets the component at a position.

isFirst (component)

Gets whether or not the component is the first component in the visualization.

isLast (component)

Gets whether or not the component is the last component in the visualization.

destroy ()

Destroys the visualization.

This empties the container and destroys all the components which are part of the visualization.

Class envision.Preprocessor

Data preprocessor.

Data can be preprocessed before it is rendered by an adapter.

This has several important performance considerations. If data will be rendered repeatedly or on slower browsers, it will be faster after being optimized.

First, data outside the boundaries does not need to be rendered. Second, the resolution of the data only needs to be at most the number of pixels in the width of the visualization.

Performing these optimizations will limit memory overhead, important for garbage collection and performance on old browsers, as well as drawing overhead, important for mobile devices, old browsers and large data sets.

Configuration:

An object is submitted to the constructor for configuration.

• data The data for processing.

Methods:

getData ()

Returns data.

setData ()

Set the data object.

length ()

Returns the length of the data set.

bound (min, max)

Bounds the data set at within a range.

subsampleMinMax (resolution)

Subsample data using MinMax.

MinMax will display the extrema of the subsample intervals. This is slower than regular interval subsampling but necessary for data that is very non-homogenous.

subsample (resolution)

Subsample data at a regular interval for resolution.

This is the fastest subsampling and good for monotonic data and fairly homogenous data (not a lot of up and down).

Class envision.Interaction

Defines an interaction between components.

This class defines interactions in which actions are triggered by leader components and reacted to by follower components. These actions are defined as configurable mappings of trigger events and event consumers. It is up to the adapter to implement the triggers and consumers.

A component may be both a leader and a follower. A leader which is a follower will react to actions triggered by other leaders, but will safely not react to its own. This allows for groups of components to perform a common action.

Optionally, actions may be supplied with a callback executed before the action is consumed. This allows for quick custom functionality to be added and is how advanced data management (ie. live Ajax data) may be implemented.

This class follow an observer mediator pattern.

Configuration:

An object is submitted to the constructor for configuration.

• leader Component(s) to lead the interaction

Methods:

leader (component)

Add a component as an interaction leader.

follower (component)

Add a component as an interaction leader.

group (components)

Adds an array of components as both followers and leaders.

add (action, [options])

Adds an action to the interaction.

The action may be optionally configured with the options argument. Currently the accepts a callback member, invoked after an action is triggered and before it is consumed by followers.

Development

This project uses smoosh to build and jasmine with js-imagediff to test. Tests may be executed by jasmine-headless-webkit with cd spec; jasmine-headless-webkit -j jasmine.yml -c or by a browser by navigating to spec/SpecRunner.html.

Author: HumbleSoftware
Source Code: https://github.com/HumbleSoftware/envisionjs 
License: MIT License

#html #javascript #datavisualizations 

Multi-Dimensional Charting Built to Work Natively with D3.js

dc.js

Dimensional charting built to work natively with crossfilter rendered using d3.js. In dc.js, each chart displays an aggregation of some attributes through the position, size, and color of its elements, and also presents a dimension which can be filtered. When the filter or brush changes, all other charts are updated dynamically, using animated transitions.

Check out the example page and its annotated source for a quick five minute how-to guide. The detailed API reference is here (markdown version). For more examples and hints please visit the Wiki.

Support

• Example Site
• Changelog
• Frequently Asked Questions and Wiki
• v4.0 API Reference (markdown) (last - v3.1.9)
• dc.js on StackOverflow - ask questions and get help
• User Group ("mailing list") - discussion and longer topics
• GitHub Issues - bug reports and feature requests

Please direct questions and support requests to Stack Overflow or the user group. When posting to Stack Overflow, use the [dc.js] and/or [crossfilter] tags - other tags are likely to draw unwanted attention.

Get help faster with a working example! Fork these to get started:
blank jsFiddle - example jsFiddle - blank bl.ock - example bl.ock

Versioning

Version 4.* is compatible with d3 versions 4 and 5. It is not compatible with IE. Use dc.js 3.* if you need IE support, or use dc.js 2.* if you need compatibility with d3 version 3.

CDN location

https://unpkg.com/dc@4/dist/dc.js
https://unpkg.com/dc@4/dist/style/dc.css

or copy the latest links from CDNJS

Install with npm

npm install dc

Install without npm

Download

• d3.js
• crossfilter.js
• dc.js - stable
• dc.js - bleeding edge (develop)

How to build dc.js locally

Prerequisite modules

Make sure the following packages are installed on your machine

• node.js
• npm

Install dependencies

$ npm install

Build and Test

$ grunt test

Developing dc.js

Start the development server

$ grunt server

• Jasmine specs are hosted at http://localhost:8888/spec
• The stock example is at http://localhost:8888/web
• More examples are at http://localhost:8888/web/examples

Author: dc-js
Source Code: https://github.com/dc-js/dc.js 
License: View license

#datavisualizations #javascript