PySpark Read CSV: Carregue e processe arquivos grandes com eficiência

Os arquivos CSV são pilares essenciais no processamento e na análise de dados. Quase todos os profissionais de dados, desde engenheiros de dados intermediários e cientistas de dados até desenvolvedores que utilizam o PySpark, acabam lidando com arquivos CSV em algum momento. No entanto, à medida que os conjuntos de dados aumentam de megabytes para gigabytes, ou mesmo para terabytes e além, ferramentas simples e únicas, como o Pandas ou as bibliotecas padrão do Python, têm dificuldade para lidar com a carga. É nesse ponto que o Apache Spark e o PySpark se tornam importantes para o gerenciamento de arquivos CSV em grande escala em ambientes de computação distribuída.

Este artigo ensinará tudo o que você precisa saber ao ler grandes arquivos CSV com o PySpark. 

Certifique-se de que você tenha o PySpark instalado e que esteja familiarizado com os conceitos básicos seguindo nosso tutorial Getting Started with PySpark. 

O que é ler CSV no PySpark?

O PySpark permite que os usuários leiam arquivos CSV em DataFrames distribuídos. Os DataFrames no PySpark são muito parecidos com os DataFrames do Pandas, fornecendo uma interface familiar. No entanto, sob a superfície, os DataFrames do PySpark distribuem a computação e o armazenamento em vários nós, proporcionando um desempenho excepcional para conjuntos de dados maciços. 

O PySpark oferece vantagens atraentes para arquivos CSV grandes, como:

• Carregamento de dados distribuídos,
• Tratamento robusto de valores nulos,
• Flexibilidade na definição do esquema e
• Maneiras simples de gerenciar arquivos CSV múltiplos ou compactados.

No entanto, surgem desafios comuns, incluindo o tratamento eficiente de cabeçalhos, a inferência ou especificação precisa de esquemas e o gerenciamento de registros malformados ou inconsistentes. Continue lendo para descobrir como você pode lidar com todos esses desafios. 

A leitura de arquivos CSV no PySpark é um dos tópicos que você deve entender para ser aprovado em uma entrevista com o PySpark. As 36 principais perguntas e respostas da entrevista sobre PySpark para 2025 fornecem um guia abrangente de perguntas e respostas da entrevista sobre PySpark, abrangendo tópicos desde conceitos básicos até técnicas avançadas e estratégias de otimização.  

Fundamentos da leitura de arquivos CSV no PySpark

A leitura de dados CSV é frequentemente uma das etapas iniciais e mais críticas nos fluxos de trabalho do PySpark, formando a base para transformações subsequentes, análise exploratória e tarefas de machine learning. A execução correta dessa etapa garante um processamento de dados mais limpo e um melhor desempenho downstream.

Estrutura conceitual

O PySpark lê arquivos CSV dentro do modelo distribuído do Spark. Em vez de ler dados CSV inteiramente na memória em uma única máquina, o Spark divide tarefas de dados grandes em vários nós de cluster. O otimizador Catalyst incorporado do Spark melhora ainda mais o desempenho, executando com eficiência as operações subjacentes necessárias durante a ingestão de CSV.

Sintaxe de leitura principal

A maneira mais simples de ler arquivos CSV envolve as funções incorporadas do Spark: 

spark.read.csv("file_path", header=True, inferSchema=True)

Ou explicitamente:

spark.read.format("csv").option("header", "True").load("file_path")

Os principais parâmetros incluem:

• file_path - local dos arquivos CSV.
• header - Defina os nomes das colunas a partir dos cabeçalhos CSV se True.
• inferSchema - infere automaticamente os tipos de dados da coluna.
• delimiter - caractere que separa as colunas; o padrão é vírgula.

Em nosso tutorial Learn PySpark From Scratch in 2025 , você encontrará mais detalhes sobre os fundamentos do PySpark e como aprendê-lo. 

Leitura de arquivos CSV: Opções e configurações

O PySpark fornece opções abrangentes que proporcionam controle granular sobre o processo de leitura de CSV.

Inferência de cabeçalho e esquema

A configuração header=True instrui o Spark a usar a primeira linha do CSV como nomes de coluna.

inferSchema=True  permite que o Spark adivinhe automaticamente os tipos de coluna, examinando seus dados:

spark.read.csv("customers.csv", header=True, inferSchema=True)

Embora a inferência de esquema seja conveniente e eficaz no início, os grandes conjuntos de dados sofrem redução de desempenho, pois o Spark faz repetidas passagens sobre os dados para determinar os tipos de dados.

Especificação de esquema personalizado 

Ao definir explicitamente seu esquema, você melhora significativamente o desempenho, eliminando as varreduras de dados repetidas do Spark. Um esquema definido comunica os nomes e tipos de coluna antecipadamente.

Aqui está como você pode definir um esquema personalizado no PySpark:

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, DoubleType
schema = StructType([
    StructField("user_id", IntegerType(), True),
    StructField("name", StringType(), True),
    StructField("score", DoubleType(), True),
])
df = spark.read.csv("customers.csv", schema=schema, header=True)

A seguir, vamos explorar a manipulação de delimitadores no PySpark ao ler arquivos CSV. 

Manipulação de delimitadores e caracteres especiais

Muitos arquivos CSV usam delimitadores diferentes de vírgulas, como pipes ou tabulações. O PySpark permite que você especifique o delimitador explicitamente:

spark.read.csv("customers.csv", header=True, delimiter="|")

Além disso, os caracteres de escape e aspas também podem ser configurados para lidar com cenários de caracteres especiais:

spark.read.csv("data.csv", header=True, escape='\"', quote='"')

Gerenciar valores nulos e ausentes

Os dados CSV do mundo real frequentemente contêm inconsistências ou registros incompletos. O PySpark simplifica a manipulação de valores nulos traduzindo placeholders personalizados em valores nulos:

spark.read.csv("customers.csv", header=True, schema=schema, nullValue="NA")

Isso esclarece os valores nulos, reduzindo drasticamente a limpeza manual de dados posteriormente.

Vamos explorar outras estratégias para lidar com valores nulos. 

Você pode decidir filtrar os valores nulos: 

# Filter rows where Age is not null
df_filtered = df.filter(df["Age"].isNotNull())
df_filtered.show()

Isso filtra o DataFrame para que você inclua apenas as linhas em que a coluna Age não seja nula. O resultado deve ser semelhante:

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  3|  Bob| 30|  NULL|
|  4|Carol| 28| 55000|
+---+-----+---+------+

A outra estratégia é preencher os valores nulos: 

# Replace null values in Age and Salary with default values
df_filled = df.na.fill({"Age": 0, "Salary": 0})
df_filled.show()

O resultado terá a seguinte aparência: 

+---+-----+---+------+
| ID| Name|Age|Salary|
+---+-----+---+------+
|  1| John| 25| 50000|
|  2|Alice|  0| 60000|
|  3|  Bob| 30|     0|
|  4|Carol| 28| 55000|
|  5|David|  0| 48000|
+---+-----+---+------+

Leitura de vários arquivos e diretórios

O PySpark é excelente no gerenciamento de conjuntos de dados grandes e com vários arquivos. Em vez de carregar e mesclar manualmente os arquivos de um diretório sequencialmente, o PySpark oferece suporte a padrões curinga para um carregamento em massa rápido e eficiente:

spark.read.csv("/data/sales/*.csv", header=True, schema=schema)

Isso agrega efetivamente vários arquivos CSV em um DataFrame em uma operação única e simplificada.

Depois que os dados são carregados no PySpark, as próximas etapas incluem a organização, a engenharia de recursos e a criação de modelos de machine learning. Nosso curso Feature Engineering with PySpark aborda esses conceitos em profundidade. 

Técnicas de otimização para leitura eficiente de CSV

Ao lidar com dados CSV em grande escala, é fundamental aproveitar as estratégias de otimização do PySpark.

Estratégias de particionamento

O particionamento influencia muito o desempenho ao distribuir uniformemente os dados entre os nós do cluster. O Spark permite o controle explícito do tamanho e do número da partição durante a ingestão de dados para ajudar a acelerar as operações subsequentes:

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

​​.repartition(20) divide o DataFrame em 20 partições no cluster do Spark. Como o Spark processa os dados em partes, você pode ter mais partições:

• Melhorar o paralelismo
• Equilibrar a carga de trabalho no cluster
• Acelere as transformações e gravações

Se você estiver executando em um cluster com muitos núcleos, isso ajudará a fazer uso total deles. Mas você pode tornar as coisas mais lentas se exagerar (digamos, 1.000 partições em um conjunto de dados pequeno).

Descubra mais funções do Spark, como repartition , com nossa Folha de dicas do PySpark : Spark em Python. Nele, você encontrará detalhes sobre a inicialização do Spark em Python, o carregamento de dados, a classificação e o reparticionamento. 

Armazenamento em cache e persistência

Se o seu fluxo de trabalho envolve acessar repetidamente o mesmo conjunto de dados após a ingestão, o armazenamento em cache do DataFrame na memória ou no disco pode aumentar significativamente o desempenho:

df.cache()

No entanto, lembre-se de que o armazenamento em cache requer recursos suficientes do sistema; sempre equilibre o uso da memória com os ganhos de desempenho.

Avaliação preguiçosa e ações de acionamento

O PySpark se baseia em um modelo de avaliação preguiçoso: as operações de DataFrame transformam os planos em vez de executá-los imediatamente. A leitura real do arquivo é executada somente quando necessário, acionada por comandos como show(), count(), ou collect():

# no reading yet
df = spark.read.csv("data.csv", header=True, schema=schema)   
# actual read triggered here
df.show(5)  

Casos de uso avançados e considerações

Vamos explorar cenários mais complexos que você pode encontrar ao ler arquivos CSV: 

Leitura de arquivos CSV compactados

O Spark gerencia com eficiência arquivos CSV compactados, como gz ou .bz2, de forma transparente, sem configurações adicionais:

spark.read.csv("logs.csv.gz", header=True, schema=schema)

Manipulação de registros malformados

Os conjuntos de dados CSV podem conter linhas malformadas. O PySpark oferece várias opções para ajudar você a gerenciar erros ou registros malformados de forma elegante:

• mode="PERMISSIVE" (padrão): inclui linhas malformadas com colunas preenchidas com valor nulo.
• mode="DROPMALFORMEDNão há necessidade de usar o recurso de "pular" registros malformados. Esse modo não é compatível com as funções integradas de CSV.
• mode="FAILFAST": lança uma exceção ao encontrar qualquer registro malformado.

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

Configurações de localidade e codificação

Às vezes, os dados CSV usam codificações fora do padrão. O PySpark lida facilmente com codificações variadas por meio do parâmetro encoding:

spark.read.csv("data_utf8.csv", header=True, encoding="UTF-8")

As codificações suportadas incluem, US-ASCII, ISO-8859-1, UTF-8, UTF-16BE, UTF-16LE, e UTF-16.

Práticas recomendadas e armadilhas comuns

Aqui estão algumas práticas recomendadas que você deve ter em mente ao ler arquivos CSV com o Spark: 

• Especifique explicitamente o esquema sempre que a estrutura do conjunto de dados for conhecida.
• Controle o particionamento para distribuir com eficiência a carga de trabalho.
• Cache estratégico para DataFrames acessados com frequência.
• Acione as ações de leitura intencionalmente, atento à avaliação preguiçosa.

Certifique-se de evitar: 

• Configuração de header=False para CSVs com linhas de cabeçalho.
• Depender exclusivamente do inferSchema em conjuntos de dados grandes ou acessados repetidamente.
• Ignorar configurações críticas de delimitador ou codificação.

Conclusão

Compreender e aproveitar adequadamente os poderosos recursos de ingestão de CSV do PySpark é essencial para o processamento eficaz de Big Data. Com a especificação clara de esquemas, a manipulação de formatos nulos personalizados, o uso de particionamento eficiente e o gerenciamento de cenários de arquivos compactados ou múltiplos, seu fluxo de trabalho se torna otimizado e eficiente.

Lembre-se de que, embora o PySpark ofereça enormes vantagens para tarefas de dados em grande escala, ferramentas mais simples, como o Pandas, ainda podem ser suficientes para pequenos conjuntos de dados. Utilize o PySpark ao trabalhar com dados que ultrapassam os recursos de uma única máquina e sempre considere suas vantagens de computação distribuída.

Para explorar mais o PySpark, confira nossos cursos detalhados sobre o Spark, incluindo:

• Introdução ao PySpark
• Fundamentos do PySpark 
• Fundamentos de Big Data com PySpark
• Criando mecanismos de recomendação com o PySpark