As 36 principais perguntas e respostas da entrevista sobre PySpark para 2026

Perguntas básicas para entrevistas sobre PySpark

Vamos começar explorando algumas perguntas fundamentais da entrevista sobre PySpark que avaliam sua compreensão dos conceitos básicos e das vantagens dessa poderosa biblioteca.

Quais são as principais vantagens de usar o PySpark em vez do Python tradicional para processamento de big data?

O PySpark, a API Python para o Apache Spark, tem várias vantagens em relação ao Python tradicional para processamento de big data. Isso inclui:

• Escalabilidade para lidar com conjuntos de dados enormes.
• Alto desempenho por meio do processamento paralelo.
• Tolerância a falhas para garantir a confiabilidade dos dados.
• Integração com outras ferramentas de big data dentro do ecossistema Apache.

Como você cria uma SparkSession no PySpark? Quais são suas principais utilizações?

No PySpark, o objeto ` SparkSession ` é o ponto de partida para usar as funcionalidades do Spark e é criado usando a API ` SparkSession.builder `. 

Suas principais utilizações incluem:

• Interagindo com o Spark SQL para processar dados estruturados.
• Criando DataFrames.
• Configurando as propriedades do Spark.
• Gerenciando o ciclo de vida do SparkContext e do SparkSession.

Aqui está um exemplo de como um SparkSession pode ser criado: 

from pyspark.sql import SparkSession
     
spark = SparkSession.builder \
         .appName("MySparkApp") \
         .master("local[*]") \
         .getOrCreate()	

Descreva as diferentes maneiras de ler dados no PySpark.

O PySpark dá suporte à leitura de dados de várias fontes, como CSV, Parquet e JSON, entre outras. Para isso, oferece diferentes métodos, incluindo spark.read.csv(), spark.read.parquet(), spark.read.json(), spark.read.format(), spark.read.load(). 

Aqui está um exemplo de como os dados podem ser lidos no PySpark: 

df_from_csv = spark.read.csv("my_file.csv", header=True)
df_from_parquet = spark.read.parquet("my_file.parquet")
df_from_json = spark.read.json("my_file.json")

Como você lida com dados ausentes no PySpark?

No PySpark, dá pra lidar com dados faltando usando vários métodos:

• A gente pode eliminar linhas ou colunas com valores ausentes usando o método ` .dropna()`.
• Podemos preencher os dados que faltam com um valor específico ou usar métodos de interpolação com o método ` .fillna()`.
• Podemos calcular valores ausentes usando métodos estatísticos, como média ou mediana, usando Imputer.

Aqui está um exemplo de como os dados ausentes podem ser tratados no PySpark: 

# How to drop rows 
df_from_csv.dropna(how="any")

# How to fill missing values with a constant
df_from_parquet.fillna(value=2)

# How to impute values with median
from pyspark.ml.feature import Imputer
imputer = Imputer(strategy="median", inputCols=["price","rooms"], outputCols=["price_imputed","rooms_imputed"])
model = imputer.fit(df_from_json)
df_imputed = model.transform(df_from_json)

Como você pode armazenar dados em cache no PySpark para melhorar o desempenho?

Uma das vantagens do PySpark é que ele permite usar os métodos .cache() ou .persist() para guardar os dados na memória ou no nível de armazenamento especificado. Essa tarefa melhora o desempenho, evitando cálculos repetidos e reduzindo a necessidade de serialização e desserialização de dados. 

Aqui está um exemplo de como armazenar dados em cache no PySpark: 

# How to cache data in memory 
df_from_csv.cache()

# How to persist data in local disk 
df_from_csv.persist(storageLevel=StorageLevel.DISK_ONLY)

Descreva como fazer junções no PySpark.

O Pyspark permite realizar vários tipos de junções: junções internas, externas, à esquerda e à direita. Usando o método ` .join() `, podemos especificar a condição de junção no parâmetro `on` e o tipo de junção usando o parâmetro ` how `, como mostrado no exemplo:

# How to inner join two datasets
df_from_csv.join(df_from_json, on="id", how="inner")

# How to outer datasets
df_from_json.join(df_from_parquet, on="product_id", how="outer")

Quais são as principais diferenças entre RDDs, DataFrame e Datasets no PySpark?

Os conjuntos de dados distribuídos resilientes (RDD), DataFrame e conjuntos de dados são abstrações importantes no Spark que nos permitem trabalhar com dados estruturados em um ambiente de computação distribuída. Mesmo sendo todas formas de mostrar dados, elas têm diferenças importantes:

• RDDs são APIs de baixo nível que não têm um esquema e oferecem controle sobre os dados. São coleções imutáveis de objetos. 
• DataFrame são APIs de alto nível construídas sobre RDDs otimizadas para desempenho, mas não são do tipo seguro. Eles organizam dados estruturados e semiestruturados em colunas nomeadas.
• Os conjuntos de dados juntam as vantagens dos RDDs e dos DataFrame. São APIs de alto nível que oferecem abstração de tipo seguro. Eles suportam Python e Scala e oferecem verificação de tipo em tempo de compilação, sendo mais rápidos que os DataFrame. 

Explique o conceito de avaliação preguiçosa no PySpark. Como isso afeta o desempenho?

O PySpark usa uma estratégia chamada avaliação preguiçosa, onde as transformações aplicadas em conjuntos de dados distribuídos (RDDs, DataFrame ou Datasets) não são feitas na hora. Ao contrário, o Spark cria uma sequência de operações ou transformações a serem realizadas nos dados, chamada de gráfico acíclico direcionado (DAG). Essa avaliação preguiçosa melhora o desempenho e otimiza a execução, porque o cálculo é adiado até que uma ação seja acionada e seja estritamente necessária.

Qual é o papel do particionamento no PySpark? Como isso pode melhorar o desempenho?

No PySpark, o particionamento de dados é o recurso principal que nos ajuda a distribuir a carga uniformemente entre os nós de um cluster. Particionamento é quando você divide os dados em pedaços menores (partições) que são processados de forma independente e em paralelo em um cluster. Melhora o desempenho ao permitir o processamento paralelo, reduzir a movimentação de dados e melhorar a utilização dos recursos. A partição pode ser controlada usando métodos como .repartition() e .coalesce().

Explique o conceito de variáveis de transmissão no PySpark e dê um exemplo de uso.

As variáveis de transmissão são uma característica importante das estruturas de computação distribuída do Spark. No PySpark, são variáveis compartilhadas somente leitura que são armazenadas em cache e distribuídas aos nós do cluster para evitar operações de shuffle. Eles podem ser muito úteis quando temos um aplicativo de machine learning distribuído que precisa usar e carregar um modelo pré-treinado. Transmitimos o modelo como uma variável, o que nos ajuda a reduzir a sobrecarga de transferência de dados e melhorar o desempenho.

Quais são as diferenças entre o PySpark e o pandas?

PySpark e pandas são bem populares pra manipular dados, mas têm diferenças importantes:

• Escalabilidade: O PySpark foi feito pra lidar com big data e processamento distribuído, enquanto o pandas é mais legal pra conjuntos de dados menores que cabem na memória.
• Desempenho: O PySpark faz o processamento paralelo em clusters, o que é bem mais rápido para grandes conjuntos de dados do que o pandas, que funciona em uma única máquina.
• Fácil de usar: O Pandas é mais simples para análise exploratória de dados (EDA), enquanto o PySpark é mais complexo, mas altamente otimizado para computação distribuída.

Como você pode converter um DataFrame do Pandas em um DataFrame do PySpark e vice-versa?

Você pode converter um DataFrame do Pandas em um DataFrame do PySpark usando spark.createDataFrame() e vice-versa usando .toPandas().

import pandas as pd
from pyspark.sql import SparkSession

# Initialize SparkSession
spark = SparkSession.builder.appName("Example").getOrCreate()

# Create Pandas DataFrame
pdf = pd.DataFrame({'id': [1, 2, 3], 'value': [10, 20, 30]})

# Convert to PySpark DataFrame
df_spark = spark.createDataFrame(pdf)

# Convert back to Pandas DataFrame
pdf_new = df_spark.toPandas()

Perguntas intermediárias sobre PySpark para entrevistas

Depois de falar sobre o básico, vamos ver algumas perguntas de nível intermediário sobre PySpark que exploram mais a fundo a arquitetura e o modelo de execução das aplicações Spark.

O que é um Spark Driver e quais são suas responsabilidades?

O Spark Driver é o processo principal que coordena as aplicações Spark, executando tarefas nos clusters. Ele se comunica com o gerenciador de cluster para alocar recursos, agendar tarefas e monitorar a execução de trabalhos do Spark.

O que é Spark DAG?

Um gráfico acíclico direcionado (DAG) no Spark é um conceito importante porque representa o modelo de execução lógica do Spark. É direcionado porque cada nó representa uma transformação feita numa ordem específica nas arestas. É acíclico porque não tem loops ou ciclos no plano de execução. Esse plano é otimizado usando transformações de pipeline, coalescência de tarefas e pushdown de predicados.

Quais são os diferentes tipos de gerenciadores de cluster disponíveis no Spark?

O Spark atualmente suporta diferentes gerenciadores de cluster para gerenciamento de recursos e agendamento de tarefas, incluindo:

• Autônomo, cluster simples incluído no Spark.
• O Hadoop YARN é um gerenciador geral no Hadoop usado para agendar tarefas e gerenciar recursos.
• O Kubernetes é usado para automação, implantação, dimensionamento e gerenciamento de aplicativos em contêineres.
• O Apache Mesos é um sistema distribuído usado para gerenciar recursos por aplicativo.

Descreva como implementar uma transformação personalizada no PySpark.

Para implementar uma transformação personalizada no PySpark, podemos definir uma função Python que opera em DataFrame do PySpark e, em seguida, usar o método ` .transform() ` para invocar a transformação.

Aqui está um exemplo de como implementar uma transformação personalizada no PySpark: 

# Define a python function that operates on pySpark DataFrames
def get_discounted_price(df):
    return df.withColumn("discounted_price", \
                          df.price - (df.price * df.discount) / 100) 

# Evoke the transformation
df_discounted = df_from_csv.transfrom(get_discounted_price)

Explique o conceito de funções de janela no PySpark e dê um exemplo.

As funções PySpark Window permitem aplicar operações em uma janela de linhas, retornando um único valor para cada linha de entrada. A gente pode fazer ranking, análises e funções agregadas. 

Aqui está um exemplo de como aplicar uma função de janela no PySpark: 

from pyspark.sql.window import Window
from pyspark.sql.functions import row_number

# Define the window function
window = Window.orderBy("discounted_price")

# Apply window function
df = df_from_csv.withColumn("row_number", row_number().over(window))

Como você lida com erros e exceções no PySpark?

Uma das maneiras mais úteis de lidar com erros e exceções nas transformações e ações do PySpark é colocar o código em blocos try-except para capturá-los. Nos RDDs, a gente pode usar uma operaçã foreach e para iterar sobre os elementos e lidar com exceções. 

Qual é o objetivo dos pontos de verificação no PySpark?

No PySpark, o checkpointing significa que os RDDs são salvos no disco para que esse ponto intermediário possa ser usado no futuro, em vez de ter que calcular de novo o RDD da fonte original. Os pontos de verificação são uma forma de se recuperar de falhas, porque o driver é reiniciado com esse estado calculado antes. 

Como o PySpark lida com a inferência de esquema e como você pode definir um esquema explicitamente?

O PySpark adivinha o esquema automaticamente quando carrega dados estruturados, mas, para um melhor controle e eficiência, você pode definir o esquema explicitamente usando StructType e StructField.

from pyspark.sql.types import StructType, StructField, IntegerType, StringType

schema = StructType([
    StructField("id", IntegerType(), True),
    StructField("name", StringType(), True)
])

df = spark.read.csv("data.csv", schema=schema, header=True)

Perguntas avançadas sobre PySpark para entrevistas

Pra quem tá procurando cargos mais seniores ou quer mostrar que entende bem do PySpark, vamos ver algumas perguntas avançadas de entrevista que falam sobre as complexidades das transformações e otimizações no PySpark.

Explique as diferenças entre transformações estreitas e amplas no PySpark.

No PySpark, as transformações estreitas são feitas quando cada partição de entrada contribui para, no máximo, uma partição de saída e não precisa de embaralhamento. Exemplos incluem map(), filter() e union. Pelo contrário, grandes transformações são necessárias para operações em que cada partição de entrada pode contribuir para várias partições de saída e exigir reorganização, junções ou agregações de dados. Exemplos incluem groupBy(), join() e sortBy().

O que é um otimizador Catalyst no Spark e como ele funciona?

No Spark, o otimizador Catalyst é um componente baseado em regras do Spark SQL usado para otimizar o desempenho das consultas. A principal tarefa dele é transformar e melhorar a operação SQL ou DataFrame do usuário para criar um plano de execução físico eficiente, feito sob medida para as características específicas da consulta e do conjunto de dados.

Descreva como implementar agregações personalizadas no PySpark.

Para implementar agregações personalizadas no PySpark, podemos usar os métodos ` groupBy() ` e ` agg() ` juntos. Dentro da chamada para agg(), podemos passar várias funções do módulo pyspark.sql.functions. Além disso, podemos aplicar agregações personalizadas do Pandas a grupos dentro de um DataFrame do PySpark usando o método ` .applyInPandas() `.

Aqui está um exemplo de como implementar agregações personalizadas no PySpark: 

# Use groupBy and agg with Functions
from pyspark.sql import functions as F
df_from_csv.groupBy("house_id").agg(F.mean("price_discounted"))

# Use applyInPandas
def normalize_price(df):
    disc_price = df["discounted_price"]
    df["normalized_price"] = disc_price.mean() / disc_price.std()

df_from_csv.groupBy("house_id").applyInPandas(normalize_price)

Que desafios você enfrentou ao trabalhar com grandes conjuntos de dados no PySpark? Como você superou esses desafios?

Com essa pergunta, a gente pode pensar na nossa própria experiência e contar um caso específico em que enfrentamos desafios com o PySpark e grandes conjuntos de dados, que podem incluir alguns dos seguintes:

• Gerenciamento de memória e uso de recursos.
• Distribuição desigual dos dados e carga de trabalho irregular.
• Otimização de desempenho, especialmente para transformações e reorganizações amplas.
• Depurar e resolver problemas complexos de falhas em tarefas.
• Particionamento e armazenamento eficientes de dados.

Para resolver esses problemas, o PySpark oferece particionamento do conjunto de dados, armazenamento em cache de resultados intermediários, uso de técnicas de otimização integradas, gerenciamento robusto de clusters e aproveitamento de mecanismos de tolerância a falhas.

Como você integra o PySpark com outras ferramentas e tecnologias no ecossistema de big data?

O PySpark tem uma forte integração com várias ferramentas de big data, incluindo Hadoop, Hive, Kafka e HBase, bem como armazenamento baseado em nuvem, como AWS S3 e Google Cloud Storage. Essa integração é feita usando conectores, bibliotecas e APIs integrados fornecidos pelo PySpark.

Quais são algumas das melhores práticas para testar e depurar aplicativos PySpark?

Algumas das melhores práticas recomendadas para testar e depurar aplicativos PySpark incluem:

• Escrevendo testes unitários usando o pyspark.sql.test.SQLTestUtils junto com bibliotecas Python (pytest)
• Depurando aplicativos e registrando mensagens usando a biblioteca logging, bem como a interface do usuário do Spark.
• Otimizando o desempenho usando as APIs Spark org.apache.spark.metrics e ferramentas de monitoramento de desempenho.

Como você lidaria com questões de segurança e privacidade de dados em um ambiente PySpark?

Hoje em dia, compartilhar dados ficou mais fácil, então proteger informações confidenciais e sigilosas é uma boa maneira de evitar vazamentos de dados. Uma das melhores práticas que podemos seguir é usar criptografia de dados durante o processamento e armazenamento.

No PySpark, dá pra fazer isso usando as funções ` aes_encrypt() ` e ` aes_decrypt() ` nas colunas de um DataFrame. Também podemos usar outra biblioteca, como a biblioteca de criptografia, para alcançar esse objetivo.

Descreva como usar o PySpark para criar e implementar um modelo de machine learning.

O PySpark nos oferece a biblioteca MLIib, uma biblioteca de machine learning escalável para criar e implementar modelos de machine learning em grandes conjuntos de dados. Essa API de biblioteca pode ser usada para várias tarefas no processo de ML, como pré-processamento de dados, engenharia de recursos, treinamento de modelos, avaliação e implantação. Usando os clusters Spark, podemos implementar modelos de ML baseados em PySpark em produção usando inferência em lote ou streaming. 

Como você pode otimizar as operações de embaralhamento no PySpark?

As operações de embaralhamento acontecem quando os dados são redistribuídos pelas partições e podem ser caras em termos de desempenho. Pra otimizar as embaralhadas:

• Use o repartition() de forma estratégica para equilibrar partições antes de operações caras, como junções.
• Prefira usar o comando ` coalesce() ` em vez de ` repartition() ` ao reduzir partições, pois isso minimiza a movimentação de dados.
• Transmita tabelas menores usando broadcast() antes de juntar com tabelas grandes para evitar operações que exigem muita reorganização.
• Ajuste as configurações do Tune Spark, como spark.sql.shuffle.partitions, para otimizar o número de partições para operações de shuffle.

Perguntas de entrevista sobre PySpark para um engenheiro de dados

Se você estiver sendo entrevistado para uma vaga de engenheiro de dados, espere perguntas que avaliem sua capacidade de projetar, otimizar e solucionar problemas em aplicativos PySpark em um ambiente de produção. Vamos ver algumas perguntas típicas que você pode encontrar numa entrevista.

Descreva como você otimizaria um trabalho PySpark que está rodando devagar. Quais são os principais fatores que você levaria em consideração?

Se um trabalho PySpark estiver lento, tem várias coisas que a gente pode melhorar pra otimizar o desempenho dele:

• Garantir o tamanho e o número adequados de partições de dados para minimizar a reorganização de dados durante as transformações.
• Usando DataFrame em vez de RRDs porque eles já utilizam vários módulos de otimização para melhorar o desempenho das cargas de trabalho do Spark.
• Usando junções de transmissão e variáveis de transmissão para juntar um conjunto de dados pequeno com um conjunto de dados maior.
• Armazenando em cache e mantendo intermediates DataFrame que são reutilizados.
• Ajustando o número de partições, núcleos executores e instâncias para usar os recursos do cluster de forma eficiente.
• Escolher os formatos de arquivo certos pra diminuir o tamanho dos dados.

Como você garante a tolerância a falhas em aplicativos PySpark?

Para garantir a tolerância a falhas em aplicativos PySpark, podemos adotar várias estratégias:

• Usando o Checkpointing para salvar os dados em determinados pontos.
• Replique nossos dados salvando-os em diferentes máquinas.
• Manter um registro das alterações feitas nos nossos dados antes que elas aconteçam.
• Fazendo verificações de validação de dados para procurar erros.
• Escolhendo o nível certo de persistência.
• Usando a tolerância a falhas integrada do Spark para tentar de novo automaticamente as tarefas que falharem.

Quais são as diferentes maneiras de implantar e gerenciar aplicativos PySpark?

A gente pode implantar e gerenciar aplicativos PySpark usando as seguintes ferramentas:

• YARN: um gerenciador de recursos que nos ajuda a implantar e gerenciar os aplicativos em clusters Hadoop
• Kubernetes: O Spark dá uma força pra implantar os aplicativos usando clusters Kubernetes.
• Databricks: Ele oferece uma plataforma totalmente gerenciada para aplicativos PySpark, simplificando a complexidade do gerenciamento de clusters.

Pra saber mais sobre o Databricks, dá uma olhada nesse curso Introdução ao Databricks.

Você também pode aprender mais sobre o Kubernetes neste tutorial sobre Containerização em : Docker e Kubernetes para machine learning.

Como você monitoraria e resolveria problemas em tarefas do PySpark rodando num ambiente de produção?

O PySpark oferece as seguintes ferramentas para monitorar e solucionar problemas em trabalhos executados em um ambiente de produção:

• Spark UI: Uma interface de usuário baseada na web que nos ajuda a monitorar o andamento do trabalho, a utilização de recursos e a execução de tarefas.
• Registro: A gente pode configurar o registro para pegar informações detalhadas sobre os erros e avisos.
• Métricas: Podemos usar sistemas de monitoramento para coletar e analisar métricas relacionadas à integridade do cluster e ao desempenho das tarefas.

Explique a diferença entre a alocação dinâmica e estática do Spark e quando você pode escolher uma delas.

No Spark, a alocação estática é quando você prepara recursos fixos, como memória do executor e núcleos, antes de tudo e de forma constante, para toda a duração do aplicativo. Pelo contrário, a alocação dinâmica permite que o Spark ajuste dinamicamente o número de executores com base na demanda da carga de trabalho. Os recursos podem ser adicionados ou removidos conforme necessário, melhorando a utilização dos recursos e reduzindo custos.

Como você decide entre usar DataFrame e RDDs no PySpark?

A escolha entre DataFrame e RDDs depende da estrutura dos seus dados e do tipo de operações que você precisa realizar.

• Use DataFrames quando:
  • Você precisa processar dados estruturados com base em esquemas.
  • Você quer uma execução otimizada com o Catalyst e o Tungsten.
  • Você trabalha com consultas SQL e transformações integradas.
• Use RDDs quando:
  • Você precisa de transformações de baixo nível e controle detalhado sobre os cálculos.
  • Você está trabalhando com dados não estruturados ou semiestruturados.
  • Você precisa de mais flexibilidade pra definir as transformações.

Como você implementaria o processamento incremental de dados no PySpark?

O processamento incremental é essencial para lidar com conjuntos de dados que estão sempre crescendo de forma eficiente. Pode ser implementado por:

• Usando o Delta Lake: Armazenar atualizações no formato Delta permite o tratamento eficiente de alterações incrementais.
• Usando marca d'água com streaming estruturado: Ajuda a descartar dados antigos enquanto mantém as agregações com estado.
• Particionamento e filtragem: Carregar só os dados novos ou modificados, em vez de processar tudo de novo.
• Usando checkpointing: Salva os resultados intermediários pra evitar ter que refazer tudo do zero se der problema.

Conclusão

Neste artigo, falamos sobre várias perguntas de entrevista sobre PySpark, desde o básico até o avançado. Desde entender os conceitos básicos e as vantagens do PySpark até mergulhar em otimizações mais complexas e técnicas de resolução de problemas, exploramos as principais áreas que os possíveis empregadores podem perguntar.

Se você precisa de mais treinamento em PySpark para sua entrevista, confira os seguintes cursos:

• Introdução ao PySpark
• Big Data com PySpark
• Fundamentos de Big Data com PySpark
• Folha de dicas do PySpark Spark em Python
• Machine learning com PySpark