---
title: "Kotlin Notebook para Data Science: Guia Prático em 2026 | Kotlin Brasil"
url: "https://kotlin.dev.br/blog/kotlin-notebook-data-science-2026/"
markdown_url: "https://kotlin.dev.br/blog/kotlin-notebook-data-science-2026.MD"
description: "Aprenda a usar Kotlin Notebook para análise de dados com DataFrame e Kandy. Alternativa ao Jupyter com tipagem forte e IDE integrada."
date: "2026-04-10"
author: "Karina Melo"
---

# Kotlin Notebook para Data Science: Guia Prático em 2026 | Kotlin Brasil

Aprenda a usar Kotlin Notebook para análise de dados com DataFrame e Kandy. Alternativa ao Jupyter com tipagem forte e IDE integrada.


Se você trabalha com dados e sempre associou notebooks interativos ao Python e Jupyter, é hora de conhecer o **Kotlin Notebook**. Integrado ao IntelliJ IDEA e com suporte a bibliotecas poderosas como **DataFrame** e **Kandy**, o Kotlin Notebook está se consolidando como uma alternativa real para análise de dados — com a vantagem de tipagem estática e toda a expressividade do Kotlin.

Com as novidades de 2026 e palestras dedicadas na [KotlinConf 2026](https://kotlinconf.com/) e IntelliJ IDEA Conf, a ferramenta ganha cada vez mais atenção. Neste artigo, você vai aprender o que é, como funciona e como começar a usar na prática.

## O que é o Kotlin Notebook?

O **Kotlin Notebook** é um ambiente de desenvolvimento interativo baseado em células, integrado diretamente ao IntelliJ IDEA. Ele permite:

- **Executar código Kotlin** em células com resultado imediato
- **Misturar código, texto em Markdown e visualizações** no mesmo documento
- **Explorar dados** com feedback instantâneo
- **Exportar** como `.ipynb` (compatível com Jupyter)

O Kotlin Notebook é baseado no **Kotlin Kernel para Jupyter Notebooks**, o que garante compatibilidade com Jupyter, Datalore e outras ferramentas do ecossistema.

### Setup: zero configuração

A melhor parte? O plugin do Kotlin Notebook já vem **bundled e habilitado** no IntelliJ IDEA. Basta criar um novo arquivo `.ipynb` e começar a escrever código Kotlin. Não precisa instalar interpretadores Python, ambientes virtuais ou dependências externas.

## Carregando e explorando dados com DataFrame

A biblioteca [Kotlin DataFrame](https://kotlin.github.io/dataframe/) permite carregar, filtrar, transformar e analisar dados estruturados com uma API tipada e idiomática.

### Importando a dependência

Em uma célula do notebook, basta usar a anotação `%use`:

```kotlin
%use dataframe
```

### Lendo um arquivo CSV

```kotlin
val dados = DataFrame.read("vendas-2026.csv")
dados.head(5)
```

A saída aparece como uma tabela formatada diretamente no notebook, semelhante a um `pandas.DataFrame` no Python.

### Filtrando e transformando dados

```kotlin
// Filtrando vendas acima de R$ 1000
val vendasAltas = dados
    .filter { "valor"<Double>() > 1000.0 }
    .sortByDesc("valor")

vendasAltas.head(10)
```

### Agrupando e agregando

```kotlin
// Total de vendas por região
val totalPorRegiao = dados
    .groupBy("regiao")
    .aggregate {
        sum("valor") into "total_vendas"
        count() into "quantidade"
    }
    .sortByDesc("total_vendas")

totalPorRegiao
```

A grande vantagem sobre Python é que o **DataFrame do Kotlin** gera tipos automaticamente a partir dos dados. Quando você carrega um CSV, as colunas viram propriedades tipadas — erros de nome de coluna são pegos **em tempo de compilação**, não em runtime.

### Conectando com bancos de dados

O DataFrame também suporta leitura direta de **SQL**:

```kotlin
%use dataframe

val conexao = "jdbc:postgresql://localhost:5432/meubanco"
val query = "SELECT nome, departamento, salario FROM funcionarios"
val funcionarios = DataFrame.readSqlQuery(conexao, query)

funcionarios
    .filter { "salario"<Double>() > 8000.0 }
    .groupBy("departamento")
    .aggregate {
        mean("salario") into "salario_medio"
        count() into "total"
    }
```

Se você já trabalha com [bancos de dados em Kotlin](/blog/kotlin-exposed-orm-framework-sql/) usando Exposed, o DataFrame complementa como ferramenta de análise exploratória.

## Visualizando dados com Kandy

O [Kandy](https://kotlin.github.io/kandy/) é a biblioteca de visualização oficial do ecossistema Kotlin, construída sobre o LetsPlot. Ela oferece uma **DSL type-safe** para criar gráficos diretamente no notebook.

### Importando o Kandy

```kotlin
%use kandy
```

### Gráfico de barras

```kotlin
val regioes = listOf("Sudeste", "Sul", "Nordeste", "Centro-Oeste", "Norte")
val vendas = listOf(45000, 32000, 28000, 18000, 12000)

plot {
    bars {
        x(regioes) { axis.name = "Região" }
        y(vendas) { axis.name = "Vendas (R$)" }
        fillColor = Color.hex("#7F52FF") // Roxo Kotlin
    }
    layout.title = "Vendas por Região — 2026"
}
```

### Gráfico de linhas com séries temporais

```kotlin
val meses = listOf("Jan", "Fev", "Mar", "Abr", "Mai", "Jun")
val receita = listOf(120000, 135000, 128000, 142000, 155000, 148000)
val custos = listOf(95000, 98000, 102000, 99000, 105000, 108000)

plot {
    line {
        x(meses) { axis.name = "Mês" }
        y(receita) { axis.name = "Valor (R$)" }
        color = Color.hex("#7F52FF")
        width = 2.5
    }
    line {
        x(meses)
        y(custos)
        color = Color.hex("#E87D3E")
        width = 2.5
    }
    layout {
        title = "Receita vs Custos — 1º Semestre 2026"
        size = 800 to 400
    }
}
```

### Gráfico de dispersão

```kotlin
val experiencia = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val salarios = listOf(4500, 5200, 6100, 7800, 8500, 9200, 10500, 11800, 13000, 15000)

plot {
    points {
        x(experiencia) { axis.name = "Anos de Experiência" }
        y(salarios) { axis.name = "Salário (R$)" }
        size = 5.0
        color = Color.hex("#7F52FF")
    }
    layout.title = "Experiência vs Salário — Devs Kotlin no Brasil"
}
```

Se você se interessa pela relação entre experiência e salário, temos artigos detalhados sobre [salários de dev Kotlin](/carreira/salarios-kotlin-brasil/) e [mercado de trabalho](/carreira/kotlin-mercado-trabalho/).

## Casos de uso práticos

O Kotlin Notebook não é só para data scientists. Veja onde ele brilha:

### 1. Prototipagem rápida de APIs

Testar endpoints antes de integrar no projeto principal:

```kotlin
@file:DependsOn("io.ktor:ktor-client-core:3.1.2")
@file:DependsOn("io.ktor:ktor-client-cio:3.1.2")
@file:DependsOn("io.ktor:ktor-client-content-negotiation:3.1.2")
@file:DependsOn("io.ktor:ktor-serialization-kotlinx-json:3.1.2")

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*

val client = HttpClient()
val response = client.get("https://api.github.com/repos/JetBrains/kotlin")
println(response.bodyAsText().take(500))
```

Se você trabalha com [Ktor](/blog/ktor-criando-apis-kotlin/), o notebook é perfeito para experimentação rápida.

### 2. Análise de logs e métricas

Carregar logs de produção e analisar padrões:

```kotlin
%use dataframe

val logs = DataFrame.read("app-logs-2026-04.csv")

// Erros por hora do dia
val errosPorHora = logs
    .filter { "level"<String>() == "ERROR" }
    .groupBy("hora")
    .count()
    .sortBy("hora")

errosPorHora
```

### 3. Documentação executável

Combinar Markdown e código para criar documentação que realmente roda:

```markdown
## Exemplo de uso do nosso SDK

O trecho abaixo mostra como autenticar e buscar dados:
```

```kotlin
val sdk = MeuSDK(apiKey = "demo-key")
val resultado = sdk.buscarDados(filtro = "ativo")
resultado.forEach { println(it) }
```

### 4. Preparação de dados para Machine Learning

Se você está explorando [Kotlin para IA e Machine Learning](/blog/kotlin-ia-machine-learning/), o Notebook é ideal para a etapa de preparação de dados — limpeza, normalização e feature engineering.

## Kotlin Notebook vs Jupyter com Python

| Aspecto | Kotlin Notebook | Jupyter (Python) |
|---------|-----------------|-------------------|
| **Tipagem** | Estática (erros em compile time) | Dinâmica (erros em runtime) |
| **IDE** | IntelliJ IDEA nativo | Navegador ou VS Code |
| **Autocompletar** | Completo, com tipos | Limitado |
| **Performance** | JVM (rápido para processamento) | Interpretado |
| **Ecossistema de dados** | DataFrame + Kandy | pandas + matplotlib/seaborn |
| **Interoperabilidade** | Java, Kotlin, KMP | Python |
| **Formato** | `.ipynb` compatível | `.ipynb` nativo |

Para quem já programa em Kotlin e precisa analisar dados, o Kotlin Notebook elimina a troca de contexto para Python. Você usa a mesma linguagem do backend, do Android e do [Compose Multiplatform](/blog/compose-multiplatform-1-10-6-2026/).

## Dicas para começar

1. **Atualize o IntelliJ IDEA** para a versão 2025.1 ou superior
2. **Crie um novo Kotlin Notebook**: File → New → Kotlin Notebook
3. **Use `%use`** para importar bibliotecas: `%use dataframe`, `%use kandy`
4. **Explore dados reais**: comece com um CSV pequeno do seu projeto
5. **Exporte como `.ipynb`** para compartilhar com colegas que usam Jupyter

## Recursos e próximos passos

O Kotlin Notebook está evoluindo rapidamente. Na KotlinConf 2026 (maio, em Munique), haverá palestras dedicadas sobre análise de dados com Kotlin, incluindo workshops práticos com DataFrame e Kandy.

Para aprofundar, confira estes conteúdos relacionados:

- [Kotlin para IA e Machine Learning](/blog/kotlin-ia-machine-learning/)
- [Melhores bibliotecas Kotlin](/blog/melhores-bibliotecas-kotlin/)
- [Kotlin DSL: criando APIs expressivas](/blog/kotlin-dsl/)
- [Coroutines em Kotlin](/blog/coroutines-kotlin/) — útil para processamento assíncrono de dados
- [Extension functions](/blog/extension-functions-kotlin/) — base para as DSLs do DataFrame e Kandy
- [Kotlin 2.4.0 Beta1: todas as novidades](/blog/kotlin-2-4-0-beta-novidades-2026/)

## Conclusão

O Kotlin Notebook transforma o IntelliJ IDEA em um ambiente completo para análise de dados, prototipagem e documentação interativa. Com **DataFrame** para manipulação de dados e **Kandy** para visualização, você tem um stack 100% Kotlin — sem precisar alternar para Python.

Se você é dev Kotlin e precisa explorar dados, gerar relatórios ou prototipar rapidamente, o Notebook é uma ferramenta que vale conhecer. Comece com um CSV do seu projeto e veja como a tipagem estática e o autocompletar do IntelliJ IDEA fazem diferença na produtividade.

Embora <a href="https://python.dev.br/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'python.dev.br' })">Python com Jupyter ainda domine data science</a>, o Kotlin Notebook oferece vantagens únicas para quem já trabalha no ecossistema JVM — especialmente a tipagem estática e o autocomplete inteligente do IntelliJ.

Para mais conteúdo sobre o ecossistema Kotlin em português, explore nosso [glossário](/glossario/), [tutoriais](/tutoriais/) e [guias completos](/guias/).
