As 36 principais perguntas e respostas da entrevista com o PySpark para 2025

Perguntas básicas da entrevista com o PySpark

Vamos começar explorando algumas perguntas fundamentais da entrevista do PySpark que avaliam sua compreensão dos principais conceitos e vantagens dessa poderosa biblioteca.

Quais são as principais vantagens de usar o PySpark em relação ao Python tradicional para o processamento de Big Data?

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

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

Como você cria uma SparkSession no PySpark? Quais são seus principais usos?

No PySpark, SparkSession é o ponto de entrada para você usar a funcionalidade do Spark e é criado usando a API SparkSession.builder. 

Seus principais usos incluem:

• Interagir com o Spark SQL para processar dados estruturados.
• Criando DataFrames.
• Configuração das propriedades do Spark.
• Gerenciar o ciclo de vida do SparkContext e do SparkSession.

Aqui está um exemplo de como você pode criar um SparkSession: 

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

Descreva as diferentes maneiras de ler dados no PySpark.

O PySpark oferece suporte à leitura de dados de várias fontes, como CSV, Parquet e JSON, entre outras. Para esse fim, ele fornece 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, podemos lidar com dados ausentes usando vários métodos:

• Podemos eliminar linhas ou colunas que contenham valores ausentes usando o método .dropna().
• Podemos preencher os dados ausentes com um valor específico ou usar métodos de interpolação com o método .fillna().
• Podemos imputar 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 nos permite usar os métodos .cache() ou .persist() para armazenar 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 a realização de junções no PySpark.

O Pyspark permite que você execute vários tipos de junções: interna, externa, esquerda e direita. Ao usar o método .join(), podemos especificar a condição de união no parâmetro on e o tipo de união usando o parâmetro how, conforme 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, DataFrames e Datasets no PySpark?

Spark Resilient Distributed Datasets (RDD), DataFrame e Datasets são abstrações importantes no Spark que nos permitem trabalhar com dados estruturados em um ambiente de computação distribuída. Embora todas elas sejam formas de representar dados, elas têm diferenças importantes:

• Os RDDs são APIs de baixo nível que não têm um esquema e oferecem controle sobre os dados. Eles são coleções imutáveis de objetos 
• Os DataFrames são APIs de alto nível criadas com base em RDDs otimizados para desempenho, mas não são do tipo seguro. Eles organizam dados estruturados e semiestruturados em colunas nomeadas.
• Os conjuntos de dados combinam os benefícios dos RDDs e DataFrames. São APIs de alto nível que oferecem abstração de tipo seguro. Eles são compatíveis com Python e Scala e oferecem verificação de tipo em tempo de compilação, além de serem mais rápidos do que os DataFrames. 

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

O PySpark implementa uma estratégia chamada avaliação preguiçosa, na qual as transformações aplicadas em conjuntos de dados distribuídos (RDDs, DataFrames ou Datasets) não são executadas imediatamente. Pelo contrário, o Spark constrói 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 estritamente necessária.

Qual é a função do particionamento no PySpark? Como isso pode melhorar o desempenho?

No PySpark, o particionamento de dados é o principal recurso que nos ajuda a distribuir a carga uniformemente entre os nós em um cluster. O particionamento refere-se à ação de dividir os dados em pedaços menores (partições) que são processados de forma independente e em paralelo em um cluster. Ele melhora o desempenho ao permitir o processamento paralelo, reduzir a movimentação de dados e melhorar a utilização de recursos. O particionamento pode ser controlado usando métodos como .repartition() e .coalesce().

Explique o conceito de variáveis de transmissão no PySpark e forneça um caso de uso.

As variáveis de transmissão são um recurso fundamental das estruturas de computação distribuída do Spark. No PySpark, elas são variáveis compartilhadas somente para leitura que são armazenadas em cache e distribuídas aos nós do cluster para evitar operações de embaralhamento. Eles podem ser muito úteis quando temos um aplicativo de aprendizado de máquina 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?

O PySpark e o pandas são populares para a manipulação de dados, mas têm diferenças importantes:

• Escalabilidade: O PySpark foi projetado para big data e processamento distribuído, enquanto o pandas é adequado para conjuntos de dados menores que cabem na memória.
• Desempenho: O PySpark realiza processamento paralelo em clusters, o que o torna muito mais rápido para grandes conjuntos de dados em comparação com o pandas, que opera em uma única máquina.
• Facilidade de uso: 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 da entrevista com o PySpark

Tendo abordado o básico, vamos passar para algumas perguntas de nível intermediário da entrevista sobre o PySpark que se aprofundam na arquitetura e no modelo de execução dos aplicativos Spark.

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

O Spark Driver é o processo central que orquestra os aplicativos Spark, executando tarefas nos clusters. Ele se comunica com o gerenciador de cluster para alocar recursos, agendar tarefas e monitorar a execução dos trabalhos do Spark.

O que é o Spark DAG?

Um gráfico acíclico direcionado (DAG) no Spark é um conceito fundamental porque representa o modelo de execução lógica do Spark. Ele é direcionado porque cada nó representa uma transformação executada em uma ordem específica nas bordas. Ele é acíclico porque não há 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?

Atualmente, o Spark oferece suporte a diferentes gerenciadores de cluster para gerenciamento de recursos e agendamento de trabalhos, incluindo:

• Autônomo, cluster simples incluído no Spark.
• O Hadoop YARN é um gerenciador geral do Hadoop usado para agendamento de tarefas e gerenciamento de 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 você pode implementar uma transformação personalizada no PySpark.

Para implementar uma transformação personalizada no PySpark, podemos definir uma função Python que opere nos DataFrames do PySpark e, em seguida, usar o método .transform() para evocar a transformação.

Aqui está um exemplo de como você pode 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 forneça um exemplo.

As funções PySpark Window nos permitem aplicar operações em uma janela de linhas, retornando um único valor para cada linha de entrada. Podemos executar funções de classificação, análise e agregação. 

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 é envolver o código em blocos try-except para capturá-los. Nos RDDs, podemos usar a operação foreach para iterar sobre os elementos e tratar exceções. 

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

No PySpark, o checkpointing implica que os RDDs são salvos no disco para que esse ponto intermediário possa ser referenciado no futuro, em vez de recomputar o RDD para a fonte original. Os pontos de verificação oferecem uma maneira de se recuperar de falhas, pois o driver é reiniciado com esse estado computado anteriormente. 

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

O PySpark infere o esquema automaticamente ao carregar dados estruturados, mas, para maior 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 da entrevista com o PySpark

Para aqueles que buscam cargos mais sênior ou que desejam demonstrar um conhecimento mais profundo do PySpark, vamos explorar algumas perguntas avançadas da entrevista que abordam os meandros das transformações e otimizações no ecossistema do PySpark.

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

No PySpark, as transformações estreitas são realizadas quando cada partição de entrada contribui para no máximo uma partição de saída e não requerem embaralhamento. Os exemplos incluem map(), filter() e union. Por outro lado, transformações amplas 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 embaralhamento, junções ou agregações de dados. Os 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 da consulta. Sua principal tarefa é transformar e aprimorar a operação SQL ou DataFrame do usuário para gerar um plano de execução física eficiente, adaptado às características específicas da consulta e do conjunto de dados.

Descreva como você pode 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 em um DataFrame do PySpark usando o método .applyInPandas().

Aqui está um exemplo de como você pode 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ê as superou?

Com essa pergunta, podemos nos basear em nossa própria experiência e contar um caso específico em que você enfrentou desafios com o PySpark e grandes conjuntos de dados, que podem incluir alguns dos seguintes itens:

• Gerenciamento de memória e utilização de recursos.
• Inclinação dos dados e distribuição desigual da carga de trabalho.
• Otimização do desempenho, especialmente para transformações e embaralhamentos amplos.
• Depuração e solução de problemas de falhas complexas de trabalho.
• Particionamento e armazenamento eficientes de dados.

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

Como você integra o PySpark a outras ferramentas e tecnologias no ecossistema de Big Data?

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

Quais são as práticas recomendadas para testar e depurar aplicativos PySpark?

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

• Escrever testes de unidade usando pyspark.sql.test.SQLTestUtils junto com as bibliotecas Python (pytest)
• Depuração de aplicativos e registro de mensagens usando a biblioteca logging e a interface do usuário do Spark
• Otimização do desempenho usando as APIs do Spark org.apache.spark.metrics e ferramentas de monitoramento de desempenho.

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

O compartilhamento de dados tornou-se mais fácil hoje em dia, portanto, proteger informações sensíveis e confidenciais é uma boa maneira de evitar vazamentos de dados. Uma das práticas recomendadas que podemos seguir é aplicar a criptografia de dados durante o processamento e o armazenamento.

No PySpark, podemos conseguir isso usando as funções aes_encrypt() e aes_decrypt() para colunas em um DataFrame. Também podemos usar outra biblioteca, como a biblioteca de criptografia, para atingir esse objetivo.

Descrever como usar o PySpark para criar e implementar um modelo de aprendizado de máquina.

O PySpark nos fornece a biblioteca MLIib, uma biblioteca de aprendizado de máquina dimensionável para criar e implantar modelos de aprendizado de máquina 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 do Spark, podemos implementar modelos de ML baseados no PySpark na produção usando inferência em lote ou em fluxo contínuo. 

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

As operações de embaralhamento ocorrem quando os dados são redistribuídos entre as partições e podem ser dispendiosas em termos de desempenho. Para otimizar os embaralhamentos:

• Use o repartition() estrategicamente para equilibrar as partições antes de operações caras, como uniões.
• Prefira coalesce() em vez de repartition() ao reduzir partições, pois isso minimiza a movimentação de dados.
• Transmita tabelas menores usando broadcast() antes de uni-las a tabelas grandes para evitar operações que exijam muito embaralhamento.
• Ajuste as configurações do Spark, como spark.sql.shuffle.partitions, para otimizar o número de partições para operações de embaralhamento.

Perguntas da entrevista do PySpark para um engenheiro de dados

Se você estiver sendo entrevistado para uma função de engenharia de dados, espere perguntas que avaliem sua capacidade de projetar, otimizar e solucionar problemas de aplicativos PySpark em um ambiente de produção. Vamos nos aprofundar em algumas perguntas típicas de entrevistas que você pode encontrar.

Descreva como você otimizaria um trabalho do PySpark que está sendo executado lentamente. Quais são os principais fatores que você observaria?

Se um trabalho do PySpark estiver lento, há vários aspectos que podemos melhorar para otimizar seu desempenho:

• Garantir um tamanho e um número adequados de partições de dados para minimizar o embaralhamento de dados durante as transformações.
• Usar DataFrames em vez de RRDs porque eles já usam vários módulos de otimização para melhorar o desempenho das cargas de trabalho do Spark.
• Usando uniões de difusão e variáveis de difusão para unir um conjunto de dados pequeno a um conjunto de dados maior.
• Armazenamento em cache e persistência de DataFrames intermediários que são reutilizados.
• Ajustar o número de partições, núcleos de executor e instâncias para usar efetivamente os recursos do cluster.
• Escolher os formatos de arquivo apropriados para minimizar o tamanho dos dados.

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

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

• Usar o Checkpointing para salvar os dados em determinados pontos.
• Replicar nossos dados salvando-os em diferentes máquinas.
• Manter um registro das alterações realizadas em nossos dados antes que elas aconteçam.
• Realização de verificações de validação de dados para verificar se há erros.
• Escolher o nível correto de persistência.
• Usar a tolerância a falhas integrada do Spark para repetir automaticamente as tarefas que falharem.

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

Podemos implementar e gerenciar aplicativos PySpark usando as seguintes ferramentas:

• YARN: um gerenciador de recursos que nos ajuda a implementar e gerenciar os aplicativos em clusters do Hadoop
• Kubernetes: O Spark oferece suporte para implantar os aplicativos usando clusters Kubernetes
• Databricks: Ele fornece uma plataforma totalmente gerenciada para aplicativos PySpark, abstraindo a complexidade do gerenciamento de clusters.

Para saber mais sobre o Databricks, confira este curso de Introdução ao Databricks.

Você também pode saber mais sobre o Kubernetes neste tutorial sobre Containerization: Docker e Kubernetes para aprendizado de máquina.

Como você monitoraria e solucionaria problemas de trabalhos do PySpark em execução em um ambiente de produção?

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

• IU do Spark: Uma interface de usuário baseada na Web que nos ajuda a monitorar o progresso do trabalho, a utilização de recursos e a execução de tarefas.
• Registro em log: Podemos configurar o registro em log para capturar informações detalhadas sobre os erros e avisos.
• Métricas: Podemos usar sistemas de monitoramento para coletar e analisar métricas relacionadas à saúde do cluster e ao desempenho do trabalho.

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 refere-se ao fornecimento antecipado e constante de recursos fixos, como memória do executor e núcleos, durante toda a duração do aplicativo. Por outro lado, 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 os custos.

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

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

• Use DataFrames quando:
  • Você precisa de processamento de dados estruturados com base em esquemas.
  • Você deseja uma execução otimizada com o Catalyst e o Tungsten.
  • Você trabalha com consultas SQL e transformações incorporadas.
• Use RDDs quando:
  • Você precisa de transformações de baixo nível e controle refinado sobre os cálculos.
  • Você está trabalhando com dados não estruturados ou semiestruturados.
  • Você precisa de mais flexibilidade na definição de transformações.

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

O processamento incremental é essencial para lidar com eficiência com conjuntos de dados que crescem continuamente. Ele pode ser implementado por você:

• Usando o Delta Lake: O armazenamento de atualizações no formato Delta permite o tratamento eficiente de alterações incrementais.
• Uso de marca d'água com streaming estruturado: Ajuda a descartar dados antigos enquanto mantém agregações com estado.
• Particionamento e filtragem: Carregar somente dados novos ou modificados em vez de reprocessar tudo.
• Usando o site checkpointing: Salva resultados intermediários para evitar o reprocessamento do zero em caso de falha.

Conclusão

Neste artigo, abordamos uma ampla gama de perguntas de entrevistas sobre o PySpark, abrangendo tópicos básicos, intermediários e avançados. Desde a compreensão dos principais conceitos e vantagens do PySpark até a análise de otimizações mais complexas e técnicas de solução de problemas, exploramos as principais áreas sobre as quais os possíveis empregadores podem fazer perguntas.

Se você precisar 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
• Aprendizado de máquina com PySpark