PySpark é uma linguagem que dataframes permite aos usuários interagir com um back-end Apache Spark para processar dados rapidamente.

...

É altamente recomendável evitar o uso de UDFS em todas as situações, pois são drasticamente menos performáticas do que Pyspark nativo. Na maioria das situações a lógica que parece exigir uma UDF, pode ser refatorada para usar apenas funções nativas Pyspark.

Joins

Cuidado com os joins! Se você executar um left join e o lado direito tiver matches múltiplos para uma key, essa linha será duplicada quantas vezes houver correspondência. Sempre verifique suas suposições para ver se a chave na qual você está fazendo o join é única a menos que fvocê esteja esperando ao menos que esteja esperando a multiplicação de linhas.

Joins ruins são as fonte de múltiplos problemas difíceis de depurar. Algumas práticas podem ajudar como declarar o how explicitamente, mesmo se você estiver utilizando o join default (inner):

# ruim 
flights = flights.join(aircraft, 'aircraft_id')

# ruim também
flights = flights.join(aircraft, 'aircraft_id', 'inner')

# bom
flights = flights.join(aircraft, 'aircraft_id', how='inner')

Encadeamento de expressões

Evite encadear expressões em expressões de várias linhas com tipos diferentes, principalmente se tiverem comportamentos ou contextos diferentes. Por exemplo, misturando a criação de colunas ou fazendo joining com select e filter.

# ruim
df = (
    df
    .select('a', 'b', 'c', 'key')
    .filter(F.col('a') == 'truthiness')
    .withColumn('boverc', F.col('b') / F.col('c'))
    .join(df2, 'key', how='inner')
    .join(df3, 'key', how='left')
    .drop('c')
)

# melhor (seperarando em steps)
# primeiro: selecionamos e filtramos os dados que precisamos
# segundo: criamos as colunas que precisamos
# terceiro: joining com outros dfs

df = (
    df
    .select('a', 'b', 'c', 'key')
    .filter(F.col('a') == 'truthiness')
)

df = df.withColumn('boverc', F.col('b') / F.col('c'))

df = (
    df
    .join(df2, 'key', how='inner')
    .join(df3, 'key', how='left')
    .drop('c')
)

Ter cada grupo de expressões isolado em seu bloco de códico lógico melhora a legibilidade e torna mais fácil encontrar a lógica relevante.

# ruim
df = (
    df
    .select('foo', 'bar', 'foobar', 'abc')
    .filter(F.col('abc') == 123)
    .join(another_table, 'some_field')
)

# melhor
df = (
    df
    .select('foo', 'bar', 'foobar', 'abc')
    .filter(F.col('abc') == 123)
)

df = df.join(another_table, 'some_field', how='inner')

Expressões de várias linhas

A razão pela qual você pode encadear expressões é porque o Pyspark foi desenvolvido a partir do Spark, que vem das linguagens JVM. Isso significou que alguns padrões de design foram transportados, especificamente para cadeiabilidade. No entanto, Python não suporta expressões de várias linhas normalmente e as únicas maneiras são fornecer quebras de linhas explícitas ou colocar a expressão entre parênteses. Você só precisa fornecer quebras explícitas se a cadeia ocorrer no nó raiz. Por exemplo:

# ruim
df = df.filter(F.col('event') == 'executing')\
    .filter(F.col('has_tests') == True)\
    .drop('has_tests')

# bom
df = (
  df
  .filter(F.col('event') == 'executing')
  .filter(F.col('has_tests') == True)
  .drop('has_tests')
)

Para manter a consistência, envolva a expressão em um único bloco de parênteses e evite usar \