Cours Spark
Cours Spark
Cours Spark
«
What is Apache Spark™?
Apache Spark™ is a multi-language engine for executing data engineering, data science, and machine learning on
single-node machines or clusters.
»
Apache Spark est un moteur d'analyse unifié pour le traitement de données à grande échelle. Il fournit des API de haut
niveau en Java, Scala, Python et R, ainsi qu'un moteur optimisé prenant en charge les graphiques d'exécution. Il
prend également en charge un riche ensemble d'outils de niveau supérieur, notamment Spark SQL pour SQL et le
traitement des données structurées, MLlib pour l'apprentissage automatique, GraphX pour le traitement des graphes
et Structured Streaming pour le calcul incrémentiel etle traitement des flux.
Apache Spark a débuté en tant que projet de recherche à l'AMPLab de l'UC Berkeley en 2009 et était opensource au
début de 2010. De nombreuses idées derrière le système ont été présentées dans divers documents de recherche au fil
des ans.
Après sa sortie, Spark est devenu une vaste communauté de développeurs et a rejoint Apache SoftwareFoundation en
2013. Aujourd'hui, le projet est développé en collaboration par une communauté de centaines de développeurs issus de
centaines d'organisations.
Il est conçu pour des performances rapides et utilise la RAM pour la mise en cache et le traitement desdonnées.
Spark exécute différents types de charges de travail Big Data. Cela inclut le traitement par lots de type MapReduce,
ainsi que le traitement de flux en temps réel, l'apprentissage automatique, le calcul de grapheset les requêtes
interactives. Avec des API de haut niveau faciles à utiliser, Spark peut s'intégrer à de nombreuses bibliothèques
différentes, notamment PyTorch et TensorFlow. (Ce sont deux bibliothèques de
Deep Learning)
Le moteur Spark a été créé pour améliorer l'efficacité de MapReduce et conserver ses avantages. Même si Spark n'a pas
son système de fichiers, il peut accéder aux données sur de nombreuses solutions de stockage différentes. La
structure de données utilisée par Spark est appelée Resilient Distributed Dataset,ou RDD.
Spark est un moteur de traitement rapide et général compatible avec les données Hadoop. Il peut s'exécuterdans des
clusters Hadoop via YARN ou le mode standalone de Spark, et il peut traiter des données dans HDFS, HBase,
Cassandra, Hive et n'importe quel format d'entrée Hadoop. Il est conçu pour effectuer à la foisun traitement par lots (batch
processing, similaire à MapReduce) et de nouvelles charges de travail telles que le streaming, les requêtes interactives
et l'apprentissage automatique.
Spark est considéré souvent comme un nouveau cadre de calcul dans l'écosystème de Hadoop. Bien sûr, ilpeut être
déployé seul sans Hadoop, et on le verra plus tard.
PySpark est une interface pour Apache Spark en Python. Il vous permet non seulement d'écrire des applications Spark à
l'aide des API Python, mais fournit également le shell PySpark pour analyser de manière interactive vos données dans
un environnement distribué. PySpark prend en charge la plupart desfonctionnalités de Spark telles que Spark SQL,
DataFrame, Streaming, MLlib (Machine Learning) et Spark Core.
1.3 Terminologies
Apache Spark - Une plate-forme de traitement de données open source conçue pour le traitement à grandevitesse en
mémoire. Pensé comme une alternative à MapReduce. Spark peut être une implémentation à un ou plusieurs nœuds.
Resilient Distributed Dataset — Également appelé RDD. C'est un jeu de données immuable. Cela signifie qu'il ne peut
pas être modifié au fil du temps. Les RDD peuvent être stockés sur disque ou en mémoire dansun cluster. Ils sont
tolérants aux pannes. Les modifications apportées aux RDD sont effectuées avec les opérations de transformation et
d'action.
Partition — Les données peuvent être réparties en unités logiques plus petites. Ces unités sont appeléespartitions.
Cluster Manager — Un service externe comme Yarn, Apache Mesos ou Spark Standalone Cluster. Lesgestionnaires de
cluster assurent la surveillance, la planification et la sécurité.
Worker Node — Également appelé nœud esclave. Les exécuteurs sont des nœuds de travail générés pendant la durée de
vie d'une application Spark. Le travail d'exécution sur les données dans le nœud et lerapport au nœud maître.
Application — Un programme d'utilisateurs construit sur le cluster Spark. Il se compose d'un programmepilote et des
exécuteurs sur le cluster.
Executor — Existent généralement sur un nœud de travail et implémentent des tâches. Ces tâches sont en mémoire ou sur
disque. Les tâches sont créées par le pilote et envoyées aux exécuteurs. Lorsque les exécuteurs ont terminé la tâche, ils
renvoient les résultats au pilote.
Driver Program — Un programme qui s'exécute sur un nœud maître. Il crée le SparkContext. Ils déclarent des
Transformations et des Actions sur le RDD’. C'est le processus où s'exécute la fonction Main(). Il convertitles processus
en tâches qui sont ensuite exécutées sur les exécuteurs.
Transformations - Les transformations créent de nouveaux RDD en fonction des opérations effectuées sur les RDD
existants. Il existe deux types de transformations : étroites et étendues.
Narrow Transformations — Tous les éléments requis pour calculer une partition vivent dans une partitionparent unique
d'un RDD.
Wide Transformations — Tous les éléments requis pour calculer une partition appartiennent à plusieurs partitions d'un
RDD.
Actions — Les actions sont des opérations qui produisent des valeurs non RDD. Ils déclenchent des transformations pour
renvoyer des valeurs. Exemples d'actions : compter, collecter, agréger, min, max oupremier.
Aujourd'hui, nous avons de nombreuses solutions gratuites pour le traitement du Big Data. De nombreusesentreprises
proposent également des fonctionnalités d'entreprise spécialisées pour compléter les plates- formes open source.
L'écosystème Hadoop
Hadoop prend en charge l'analyse avancée des données stockées (par exemple, l'analyse prédictive, l'exploration de
données, l'apprentissage automatique (ML), etc.). Il permet de diviser les tâches de traitement d'analyse de données
volumineuses en tâches plus petites. Les petites tâches sont effectuées enparallèle à l'aide d'un algorithme (par
exemple, MapReduce), puis sont réparties sur un cluster Hadoop (c'est-à-dire des nœuds qui effectuent des calculs
parallèles sur de grands ensembles de données).
Chaque machine d'un cluster stocke et traite les données. Hadoop stocke les données sur des disques à l'aide de
HDFS. Le logiciel offre des options d'évolutivité transparentes. Vous pouvez commencer avec une seule machine,
puis passer à des milliers, en ajoutant n'importe quel type de matériel d'entreprise ou de base.
Les sections suivantes décrivent les principales différences et similitudes entre les deux cadres. Nousexaminerons
Hadoop contre Spark sous plusieurs angles. Certains d'entre eux sont le coût, les performances, la sécurité et la
facilité d'utilisation.
Le tableau ci-dessous donne un aperçu des conclusions tirées dans les sections suivantes.
Catégorie de
comparaison Hadoop Spark
Hadoop Spark
Catégorie de
comparaison Hadoop Spark
Hadoop Spark
1.5.1 Performance
En accédant aux données stockées localement sur HDFS, Hadoop améliore les performances globales. Cependant,
cela ne correspond pas au traitement en mémoire de Spark. Selon les affirmations d'Apache,Spark semble être 100
fois plus rapide lors de l'utilisation de la RAM pour le calcul que Hadoop avec MapReduce.
La domination est de même avec le tri des données sur des disques. Spark était 3 fois plus rapide et nécessitait 10 fois
moins de nœuds pour traiter 100 To de données sur HDFS. Cette référence a été suffisantepour établir le record du
monde en 2014.
La principale raison de cette suprématie de Spark est qu'il ne lit pas et n'écrit pas de données intermédiaires sur les
disques mais utilise de la RAM. Hadoop stocke les données sur de nombreuses
sources différentes, puis traite les données par lots à l'aide de MapReduce.
Tout ce qui précède peut positionner Spark comme le gagnant absolu. Cependant, si la taille des données est
supérieure à la RAM disponible, Hadoop est le choix le plus logique. Un autre point à prendre en compteest le coût de
fonctionnement de ces systèmes.
1.5.2 coût
En comparant Hadoop à Spark en terme de coût, nous devons creuser plus loin que le prix du logiciel. Lesdeux plates-
formes sont open source et entièrement gratuites.
Néanmoins, les coûts d'infrastructure, de maintenance et de développement doivent être pris en comptepour obtenir un
coût total de possession (TCO) approximatif.
Le facteur le plus important dans la catégorie des coûts est le matériel sous-jacent dont vous avez besoin pour
exécuter ces outils. Étant donné que Hadoop s'appuie sur n'importe quel type de stockage sur disque pour le traitement
des données, le coût de son fonctionnement est relativement faible.
D'autre part, Spark dépend des calculs en mémoire pour le traitement des données en temps réel. Ainsi,faire tourner des
nœuds avec beaucoup de RAM augmente considérablement le coût de possession.
Une autre préoccupation est le développement d'applications. Hadoop existe depuis plus longtemps queSpark et il est
moins difficile de trouver des développeurs de logiciels.
Les points ci-dessus suggèrent que l'infrastructure Hadoop est plus rentable. Bien que cette affirmation soitcorrecte, nous
devons nous rappeler que Spark traite les données beaucoup plus rapidement. Par conséquent, il faut un plus petit
nombre de machines pour effectuer la même tâche.
Les deux frameworks traitent les données de manière assez différente. Bien que Hadoop avec MapReduce etSpark avec
RDD traitent les données dans un environnement distribué, Hadoop est plus adapté au traitement par lots. En revanche,
Spark brille par son traitement en temps réel.
L'objectif de Hadoop est de stocker des données sur des disques, puis de les analyser en parallèle par lots dans un
environnement distribué. MapReduce ne nécessite pas une grande quantité de RAM pour gérer degros volumes de
données. Hadoop s'appuie sur du matériel de tous les jours pour le stockage et convient mieux au traitement linéaire
des données.
Apache Spark fonctionne avec des ensembles de données distribués résilients (RDD). Un RDD est un ensemble
distribué d'éléments stockés dans des partitions sur des nœuds du cluster. La taille d'un RDD est généralement trop
grande pour être gérée par un nœud. Par conséquent, Spark partitionne les RDD sur les nœuds les plus proches et
effectue les opérations en parallèle. Le système suit toutes les actions effectuéessur un RDD à l'aide d'un graphe
acyclique dirigé (DAG).
Grâce aux calculs en mémoire et aux API de haut niveau, Spark gère efficacement les flux en direct de données
non structurées. De plus, les données sont stockées dans un nombre prédéfini de partitions. Un nœud peut avoir
autant de partitions que nécessaire, mais une partition ne peut pas s'étendre à un autrenœud.
1.5.4 Tolérance aux pannes
En parlant de Hadoop contre Spark dans la catégorie de tolérance aux pannes, nous pouvons dire que les deux offrent
un niveau suffisant de gestion des échecs. De plus, nous pouvons dire que leur approche de latolérance aux pannes est
différente.
Hadoop a la tolérance aux pannes comme base de son fonctionnement. Il réplique les données plusieursfois sur les
nœuds. En cas de problème, le système reprend le travail en créant les blocs manquants à partird'autres emplacements.
Les nœuds maîtres suivent l'état de tous les nœuds esclaves. Enfin, si un nœud esclave ne répond pas aux pings d'un
maître, le maître affecte les travaux en attente à un autre nœud esclave.
Spark utilise des blocs RDD pour atteindre la tolérance aux pannes. Le système suit la façon dont l'ensemblede données
immuable est créé. Ensuite, il peut redémarrer le processus en cas de problème. Spark peut reconstruire les données
dans un cluster en utilisant le suivi DAG des workflows. Cette structure de données permet à Spark de gérer les pannes
dans un écosystème de traitement de données distribué
1.5.5 Scalabilité
La frontière entre Hadoop et Spark devient floue dans cette section. Hadoop utilise HDFS pour gérer le BigData.
Lorsque le volume de données augmente rapidement, Hadoop peut rapidement évoluer pour répondre à la demande.
Étant donné que Spark n'a pas son système de fichiers, il doit s'appuyer sur HDFSlorsque les données sont trop
volumineuses pour être gérées.
Les clusters peuvent facilement s'étendre et augmenter la puissance de calcul en ajoutant plus de serveursau réseau. En
conséquence, le nombre de nœuds dans les deux frameworks peut atteindre des milliers. Il n'y a pas de limite ferme au
nombre de serveurs que vous pouvez ajouter à chaque cluster et à la quantité de données que vous pouvez traiter.
Certains des chiffres confirmés comportent 8 000 machines dans un environnement Spark avec des pétaoctets de
données. Quand on parle de clusters Hadoop, ils sont bien connus pour héberger des dizainesde milliers de machines et
près d'un exaoctet de données.
Spark est peut-être le cadre le plus récent avec moins d'experts disponibles que Hadoop, mais il est connupour être plus
convivial. En revanche, Spark prend en charge plusieurs langages en plus du langage natif (Scala) : Java, Python, R et
Spark SQL. Cela permet aux développeurs d'utiliser le langage de programmation qu'ils préfèrent.
Le framework Hadoop est basé sur Java. Les deux langages principaux pour écrire du code MapReduce sont Java ou
Python. Hadoop n'a pas de mode interactif pour aider les utilisateurs. Cependant, il s'intègre aux outils Pig et Hive
pour faciliter l'écriture de programmes MapReduce complexes.
En plus de la prise en charge des API dans plusieurs langues, Spark gagne avec son mode interactif. Vouspouvez
utiliser le shell Spark pour analyser les données de manière interactive avec Scala ou Python. Le shell fournit un
retour instantané aux requêtes, ce qui rend Spark plus facile à utiliser que Hadoop MapReduce.
1.5.7 Machine Learning
L'apprentissage automatique est un processus itératif qui fonctionne mieux en utilisant le calcul enmémoire. Pour cette
raison, Spark s'est avéré être une solution plus rapide dans ce domaine.
La raison en est que Hadoop MapReduce divise les travaux en tâches parallèles qui peuvent être trop volumineuses pour
les algorithmes d'apprentissage automatique. Ce processus crée des problèmes deperformances d'I/O dans ces
applications Hadoop.
La bibliothèque Mahout est la principale plate-forme d'apprentissage automatique des clusters Hadoop. Mahout
s'appuie sur MapReduce pour effectuer le regroupement, la classification et la recommandation. Samsara a
commencé à remplacer ce projet.
Spark est livré avec une bibliothèque d'apprentissage automatique par défaut, MLlib. Cette bibliothèque effectue des
calculs ML itératifs en mémoire. Il comprend des outils pour effectuer la régression, la classification, la persistance, la
construction de pipelines, l'évaluation et bien d'autres.
Spark avec MLlib s'est avéré neuf fois plus rapide qu'Apache Mahout dans un environnement basé sur disque Hadoop.
Lorsque vous avez besoin de résultats plus efficaces que ce qu'offre Hadoop, Spark est lemeilleur choix pour
l'apprentissage automatique.
Hadoop est bon marché : Bien qu'il soit open source et facile à configurer, le fonctionnement continu du serveur peut être
coûteux.
Hadoop est une base de données : Bien que Hadoop soit utilisé pour stocker, gérer et analyser des données distribuées,
aucune requête n'est impliquée lors de l'extraction des données. Cela fait de Hadoopun entrepôt de données plutôt
qu'une base de données.
Hadoop n'aide pas les PME : Le « Big data » n'est pas réservé aux « grandes entreprises ». Hadoop a des
fonctionnalités simples comme les rapports Excel qui permettent aux petites entreprises d'exploiter sa puissance.
Avoir un ou deux clusters Hadoop peut grandement améliorer les performances d'une petite entreprise.
Hadoop est difficile à configurer : Bien que la gestion de Hadoop soit difficile aux niveaux supérieurs, ilexiste de
nombreuses interfaces utilisateur graphiques (GUI) qui simplifient la programmation pour MapReduce.
Spark est une technologie en mémoire : Bien que Spark utilise efficacement l'algorithme le moins récemment
utilisé (LRU), il ne s'agit pas en soi d'une technologie basée sur la mémoire.
Spark fonctionne toujours 100 fois plus vite que Hadoop : Bien que Spark puisse fonctionner jusqu'à 100 fois plus vite que
Hadoop pour les petites charges de travail, selon Apache, il ne fonctionne généralement que jusqu'à 3 fois plus vite
pour les grandes.
Spark introduit de nouvelles technologies dans le traitement des données : Bien que Spark utilise efficacement
l'algorithme LRU et le traitement des données par pipeline, ces fonctionnalités existaient
auparavant dans les bases de données de traitement massivement parallèle (MPP). Cependant, ce quidistingue Spark de
MPP est son orientation open source.
En examinant Hadoop par rapport à Spark dans les sections ci-dessus, nous pouvons extraire quelques casd'utilisation
pour chaque framework.
Hadoop est plus efficace pour les scénarios impliquant les éléments suivants :
Traitement d'ensembles de données volumineux dans des environnements où la taille des donnéesdépasse la
mémoire disponible
Traitement par lots avec des tâches qui exploitent les opérations de lecture et d'écriture sur disqueConstruire une
infrastructure d'analyse de données avec un budget limité
Terminer des travaux qui ne sont pas urgents
Spark est plus efficace pour les scénarios impliquant les éléments suivants :
Hadoop et Spark sont des technologies de traitement du Big Data. En dehors de cela, ce sont des cadresassez différents
dans la façon dont ils gèrent et traitent les données.
Selon les sections précédentes, il semble que Spark soit le grand gagnant. Bien que cela puisse être vrai dans une
certaine mesure, en réalité, ils ne sont pas créés pour se faire concurrence, mais plutôt pour secompléter.
Bien sûr, comme nous l'avons indiqué plus haut dans cet article, il existe des cas d'utilisation où l'un ou l'autre
framework est un choix plus logique. Dans la plupart des autres applications, Hadoop et Spark fonctionnent mieux
ensemble. En tant que successeur, Spark n'est pas là pour remplacer Hadoop mais pourutiliser ses fonctionnalités pour
créer un nouvel écosystème amélioré.
En combinant les deux, Spark peut tirer parti des fonctionnalités qui lui manquent, comme un système de fichiers.
Hadoop stocke une énorme quantité de données à l'aide de matériel abordable et effectue ensuite des analyses, tandis
que Spark apporte un traitement en temps réel pour gérer les données entrantes. Sans Hadoop, les applications métier
peuvent manquer des données historiques cruciales que Spark ne gère pas.
Dans cet environnement coopératif, Spark tire également parti des avantages de Hadoop en matière desécurité et de
gestion des ressources. Avec YARN, le clustering Spark et la gestion des données sontbeaucoup plus faciles. Vous
pouvez exécuter automatiquement des charges de travail Spark à l'aide de toutes les ressources disponibles.
Cette collaboration fournit les meilleurs résultats en matière d'analyse rétroactive des données transactionnelles,
d'analyse avancée et de traitement des données IoT. Tous ces cas d'utilisation sontpossibles dans un environnement.
Les créateurs de Hadoop et Spark avaient l'intention de rendre les deux plates-formes compatibles et deproduire des
résultats optimaux adaptés à toutes les exigences de l'entreprise.
2 Utiliser Spark
1. Spark
https://www.apache.org/dyn/closer.lua/spark/spark-3.0.3/spark-3.0.3-bin-hadoop2.7.tgz
https://dlcdn.apache.org/spark/spark-3.0.3/spark-3.0.3-bin-hadoop2.7.tgz
2. Hadoop: Vous
pouvez :
extraire le fichier zip fourni avec le cours et le placer quelque part. Ex : C:\BigDataSoft\winutils-
master\hadoop-2.7.1. I
PS: Ici on a juste une petite dépendance à régler sur Windows. Dans le cadre de ce cours, on ne ferapas en mode
HADOOP + SPARK sur votre PC personnel. Le mode du déploiement StandAlone de SPARK ne dépend pas
de Hadoop. Donc théoriquement, nous n'avons pas besoin de HADOOP. En revanche, spark est fait pour être
utilisé sur des servers de Linux. Afin de faire fonctionner Spark surWindows, il nous faut donc ce petit
plugin de Hadoop dédié au OS Windows. Pour les élèves motivés, si vous voulez essayer HADOOP +
SPARK, vous pouvez télécharger une distribution complète sur le site
https://archive.apache.org/dist/hadoop/common . La version 2.7.X est recommendée
3. Java:
Vous pouvez
Lorsque tous les étapes sont terminées, tapezque spark-shell dans un environnement shell et vous verrez
Spark aura bien démarré.
C'est donc l'environnement interactif de Spark. Par défaut, le langage utilisé est en Scala.
Vous pouvez ensuite tapez la commande pyspark . Nous avons donc maintenant un environnement de
Spark en Python, dans lequel vous pouvez écrire du code Python. Mais comme on utilise un interpreteur du Python
dans Anaconda, ce mode d'emploi n'est pas bien configuré, donc non recommandée dans le cadre de ce cours. Et on
verra comment écrire du progamme Spark en Python dans Anaconda.
Gardez l'environnement du shell, dans un Web browser ouvrir la page http://localhost:4040/ . C'est donc unmoniteur
du cluster de Spark, bien qu'on n'ait qu'un seul Executor(équivalent au worker/slave) dans ce cluster qui est aussi son
propre Driver (équivalent au master)
2.2 Soumettre une tâche au cluster Spark en mode Local
On fait appel ici à une commande qui s'appelle spark-submit . Rapplons nous que le dossier spark-
3.0.3-bin-hadoop2.7\bin est ajouté dans le PATH du système par une concaténation de
%SPARK_HOME%\bin. En fait dans ce dossier, il y a un tas de commande de Spark, y compris spark-
shell, pyspark et spark-submit
Exécutons donc la commande suivant dans un shell (Attention! on n'est plus dans le mode interactif deSpark) en
utilisant votre chemin du fichier pi.py.
Par exemple:
Après environ 7.7 s, la valeur de Pi est estimé à 3.139 (Cette valeur est aléatoire, elle différente de chaqueexécution)
Le temps peut apparaître long pour faire ce petit calcul. Mais vous devez savoir que ce temps comporte letemps de
démarrage du server.
Voici le programme pi.py. Vous arrivez à le comprendre après l'étude des prochains chapitres.
2.3 Démarrage un cluster en mode StandAlone
Linux/mac OS
./sbin/start-master.sh
Une fois démarré, le maître imprimera une URL spark://HOST:PORT pour lui-même, que vous pouvez utiliser pour y
connecter les Workers, ou passer comme argument "maître" à SparkContext. Vous pouvez également trouver cette URL
sur l'interface utilisateur Web du maître, qui est http://localhost:8080 par défaut.
De même, vous pouvez démarrer un ou plusieurs workers et les connecter au master via :
./sbin/start-worker.sh <master-spark-URL>
Une fois que vous avez démarré un worker, regardez l'interface utilisateur Web du maître. Vous devriez voirle nouveau
nœud répertorié ici, ainsi que son nombre de processeurs et de mémoire (moins un gigaoctet restant pour le système
d'exploitation).
Windows:
Pour démarrer un serveur Worker, exécuter la commande suivante dans n'importe quelle machine dans leréseau
cluster. Ici on utilisera la même machine.
Dans le moniteur de Master http://localhost:8080/ , on peut voir qu'un noeud Worker est effectivementajouté dans
le cluster.
2.4 Soumettre une tâche au cluster Spark en mode StandAlone
Nous avons vu préalablement comment soumettre la tâche du calcul de Pi en mode local. De même, nous pouvons
soumettre cette tâche dans un cluster en mode StandAlone. La seule différence est donc la valeur du paramètre --
master.
nous avons donc effectué un calcul avec 100 itération au bout de 85s. La valeur de Pi estimé est donc 3.1408
Nous pouvons confirmer à travers le moniteur que cette tâche est bien ajouté dans notre cluster StandAlonedémarré
dans la section précédente.
en cours d'exécution
fin d'exécution
Préparez d'abord un fichier txt comme celui pour le MapReduce. J'ai saisi le contenu suivant pour
l'illustration et sauvegarder ce fichier sur le chemin C:\BigDataSoft\Input\words.txt
Hello Python
Hello Hadoop
Hello Spark
Spark SQL
Spark Streaming
Spark Flink
Spark Python
Spark Scala
Comme nous avons actuellement 2 copies de Pyspark(une dans la distribution complète de Spark que nous avons
téléchargée manuellement, l'autre dans l'environnement d'Anaconda que nous venons de téléchargerpar la commande),
nous utilisons le code suivant pour informer notre interprêteur Python quel spark il doit démarrer. Normalement si
vous avez bien configurer les variables d'environnement avec la bonne version de spark, on ne doit pas avoir du
soucis sur Windows. Il y a actuellement une petite incompatibilité de la version 3.2 avec Windows.
import findspark
findspark.init("C:\BigDataSoft\spark-3.0.3-bin-hadoop2.7")
from pyspark import SparkConf,SparkContext
la variable context sc est extrêmement importante dans la programmation en Spark. Elle est crée et
retenue automatique dans un environnement interactif Shell de Spark.
# read data from text file and split each line into words
file_rdd = sc.textFile("C:\\BigDataSoft\\Input\\Words.txt")
words_rdd = file_rdd.flatMap(lambda line: line.split(" "))
print(result_rdd.collect())
Exercice:
À un niveau élevé, chaque application Spark se compose d'un programme pilote(Driver) qui exécute la fonction
principale de l'utilisateur et exécute diverses opérations parallèles sur un cluster. La principale abstraction fournie
par Spark est un jeu de données distribué résilient (RDD), qui est une collection d'éléments partitionnés sur les
nœuds du cluster qui peuvent être exploités en parallèle. Les RDD sont créésen commençant par un fichier dans le
système de fichiers Hadoop (ou tout autre système de fichiers pris encharge par Hadoop), ou une collection Scala
existante dans le programme du pilote, et en le transformant. Les utilisateurs peuvent également demander à Spark de
conserver un RDD en mémoire, ce qui lui permet d'être réutilisé efficacement dans des opérations parallèles. Enfin,
les RDD récupèrent automatiquement après les pannes de nœud.
Calcul en mémoire
Spark utilise le calcul en mémoire pour accélérer le temps de traitement total. Dans le calcul en mémoire, les données
sont conservées dans la RAM (mémoire à accès aléatoire) au lieu des lecteurs de disque plus lents. Ceci est très utile
car il réduit le coût de la mémoire et permet la détection de modèles, analyse les données volumineuses plus
efficacement. Les principales méthodes qui l'accompagnent sont les méthodes
cache() et persist().
Immutabilité
Comme il est facile de partager les données immuables en toute sécurité entre plusieurs processus, cela s'avère être
une option très valable. L'immuabilité exclut simplement de nombreux problèmes potentielsdus à diverses mises à
jour à partir de différents threads à la fois. Il est plus sûr de partager des données immuables entre les processus. Mais,
les RDD ne sont pas seulement des fonctions immuables, mais aussi des fonctions déterministes de leurs entrées, ce
qui permet de recréer les parties RDD à n'importe quel moment donné. Nous pouvons considérer les RDD non
seulement comme une collection de données, maiscomme une recette pour créer de nouvelles données à partir
d'autres données.
Partitionnement
Les RDD sont généralement des collections de divers éléments de données de volumes massifs, qui ne peuvent
pas tenir dans un seul nœud et doivent être partitionnés sur plusieurs nœuds. Spark effectue automatiquement ce
partitionnement des RDD et distribue ces partitions sur différents nœuds. Les pointsclés liés à ces partitions sont
En augmentant le nombre d'exécuteurs sur le cluster, le parallélisme peut être augmenté dans lesystème.
3.2.1 RDD
Un RDD ou Resilient Distributed Dataset est la structure de données fondamentale réelle d'Apache Spark. Cesont des
collections immuables (en lecture seule) d'objets de différents types, qui calculent sur les différents nœuds d'un
cluster donné. Ceux-ci fournissent la fonctionnalité permettant d'effectuer des calculsen mémoire sur de grands clusters
de manière tolérante aux pannes. Chaque ensemble de données dans le RDD Spark est bien partitionné sur de nombreux
serveurs afin qu'ils puissent être calculés efficacement sur différents nœuds du cluster.
3.2.2 DataSet
Dans Apache Spark, l'ensemble de données est une structure de données dans Spark SQL qui est fortementtypée,
orientée objet et est une carte vers un schéma relationnel. Il représente une requête structurée avec des encodeurs et est
une extension de l'API Data-frame. Ceux-ci sont à la fois sérialisables et interrogeables,donc persistants par nature. Il
fournit une interface unique pour les langages Scala et Java. Cela réduit également la charge des bibliothèques.
3.2.3 DataFrame
On peut dire que les Data-Frames sont des Dataset organisés en colonnes nommées. Celles-ci sont très similaires à
la table d'une base de données relationnelle. L'idéologie est de permettre le traitement d'une grande quantité de
données structurées. Data-Frame contient des lignes avec un schéma où le schéma estl'illustration de la structure des
données. Il fournit une gestion de la mémoire et des plans d'exécution optimisés.
3.3 Création d'un RDD
“
Rappel:
Ensemble de données distribué résilient (Resilient Distributed Dataset, RDD), qui est une collection d'éléments
tolérants aux pannes qui peuvent être utilisés en parallèle. Il existe trois façons de créer des RDD
: paralléliser une collection existante dans votre programme de pilote ou référencer un ensemble de données dans un
système de stockage externe, tel qu'un système de fichiers partagé, HDFS, HBase ou toutesource de données offrant un
Hadoop InputFormat, et créer un RDD à partir d'un RDD existant
Les collections parallélisées sont créées en appelant la méthode parallelize de SparkContext sur un
itérable ou une collection existante dans votre programme de pilote. Les éléments de la collection sontcopiés
pour former un jeu de données distribué qui peut être exploité en parallèle. Par exemple, voici comment créer une
collection parallélisée contenant les nombres 1 à 5 :
data = [1, 2, 3, 4, 5]
distData = sc.parallelize(data)
Les RDD de fichiers texte peuvent être créés à l'aide de la méthode textFile de SparkContext. Cette
méthode prend un URI pour le fichier (soit un chemin local sur la machine, soit un URI hdfs://, s3a://, etc.) etle lit
comme une collection de lignes. Voici un exemple d'invocation :
distFile = sc.textFile("data.txt")
Si vous utilisez un chemin sur le système de fichiers local, le fichier doit également être accessible aumême chemin
sur les noeuds worker. Copiez le fichier sur tous les nœuds de calcul ou utilisez un système de fichiers partagé
monté sur le réseau.
Toutes les méthodes d'entrée basées sur des fichiers de Spark, y compris textFile, prennent égalementen charge
l'exécution sur des répertoires, des fichiers compressés et des caractères génériques. Par exemple, vous pouvez
utiliser textFile("/my/directory"), textFile("/my/directory/ .txt") et textFile("/my/directory/ .gz").
La méthode textFile prend également un deuxième argument facultatif pour contrôler le nombre de partitions du
fichier. Par défaut, Spark crée une partition pour chaque bloc du fichier (les blocs étant de 128 Mo par défaut
dans HDFS), mais vous pouvez également demander un nombre de partitions plus élevé en passant une valeur
plus grande. Notez que vous ne pouvez pas avoir moins de partitionsque de blocs.
La transformation transforme un RDD en un autre, et le changement est le moyen de créer un RDD à partir d'un RDD
existant. Cela crée une différence entre Apache Spark et Hadoop MapReduce. La conversion fonctionne comme celle
qui absorbe un RDD et en produit un. Le RDD d'entrée ne change pas et, comme lesRDD sont immuables, il génère des
RDD variables en appliquant des opérations.
Il existe deux opérations de transformations et d'actions Apache Spark RDD. Une transformation est une fonction qui
produit un nouveau RDD à partir des RDD existants. Il prend un RDD en entrée et génère un ouplusieurs RDD en
sortie. Chaque fois qu'il crée un nouveau RDD lorsque nous appliquons une transformation. Ainsi, tous les RDD
d'entrée ne peuvent pas être modifiés car les RDD sont immuables.
Produit un DAG qui garde une trace de quel RDD a été créé lors du cycle de vie.Exemple :
Transformations étroites : dans ce type, tous les éléments nécessaires pour calculer les enregistrementsd'une seule
partition résident dans cette seule partition. Ici, nous utilisons un sous-ensemble limité departition pour calculer
le résultat. Les transformations étroites sont le résultat de map(), filter().
Transformations étendues : ici, tous les éléments requis pour calculer les enregistrements dans cettepartition
unique peuvent résider dans de nombreuses partitions du RDD parent. Ceux-ci utilisent
groupbyKey() et reducebyKey().
3.4.2 Actions
Les transformations dans Apache Spark créent des RDD les unes des autres, mais pour travailler sur unensemble
de données réel, puis nous effectuons des opérations d'action. Ici, le nouveau RDD n'est pasformé mais donne des
valeurs non-RDD en tant que résultats qui sont stockés sur les pilotes ou sur le système de stockage externe. Cela
apporte de la paresse au traitement des RDD.
Les actions sont un moyen d'envoyer des données de l'exécuteur au pilote où les exécuteurs sont responsables de
l'exécution d'une tâche. Dans le même temps, le pilote est un processus JVM qui gère lestravailleurs et l'exécution de
la tâche.
Renvoie un nouveau RDD en appliquant d'abord une fonction à tous les éléments de ce RDD, puis en
aplatissant les résultats.
Renvoie un nouvel ensemble de données formé en sélectionnant les éléments de la source sur lesquels funcrenvoie true.
tmp = [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
print(sc.parallelize(tmp).sortBy(lambda x: x[0]).collect())
print(sc.parallelize(tmp).sortBy(lambda x: x[1]).collect())
3.4.3.6 groupByKey()
Lorsqu'il est appelé sur un ensemble de données de paires (K, V), renvoie un ensemble de données depaires (K,
Iterable).
Remarque : Si vous effectuez un regroupement afin d'effectuer une agrégation (telle qu'une somme ou une
moyenne) sur chaque clé, l'utilisation de reduceByKey ou d' aggreggateByKey donnera de bien
meilleures performances.
rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 1), ('b', 1), ('b', 1)])
result = rdd.groupByKey()
print(result)
print(result.map(lambda t:(t[0], list(t[1]))).collect())
Lorsqu'il est appelé sur un ensemble de données de paires (K, V), renvoie un ensemble de données de paires (K, V)
où les valeurs de chaque clé sont agrégées à l'aide de la fonction de réduction donnée func, quidoit être de type (V, V)
=> V
rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 1), ('b', 1), ('b', 1)])
result = rdd.reduceByKey(lambda a, b: a + b ).collect()
print(result)
3.4.3.8 sortByKey()
Lorsqu'il est appelé sur un ensemble de données de paires (K, V) où K implémente Ordered, renvoie un ensemble
de données de paires (K, V) triées par clés dans l'ordre croissant ou décroissant, comme spécifiédans l'argument
booléen croissant.
tmp = [('a', 1), ('b', 2), ('1', 3), ('d', 4), ('2', 5)]
print(sc.parallelize(tmp).sortByKey().first())
print(sc.parallelize(tmp).sortByKey(True).collect())
print(sc.parallelize(tmp).sortByKey(False).collect())
3.4.3.9 mapValues( func )
Transmet chaque valeur de la paire clé-valeur RDD via une fonction de mappage sans modifier les clés ; celaconserve
également le partitionnement du RDD d'origine.
rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 1), ('b', 1), ('b', 1)])
print(rdd.mapValues(lambda x: x*10).collect())
3.4.3.10 distinct()
3.4.3.11 union()
Renvoie l'intersection de ce RDD et d'un autre. La sortie ne contiendra aucun élément en double, même siles RDD
d'entrée en contenaient.
3.4.3.13 join()
Lorsqu'il est appelé sur des ensembles de données de type (K, V) et (K, W), renvoie un ensemble de donnéesde paires
(K, (V, W)) avec toutes les paires d'éléments pour chaque clé.
3.4.3.14 glom()
Renvoie un RDD créé en fusionnant tous les éléments de chaque partition dans une liste.
Renvoie tous les éléments de l'ensemble de données sous forme de tableau au niveau du programme pilote.
Attention: Ceci est généralement utile après un filtre ou une autre opération qui renvoie un sous-ensemble
suffisamment petit des données.
3.4.3.16 first()
sc.parallelize([2, 3, 4]).first()
3.4.3.17 count()
sc.parallelize([2, 3, 4]).count()
Attention: Cette méthode ne doit être utilisée que si le tableau résultant est censé être petit, car toutesles données sont
chargées dans la mémoire du pilote.
sc.parallelize([7,2, 3, 4, 5, 6]).take(2)
Prend les num premiers éléments d'un RDD. Il renvoie la liste triée par ordre décroissant.
Attention: Cette méthode ne doit être utilisée que si le tableau résultant est censé être petit, car toutesles données sont
chargées dans la mémoire du pilote.
sc.parallelize([7,2, 3, 4, 5, 6]).top(2)
3.4.3.20 countByKey()
Compte le nombre d'éléments pour chaque clé et renvoyez le résultat au maître sous forme de dictionnaire.
Agréger les éléments de l'ensemble de données à l'aide d'une fonction func (qui prend deux arguments et en renvoie
un). La fonction doit être commutative et associative pour pouvoir être calculée correctement enparallèle.
Prend les N éléments d'un RDD classés par ordre croissant ou comme spécifié par la fonction de clé
facultative.
print(sc.parallelize([10, 1, 2, 9, 3, 4, 5, 6, 7]).takeOrdered(3))
sc.parallelize(range(10)).saveAsTextFile("output1")
sc.parallelize(range(10), 3).saveAsTextFile("output2")
Au lieu de travailler sur chaque élément dans une partition comme map() , mapPartitions travaille
sur toute la partition, donc en général plus performante que map.
1. Spark crée un graphique lorsque vous entrez du code dans la console Sparking.
2. Lorsqu'une action est appelée sur Spark RDD, Spark soumet le graphique au planificateur DAG.
3. Les opérateurs sont divisés en étapes de tâches dans le planificateur DAG.
4. Les étapes sont transmises au planificateur de tâches, qui lance la tâche via le gestionnaire de cluster.
1. Créez des RDD d'entrée à partir de données externes ou parallélisez une collection dans votre
programme pilote.
2. Transformez-les paresseusement pour définir de nouveaux RDD à l'aide de transformations telles quefilter() ou
map()
3. Facultatif : demandez à Spark de mettre en cache() tous les RDD intermédiaires qui devront être réutilisé.
4. Lancer des actions telles que count() et collect() pour lancer un calcul parallèle,qui est
ensuite optimisé et exécuté par Spark.
3.5 Limitations du RDD dans Apache Spark
Dans Apache Spark, le RDD n'a pas d'option pour l'optimisation automatique des entrées. Il est incapable d'utiliser les
optimiseurs avancés Spark tels que l'optimiseur Catalyst et le moteur d'exécution Tungsten, etnous ne pouvons donc
effectuer qu'une optimisation RDD manuelle. Ceci est surmonté dans les concepts Dataset et DataFrame, où les deux
utilisent le Catalyst pour générer un plan de requête logique et physiqueoptimisé. Il fournit de l'espace et de l'efficacité
de vitesse.
RDD ne fournit pas de sécurité statique ou de type Runtime et ne permet pas à l'utilisateur de vérifier leserreurs lors
de l'exécution. Mais, Dataset fournit une sécurité de type au moment de la compilation pourcréer des workflows de
données complexes. Cela facilite la détection des erreurs au moment de la compilation et rend ainsi le code plus
sûr.
RDD se dégrade lorsqu'il n'y a pas assez de mémoire disponible pour le stocker en mémoire ou sur disque. Ici, les
partitions qui débordent de la RAM peuvent être stockées sur disque et offriront le même niveau de performances.
Nous devons augmenter la RAM et la taille du disque pour surmonter ce problème.
3.5.4 Surcharge de sérialisation et de récupération de place (limitation des
performances)
Comme RDD est un objet en mémoire, il implique la surcharge de Garbage Collection et de la sérialisation Java, qui
devient coûteuse avec la croissance des données. Pour surmonter cela, nous pouvons utiliser desstructures de données
avec moins d'objets à moindre coût ou conserver l'objet sous forme sérialisée.
RDD a un problème avec la gestion des données structurées. En effet, il ne fournit pas de vue schématique des données
et n'a aucune disposition dans ce contexte. Dataset et DataFrame fournissent une vue Schémaet sont une collection
distribuée de données organisées en colonnes nommées.
4 Pyspark SQL &DataFrame
Spark SQL est un module d'Apache Spark pour la gestion de données structurées. Avec Spark SQL, vous pouvez
traiter des données structurées en utilisant le type d'interface SQL. Ainsi, si vos données peuvent être représentées
sous forme de tableau ou se trouvent déjà dans les sources de données structurées tellesque la base de données SQL,
vous pouvez utiliser SparkSQL pour les traiter.
Spark SQL fournit une API appelée API dataframes qui permet de mélanger des requêtes SQL, des techniques de
manipulation de dataframe comme pandas et des transformations et actions habituelles d'unRDD. Il est donc très bien
intégré.
Une DataFrame est un ensemble de données organisé en colonnes nommées. Il est conceptuellement équivalent à
une table dans une base de données relationnelle ou à une trame de données dans R/Python,mais avec des
optimisations plus riches sous le capot. Les DataFrames peuvent être construits à partir d'unlarge éventail de sources
telles que : des fichiers de données structurés, des tables dans Hive, des bases dedonnées externes ou des RDD
existants. L'API DataFrame est disponible dans Scala, Java, Python et R. DansScala et Java, un DataFrame est
représenté par un ensemble de données de lignes
Que vos données soient en HDFS, Hive ou bases de données relationnelles et que vos données soient auformat
AVO, parquet, ORC ou JSON, vous pouvez accéder et traiter les données de manière uniforme.
Avec Spark SQL, vous pouvez exécuter vos requêtes Hive sans aucune modification. Et vous pouvez utiliservos outils
de BI existants pour interroger le Big Data.
De plus, vous pouvez même joindre des données dans différents formats et différentes sources de données.C'est ainsi
Comme pour RDD, nous avons besoin de sc , il est de même pour SparkSQL.
La SparkSession, introduite dans Spark 2.0, fournit un point d'entrée unifié pour la programmation de Sparkavec les
API structurées. Vous pouvez utiliser une SparkSession pour accéder à toutes les fonctionnalités de
Spark . Pour créer une SparkSession de base, utilisez simplement SparkSession.builder() :
from pyspark.sql import SparkSession
spark = SparkSession \
.builder \
.appName("Python Spark SQL basic example") \
.config("spark.some.config.option", "some-value") \
.getOrCreate()
sc = spark.sparkContext
Un DataFrame PySpark peut être créé via pyspark.sql.SparkSession.createDataFrame généralement en passant une
liste de listes, tuples, dictionnaires et pyspark.sql.Rows , un DataFramepandas et un RDD composé d'une telle liste.
pyspark.sql.SparkSession.createDataFrame prend
l'argument schema pour spécifier le schéma du DataFrame. Lorsqu'il est omis, PySpark déduit le schéma
correspondant en prenant un échantillon des données.
df = spark.createDataFrame([
Row(a=1, b=2., c='string1', d=date(2000, 1, 1), e=datetime(2000, 1, 1, 12,
0)),
Row(a=2, b=3., c='string2', d=date(2000, 2, 1), e=datetime(2000, 1, 2, 12,
0)),
Row(a=4, b=5., c='string3', d=date(2000, 3, 1), e=datetime(2000, 1, 3, 12, 0))
])
print(df)
pandas_df = pd.DataFrame({
'a': [1, 2, 3],
'b': [2., 3., 4.],
'c': ['string1', 'string2', 'string3'],
'd': [date(2000, 1, 1), date(2000, 2, 1), date(2000, 3, 1)],
'e': [datetime(2000, 1, 1, 12, 0), datetime(2000, 1, 2, 12, 0), datetime(2000,
1, 3, 12, 0)]
})
df = spark.createDataFrame(pandas_df)
print(df)
4.2.4 Créez un PySpark DataFrame à partir d'un RDD composé d'une liste de tuples.
sc = spark.sparkContext
rdd = sc.parallelize([
(1, 2., 'string1', date(2000, 1, 1), datetime(2000, 1, 1, 12, 0)),
(2, 3., 'string2', date(2000, 2, 1), datetime(2000, 1, 2, 12, 0)),
(3, 4., 'string3', date(2000, 3, 1), datetime(2000, 1, 3, 12, 0))
])
df = spark.createDataFrame(rdd, schema=['a', 'b', 'c', 'd', 'e'])
print(df)
Exercice:
Les DataFrames créées ci-dessus ont toutes les mêmes résultats et schéma.
df.show()
df.printSchema()
df.show(1)
df.collect()
Les classes PySpark StructType & StructField sont utilisées pour spécifier par programmation le schéma dela
DataFrame et créer des colonnes complexes comme des colonnes imbriquées de structure, de tableau etde carte.
StructType est une collection de StructField qui définit le nom de la colonne, le type de données de la colonne,
booléen pour spécifier si le champ peut être nullable ou non et les métadonnées.
import pyspark
from pyspark.sql import SparkSession
from pyspark.sql.types import StructType,StructField, StringType, IntegerType
Ensuite nous pouvons passer par exemple struct1 en paramètre dans spark.createDataFrame
data = [("James","","Smith","36636","M",3000),
("Michael","Rose","","40288","M",4000),
("Robert","","Williams","42114","M",4000),
("Maria","Anne","Jones","39192","F",4000),
("Jen","Mary","Brown","","F",-1)
]
schema = StructType([ \
StructField("firstname",StringType(),True), \
StructField("middlename",StringType(),True), \
StructField("lastname",StringType(),True), \
StructField("id", StringType(), True), \
StructField("gender", StringType(), True), \
StructField("salary", IntegerType(), True) \
])
df = spark.createDataFrame(data=data,schema=schema)
df.printSchema()
df.show(truncate=False)
{"name":"Michael"}
{"name":"Andy", "age":30}
{"name":"Justin", "age":19}
# spark is an existing SparkSession
df = spark.read.json("C:\\BigDataSoft\\spark-3.0.3-bin-
hadoop2.7\\examples\\src\\main\\resources\\people.json")
# Displays the content of the DataFrame to stdout
df.show()
En Python, il est possible d'accéder aux colonnes d'un DataFrame soit par attribut (df.age) soit par indexation
(df['age']). Bien que le premier soit pratique pour l'exploration interactive des données, les utilisateurs sont
fortement encouragés à utiliser le dernier formulaire, qui est à l'épreuve du temps et nerompra pas avec les noms de
colonne qui sont également des attributs de la classe DataFrame.
La fonction sql sur une SparkSession permet aux applications d'exécuter des requêtes SQL par
programmation et renvoie le résultat sous forme de DataFrame.
PySpark DataFrame fournit également un moyen de gérer les données groupées en utilisant l'approche commune, la
stratégie fractionner-appliquer-combiner. Il regroupe les données selon une certaine condition,applique une fonction à
chaque groupe, puis les combine à nouveau au DataFrame.
df = spark.createDataFrame([
['red', 'banana', 1, 10], ['blue', 'banana', 2, 20], ['red', 'carrot', 3, 30],
['blue', 'grape', 4, 40], ['red', 'carrot', 5, 50], ['black', 'carrot', 6,
60],
['red', 'banana', 7, 70], ['red', 'grape', 8, 80]], schema=['color', 'fruit',
'v1', 'v2'])
df.show()
Grouping and then applying the avg() function to the resulting groups.
df.groupby('color').avg().show()
En fait groupby renvoie un objet de la classe pyspark.sql.GroupedData . Nous avons donc toutes les
fonctions fonctions d'agrégation classique comme dans SQL: max, min, sum, count, etc
Reprenons la df suivante:
df = spark.createDataFrame([
(1, 2., 'string1', date(2000, 1, 1), datetime(2000, 1, 1, 12, 0)),
(2, 3., 'string2', date(2000, 2, 1), datetime(2000, 1, 2, 12, 0)),
(3, 4., 'string3', date(2000, 3, 1), datetime(2000, 1, 3, 12, 0))
On veut appliquer la fonction num_10 à cette dataframe, voici le code avec les deux styles introduits ci-dessus.
Faites-attention au nom de la fonction et de la variable utilisée.
#SQL style
df.selectExpr("registered_func_name(a)").show()
#DSL style
df.select(registered_udf(df['a'])).show()
#Façon2 DSL style seul
from pyspark.sql import functions as F
registered_udf2 = F.udf(num_10, IntegerType())
df.select(registered_udf2(df['a'])).show()
+-----+---+------+
| name|age|height|
+-----+---+------+
|Alice| 5| 80|
|Alice| 10| 80|
+-----+---+------+
df.dropDuplicates(['name', 'height']).show()
output :
+-----+---+------+
| name|age|height|
+-----+---+------+
|Alice| 5| 80|
+-----+---+------+
4.6.2.1 dropna()
df = spark.createDataFrame(input_data, schema)
df.dropna().show()
output:
+---+--------+-----------------+---------+
| Id| Name| Job Profile| City|
+---+--------+-----------------+---------+
| 1|Shivansh| Data Scientist| Noida|
| 3| Swati| Data Analyst|Hyderabad|
| 5| Arpit|Android Developer| Banglore|
+---+--------+-----------------+---------+
df.dropna(thresh = 3).show()
output:
+---+--------+------------------+---------+
| Id| Name| Job Profile| City|
+---+--------+------------------+---------+
| 1|Shivansh| Data Scientist| Noida|
| 2| Kate|Software Developer| null|
| 3| Swati| Data Analyst|Hyderabad|
| 5| Arpit| Android Developer| Banglore|
+---+--------+------------------+---------+
4.6.2.2 fillna()
df.fillna("loss").show()
output:
+----+--------+------------------+---------+
| Id| Name| Job Profile| City|
+----+--------+------------------+---------+
| 1|Shivansh| Data Scientist| Noida|
| 2| Kate|Software Developer| loss|
| 3| Swati| Data Analyst|Hyderabad|
| 4| loss| loss| Noida|
| 5| Arpit| Android Developer| Banglore|
| 6| Ritik| loss| loss|
|null| loss| loss| loss|
+----+--------+------------------+---------+
df.fillna("loss", subset=["City"]).show()
output:
+----+--------+------------------+---------+
| Id| Name| Job Profile| City|
+----+--------+------------------+---------+
| 1|Shivansh| Data Scientist| Noida|
| 2| Kate|Software Developer| loss|
| 3| Swati| Data Analyst|Hyderabad|
| 4| null| null| Noida|
| 5| Arpit| Android Developer| Banglore|
| 6| Ritik| null| loss|
|null| null| null| loss|
+----+--------+------------------+---------+
Dans la forme la plus simple, la source de données par défaut ( parquet sauf configuration contraire par
spark.sql.sources.default) sera utilisée pour toutes les opérations.
df = spark.read.load("examples/src/main/resources/users.parquet")
df.select("name", "favorite_color").write.save("namesAndFavColors.parquet")
df = spark.read.load("examples/src/main/resources/people.csv",
format="csv", sep=";", inferSchema="true", header="true")
df = spark.read.load("examples/src/main/resources/people.json", format="json")
df.select("name", "age").write.save("namesAndAges.parquet", format="parquet")
df.write.csv('foo.csv', header=True)
spark.read.csv('foo.csv', header=True).show()