Spark : méthodes de base DataFrame /Blog

DataFrame est une abstraction clé dans Spark qui représente des données structurées et permet une manipulation et une analyse faciles. Dans cet article de blog, nous explorerons les différentes méthodes DataFrame de base disponibles dans Spark et comment elles peuvent être utilisées pour des tâches de traitement de données à l’aide d’exemples.

Base de données:

Il existe de nombreuses méthodes DataFrame qui sont sous-classées en Transformation et Action en fonction de l’opération effectuée, vous pouvez en apprendre davantage à ce sujet dans ce blog – Opérations Spark RDD (perficient.com). Voyons quelques-uns des plus basiques et régulièrement utilisés. La plupart d’entre eux doivent être importés à partir de packages Spark. Dans les exemples, les instructions d’importation se trouvent en haut et celles que nous allons voir ci-dessous sont presque des fonctions SQL qui sont incorporées sur un DataFrame.

Affichage des données avec dans le DataFrame :

montrer:

.montrer() consiste à afficher les données du dataframe. Cela peut être utilisé lors de l’utilisation à partir du bloc-notes ou lors de l’exécution d’une tâche également.

afficher:

afficher() peut être utilisé lorsque nous avons besoin d’afficher les données dans un bloc-notes, cela ne peut pas être utilisé lors de l’exécution d’un travail.

Sélection et filtrage à partir du DataFrame :

sélectionner:

.sélectionner() La méthode peut être utilisée pour sélectionner les colonnes dont nous avons besoin dans le dataframe, l’exemple ci-dessus montre une sélection d’une colonne particulière du dataframe. Nous pouvons sélectionner plusieurs colonnes en ajoutant à l’instruction select comme

df.select("country","capital")

tête:

.tête() La méthode peut être utilisée pour obtenir la première ligne de la trame de données qui peut être utilisée lorsque nous avons besoin de valeurs maximales ou minimales d’une colonne particulière.

prendre:

.prendre() La méthode nous fournit les lignes mentionnées en haut du DataFrame.

queue:

.queue() La méthode nous fournit les lignes mentionnées à partir du bas du DataFrame.

filtre:

.filtre() La méthode peut être utilisée pour filtrer la colonne en fonction de la colonne. Nous pouvons fournir la syntaxe à la manière de SQL elle-même dans la méthode de filtrage.

baisse:

.baisse() La méthode peut être utilisée pour supprimer une colonne particulière ou un ensemble de colonnes du dataframe. La syntaxe pour supprimer plusieurs colonnes serait –

df.drop("column1","column2")

Nombre de trames de données :

compter:

.compter La méthode nous donne le nombre de DataFrame. Nous pouvons également utiliser les méthodes select et distinct pour trouver le nombre distinct d’une colonne particulière avec cette syntaxe

df.select("column_name").distinct.count

Manipulation de données sur DataFrame :

avecColonne :

.withColumn() consiste à ajouter ou modifier une colonne existante avec une transformation. Si la colonne existe, la transformation sera appliquée à cette colonne elle-même. Si la colonne n’est pas présente, il y aura une nouvelle colonne qui sera ajoutée à la fin du dataframe avec la transformation.

avecColonneRenommée :

.withColumnRenamed() consiste à modifier le nom de la colonne existante en une nouvelle colonne où le nom de la colonne à transformer sera donné en premier et la colonne de sortie souhaitée sera en dernier.

supérieur:

supérieur() est de changer la casse d’une colonne en majuscules.

inférieur:

inférieur() est de changer la casse d’une colonne en minuscule.

allumé :

allumé() peut être utilisé pour ajouter ou modifier une colonne avec une valeur codée en dur.

casting:

casting() La méthode consiste à changer le type de données d’une colonne d’un type de données à un autre.

na.fill :

.by.fill(«  ») est utilisé pour remplir les colonnes nulles avec des valeurs.

sous-chaîne :

sous-chaîne() est utilisé pour sous-chaîner une colonne.

longueur:

longueur() est de déterminer la longueur de la colonne.

concaténer :

concaténer() consiste à additionner deux chaînes ensemble.

garniture:

garniture() peut être utilisé pour supprimer les espaces dans la colonne. Si un côté particulier doit être coupé, alors rtrima et ltrim peuvent être utilisés.

Distinct et Union sur DataFrame :

syndicat:

unoin() dans DataFrame vous donnera toutes les valeurs du DataFrame contrairement à l’union SQL où cela ne donnerait que des valeurs distinctes. Pour obtenir les valeurs distinctes que nous pouvons utiliser. fonction distincte.

distinct:

distinct() dans DataFrame renverra les lignes distinctes du dataframe.

Tri et classement sur DataFrame :

commandé par:

commandé par peut être utilisé sur un DataFrame pour trier sur une colonne particulière. Par défaut, Spark triera par ordre croissant, nous pouvons explicitement appeler .desc dans l’ordre décroissant.

Optimisation et performances :

repartition:

Vous pouvez utiliser repartition pour augmenter ou diminuer le nombre de partitions dans le DataFrame. Pour plus d’informations à ce sujet, vous pouvez le trouver sur le blog intitulé Partition Spark : un aperçu / Blogs / Perficient

Il existe d’autres méthodes d’optimisation, comme la persistance et le cache, sur lesquelles vous pouvez en savoir plus sur ce blog : Spark : Niveaux de stockage de persistance / Blogs / Perficient

Rejoint :

Les DataFrames peuvent être joints les uns aux autres en utilisant la syntaxe ci-dessous :

df1.join(df2,df1("col1") == df2("col2"),"inner")

Apprenez-en davantage sur les jointures DataFrame dans cet article de blog intitulé : Spark : jointures Dataframe / Blogs / Perficient

Les références:

Documentation officielle Spark : https://spark.apache.org/docs/2.3.0/sql-programming-guide.html

Le guide Databricks DataFrame est disponible sur https://www.databricks.com/spark/getting-started-with-apache-spark/dataframes

En conclusion, ce blog fournit quelques méthodes de base ainsi que sa syntaxe et des exemples.