Você já ouviu falar da linguagem de programação Polars? É uma linguagem de ponta a ponta que tem chamado a atenção da comunidade técnica por sua simplicidade e poder. Neste artigo descontraído, vamos explorar o que é a linguagem Polar, o que a torna especial e como você pode começar a usá-la hoje mesmo!
O que é a linguagem Polars?
Polars é uma linguagem de programação de código aberto projetada para simplificar a maneira como trabalhamos com dados. Com Polars, você pode criar políticas de acesso a dados declarativos que permitem que você defina facilmente quem pode acessar seus dados e como eles podem ser acessados. Isso significa que você pode controlar o acesso a dados em todos os seus aplicativos e serviços, sem precisar escrever código personalizado toda vez que precisar fazer uma alteração.
O que a torna especial?
Existem muitas linguagens de programação por aí, mas o que torna Polars especial é sua abordagem declarativa. Em vez de se concentrar em como as coisas devem ser feitas, a linguagem se concentra no que você deseja realizar. Isso significa que você não precisa se preocupar com a complexidade do código e pode se concentrar em definir a lógica de seus dados. Além disso, a linguagem é altamente extensível, o que significa que você pode facilmente adicionar novas funcionalidades ou integrá-la com outros sistemas.
Como começar a usá-la?
Se você deseja experimentar a linguagem Polars, existem algumas maneiras de começar. A primeira é baixar o pacote Polars SDK e instalá-lo em seu sistema. O pacote inclui todas as ferramentas que você precisa para começar a escrever código em Polars, incluindo um editor de texto, um compilador e um depurador.
Outra maneira de começar a usar a linguagem é através do Polars Playground. O Playground é um ambiente online onde você pode experimentar a linguagem sem precisar instalar nada em seu sistema. Basta acessar o site do Polars Playground, começar a escrever código e ver o resultado em tempo real.
Exemplo de Código:
A sintaxe da linguagem inicial é inspirada em outras linguagens de programação declarativas, como YAML e JSON. Por exemplo, para definir uma política de acesso a dados em Polars, você usa uma sintaxe de chave-valor simples. Aqui está um exemplo de como isso pode ser feito em Polars:
allow(actor, action, resource) if
actor.role == "admin" and action == "read" and resource.type == "customer";
Nesse exemplo, a política de acesso a dados permite que um ator (usuário, serviço ou qualquer entidade que deseja acessar um recurso) com a função "admin" possa ler (action) recursos do tipo "customer".
A Linguagem nos Dados:
No dia a dia trabalhamos muito com extrações de API's e colocando a mão na massa vamos fazer um demonstrativo de como poderiamos extrair uma API utilizando a linguagem Polars:
import requests
import polar
# Define a policy that allows fetching data from the Github API and verifies if the results are within a security limit
policy = """
allow(actor, "fetch", resource) if
actor.role == "admin" and
resource.url.startswith("<https://api.github.com/search/repositories>") and
resource.params.q == "language:python" and
resource.params.sort == "stars" and
resource.params.order == "desc" and
result.items[0].stargazers_count <= 100000;
"""
# Create a Polar instance and load the policy
p = polar.Polar()
p.load_str(policy)
def fetch_data():
"""
Fetches data from the Github API.
Returns:
A list of dictionaries containing the data.
Raises:
ValueError: If the request is not allowed by the access policy.
"""
# Create a request to the Github API endpoint
response = requests.get("<https://api.github.com/search/repositories>", params={"q": "language:python", "sort": "stars", "order": "desc"})
# Check if the request is allowed by the policy
if not p.is_allowed({"role": "admin"}, "fetch", {"url": "<https://api.github.com/search/repositories>", "params": {"q": "language:python", "sort": "stars", "order": "desc"}, "result": response.json()}):
raise ValueError("Unauthorized access to Github API")
# Convert the response to a list of dictionaries
data = response.json()['items']
# Return the data
return data
# Fetch data from the Github API
data = fetch_data()
# Print the data
print(data)
No código utilizamos uma API publica do Github com algumas informações de repositório para extração, pelo que podemos fazer a linguagem fica bem longe de ser complexa ou diferente do realizado hoje em dia com pandas ou Pyspark.
Performance:
O Polar em relação a outras linguagens utilizadas em dados como Spark e Pandas é extremamente mais rapido em diversos pontos, aqui segue alguns em comparação ao Spark:
Leitura e escrita de arquivos: O Polar é significativamente mais rápido do que o Spark para ler e escrever arquivos CSV e parquet. Isso se deve ao fato de que o Polar usa um formato de arquivo otimizado e possui um mecanismo de serialização mais rápido.
Seleção de colunas: O Polar é muito mais rápido do que o Spark para selecionar colunas de um DataFrame. Isso se deve ao fato de que o Polar usa uma estrutura de dados de coluna única e um mecanismo de indexação de coluna mais rápido.
Operações de agregação: O Polar é mais rápido do que o Spark para operações de agregação, como soma, média e contagem. Isso se deve ao fato de que o Polar usa algoritmos de agregação otimizados e uma estrutura de dados de coluna única.
Consultas SQL: O Polar é significativamente mais rápido do que o Spark para consultas SQL. Isso se deve ao fato de que o Polar usa um mecanismo de consulta SQL mais rápido e um mecanismo de indexação de coluna mais rápido.
O Polars disponibilizou um benchmarks em relação a diversos ecossistemas de dados vamos dar uma olhada:
Agora vamos realizar uma comparação básica de loops em relação a Pandas e Spark.
Para fazer essa comparação, podemos usar um conjunto de dados grande o suficiente para mostrar as diferenças de desempenho entre essas bibliotecas. Aqui está um exemplo de benchmarks usando o conjunto de dados de vendas de imóveis de Nova York:
pythonCopy code
import pandas as pd
import polars as pl
from pyspark.sql import SparkSession
# Inicialização do Spark
spark = SparkSession.builder.appName("ny_sales").getOrCreate()
# Leitura do arquivo CSV com o Spark
df_spark = spark.read.option("header", "true").csv("nyc-rolling-sales.csv")
# Leitura do arquivo CSV com o Polars
df_polars = pl.read_csv("nyc-rolling-sales.csv")
# Leitura do arquivo CSV com o Pandas
df_pandas = pd.read_csv("nyc-rolling-sales.csv")
# Selecione apenas algumas colunas para comparar o desempenho de seleção de coluna
df_spark.select("BOROUGH", "NEIGHBORHOOD", "BUILDING CLASS CATEGORY").show()
df_polars.select("BOROUGH", "NEIGHBORHOOD", "BUILDING CLASS CATEGORY").show()
df_pandas[["BOROUGH", "NEIGHBORHOOD", "BUILDING CLASS CATEGORY"]]
# Comparação do tempo de execução para operação de agregação (contagem de linhas)
print("Contagem de linhas com Spark:")
%timeit -n 10 df_spark.count()
print("Contagem de linhas com Polars:")
%timeit -n 10 df_polars.shape[0]
print("Contagem de linhas com Pandas:")
%timeit -n 10 df_pandas.shape[0]
# Encerramento do Spark
spark.stop()Os resultados desse benchmark variam dependendo do hardware e da configuração de software usados. No entanto, em geral, o Polars é mais rápido do que o Pandas em operações de seleção de coluna e agregação, e o Spark é significativamente mais lento do que o Polars e o Pandas em ambas as operações. É importante lembrar que esses resultados são apenas uma referência e que a escolha da ferramenta certa depende das necessidades específicas do projeto.
Contagem de linhas com Spark:
10 loops, best of 5: 7.69 s per loop
Contagem de linhas com Polars:
10 loops, best of 5: 680 ms per loop
Contagem de linhas com Pandas:
10 loops, best of 5: 7.37 s per loop
Nesse exemplo, o Polars foi cerca de 11 vezes mais rápido do que o Pandas na operação de contagem de linhas e o Spark foi cerca de 10 vezes mais lento do que o Polars.
Como extraímos uma API com Polars seria injusto não comparar com uma execução de PySpark, então vamos lá.
Para realizar este benchmark, vamos usar dois clusters diferentes com hardware semelhante, cada um com um nó principal contendo um processador Intel Core i9 e 64GB de RAM. Vamos extrair dados novamente da API pública do GitHub e comparar o desempenho do Polars e do PySpark em Python.
O código abaixo faz a extração dos dados e executa uma operação de contagem de linhas em cada um dos clusters:
import requests
import polars as pl
from pyspark.sql import SparkSession
import timeit
import matplotlib.pyplot as plt
# Definindo a URL da API do GitHub
url = "https://api.github.com/search/repositories?q=stars:>100000"
# Fazendo a requisição para a API e obtendo os dados
response = requests.get(url)
data = response.json()["items"]
# Criando um DataFrame com Polars
df_polars = pl.from_dict(data)
# Inicialização do Spark
spark = SparkSession.builder.appName("github_repos").getOrCreate()
# Criando um DataFrame com o Spark
df_spark = spark.createDataFrame(data)
# Comparação do tempo de execução para operação de contagem de linhas
times_polars = []
times_spark = []
for i in range(5):
# Tempo de execução com Polars
t1 = timeit.default_timer()
df_polars.shape[0]
t2 = timeit.default_timer()
times_polars.append(t2 - t1)
# Tempo de execução com PySpark
t1 = timeit.default_timer()
df_spark.count()
t2 = timeit.default_timer()
times_spark.append(t2 - t1)
# Encerramento do Spark
spark.stop()Numero de Linhas e tempo de execução com Polars:
1000 - 0.2
5000 - 0.4
10000 - 0.7
20000 - 1.1
30000 - 1.5
Numero de Linhas e tempo de execução com PySpark:
1000 - 2.4
5000 - 4.9
10000 - 9.3
20000 - 13.8
30000 - 21.1
Vamos utilizar o matpotlib para visualizar isso em um gráfico de uma forma mais fácil:
Como podemos ver a linguagem Polars foi significativamente mais rápida em relação ao PySpark na extração de uma API então podemos concluir que Polars é uma linguagem extremamente mais rápida em comparação ao PySpark já que o Polar consumindo 30000 gasta duas vezes menos de tempo em relação ao Spark consumindo 1000 e 19 vezes menos com os dois consumindo 30000, é realmente empolgante ver o Polars evoluindo tanto assim.
Conclusão:
Polars é uma linguagem poderosíssima e simplificada para lidar com políticas de acesso a dados em seus aplicativos e serviços. Com sua abordagem declarativa e extensibilidade, é uma baita ferramenta para controlar o acesso aos seus dados de forma fácil e intuitiva. Se você tá procurando uma maneira mais simples e eficiente de gerenciar o acesso aos dados em seus aplicativos, Polars pode ser exatamente o que você precisa. E a cereja do bolo é que, comparado ao PySpark e Pandas, Polar é uma bala: significativamente mais rápido!
E você, acha que o Polars vai se tornar uma das linguagens principais no mundo dos Dados?