R. est un langage de programmation et un environnement logiciel principalement utilisé pour le calcul statistique et les graphiques. Il fournit une large gamme d'outils pour la manipulation des données, l'analyse des données, la visualisation des données et la modélisation statistique.
La fusion de données est une tâche d'analyse et de manipulation de données. Dans R, il existe différentes manières de fusionner des trames de données, en utilisant le 'fusionner()' fonction à partir de la base R, en utilisant le 'dplyr' paquet, et le 'données.table' emballer. Dans ce didacticiel, nous utiliserons les trois méthodes ci-dessus pour fusionner des données à l'aide de R.
1. Utilisation de 'merge()' depuis la base R :
La fonction merge() en base R nous aide à combiner deux ou plusieurs trames de données basées sur des colonnes communes. Il effectue différents types de jointures telles que la jointure interne, la jointure gauche, la jointure droite et la jointure complète.
Syntaxe:
merged_df <- merge(x,y,by = 'common_column',..)>
- 'X' et 'et' sont les trames de données que vous souhaitez fusionner.
- 'par' spécifie les colonnes communes sur lesquelles la fusion sera effectuée.
- Des arguments supplémentaires comme 'tous.x' , allié' et 'tous' contrôler le type de jointure à effectuer.
Exemple:
Considérons deux trames de données « df1 » et « df2 »
R.
df1 <->data.frame>(ID =>c>(1, 2, 3, 4),> >Name =>c>(>'A'>,>'B'>,>'C'>,>'D'>),> >Age =>c>(25, 30, 35, 40))> df2 <->data.frame>(ID =>c>(2, 3, 4, 5),> >Occupation =>c>(>'Engineer'>,>'Teacher'>,>'Doctor'>,>'Lawyer'>),> >Salary =>c>(5000, 4000, 6000, 7000))> |
>
>
Voyons des exemples d'exécution de différents types de jointures à l'aide de la fonction « merge() » :
1. Jointure interne (comportement par défaut) :
R.
inner_join <->merge>(df1, df2, by =>'ID'>)> print>(inner_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 2 B 30 Engineer 5000 2 3 C 35 Teacher 4000 3 4 D 40 Doctor 6000>
La trame de données « inner_join » résultante n'inclura que les lignes communes où 'IDENTIFIANT' est présent dans à la fois « df1 » et « df2 ».
2. Joint gauche( 'all.x=VRAI' ) :
R.
left_join <->merge>(df1, df2, by =>'ID'>, all.x =>TRUE>)> print>(left_join)> |
>
tutoriel javascript
>
Sortir:
ID Name Age Occupation Salary 1 1 A 25 NA 2 2 B 30 Engineer 5000 3 3 C 35 Teacher 4000 4 4 D 40 Doctor 6000>
Le bloc de données « left_join » résultant comprendra toutes les lignes de 'df1' et les lignes correspondantes de « df2 ». Les lignes non correspondantes de « df2 » auront une valeur « NA »
3. Rejoindre à droite ( 'all.y=VRAI' ) :
R.
right_join <->merge>(df1, df2, by =>'ID'>, all.y =>TRUE>)> print>(right_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 2 B 30 Engineer 5000 2 3 C 35 Teacher 4000 3 4 D 40 Doctor 6000 4 5 NA Lawyer 7000>
La trame de données « right_join » résultante inclura toutes les lignes de 'df2' et les lignes correspondantes de 'df1'. Les lignes non correspondantes de « df1 » auront des valeurs « NA ».
4. Jointure externe complète ( 'tous = VRAI' )
R.
full_join <->merge>(df1, df2, by =>'ID'>, all =>TRUE>)> print>(full_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 1 A 25 NA 2 2 B 30 Engineer 5000 3 3 C 35 Teacher 4000 4 4 D 40 Doctor 6000 5 5 NA Lawyer 7000>
La trame de données « full_join » résultante comprendra toutes les lignes de « df1 » et « df2 ». Les valeurs qui ne correspondent pas auront des valeurs « NA ».
2. Utilisation du package 'dplyr' :
Le package « dplyr » fournit un ensemble de fonctions pour la manipulation des données, y compris la fusion de trames de données.
La fonction principale de fusion dans « dplyr » est 'rejoindre()', qui prend en charge différents types de jointures.
Syntaxe:
merged_df<- join(x,y,by='common_column',type='type_of_join')>
- 'X' et 'et' sont les trames de données à fusionner.
- 'par' spécifie les colonnes communes sur lesquelles la fusion doit être effectuée
- 'type_of_join' peut être « intérieur », « gauche », « droite » ou « complet » pour spécifier le type de jointure.
Exemple:
Installez le dplyr() packager et créer deux trames de données, 'df1' et 'df2'.
R.
négation mathématique discrète
library>(dplyr)> df1 <->data.frame>(ID =>c>(1, 2, 3, 4),> >Name =>c>(>'A'>,>'B'>,>'C'>,>'D'>),> >Age =>c>(20, 30, 40, 50))> df2 <->data.frame>(ID =>c>(2, 3, 4, 5),> >Occupation =>c>(>'Engineer'>,>'Teacher'>,>'Doctor'>,>'Lawyer'>),> >Salary =>c>(2000, 4000, 6000, 7000))> |
>
>
Voyons des exemples d'exécution de différents types de jointures à l'aide des fonctions « dplyr » :
1. Jointure interne:
np où
R.
inner_join <->inner_join>(df1, df2, by =>'ID'>)> print>(inner_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 2 B 30 Engineer 2000 2 3 C 40 Teacher 4000 3 4 D 50 Doctor 6000>
La trame de données « inner_join » résultante inclura uniquement le lignes communes où « ID » est présent à la fois dans « df1 » et « df2 ».
2. Joint gauche:
R.
left_join <->left_join>(df1, df2, by =>'ID'>)> print>(left_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 1 A 20 NA 2 2 B 30 Engineer 2000 3 3 C 40 Teacher 4000 4 4 D 50 Doctor 6000>
Le bloc de données « left_join » résultant comprendra toutes les lignes de 'df1' et le lignes correspondantes de 'df2' . Les lignes non correspondantes de « df2 » auront des valeurs « NA ».
3. Rejoindre à droite :
R.
right_join <->right_join>(df1, df2, by =>'ID'>)> print>(right_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 2 B 30 Engineer 2000 2 3 C 40 Teacher 4000 3 4 D 50 Doctor 6000 4 5 NA Lawyer 7000>
La trame de données « right_join » résultante comprendra toutes les lignes de 'df2' et le lignes correspondantes de 'df1'. Les lignes non correspondantes de « df1 » auront des valeurs « NA ».
4. Jointure externe complète :
R.
'formule de maçon'
full_join <->full_join>(df1, df2, by =>'ID'>)> print>(full_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 1 A 20 NA 2 2 B 30 Engineer 2000 3 3 C 40 Teacher 4000 4 4 D 50 Doctor 6000 5 5 NA Lawyer 7000>
La trame de données « full_join » résultante comprendra toutes les lignes de « df1 » et « df2 » . Les lignes non correspondantes auront des valeurs « NA ».
3. Utilisation du package « data.table » :
Le package « data.table » offre une approche efficace et rapide de la manipulation des données. Il fournit la fonction 'merge()'. Il est similaire à celui de la base R mais optimisé pour la vitesse.
Syntaxe:
merged_dt <- merge(x, y, by = 'common_column', ...)>
- 'X' et 'et' sont les trames de données qui doivent être fusionnées.
- 'par' spécifie les colonnes communes sur lesquelles la fusion sera effectuée.
- Des arguments supplémentaires comme 'tous.x', 'all.y' et 'tous' qui contrôle le type de jointure.
Exemple:
Installez la bibliothèque data.table et créez deux tables de données, « dt1 » et « dt2 ».
R.
library>(data.table)> dt1 <->data.table>(ID =>c>(1, 2, 3, 4),> >Name =>c>(>'A'>,>'B'>,>'C'>,>'D'>),> >Age =>c>(25, 30, 35, 40))> dt2 <->data.table>(ID =>c>(2, 3, 4, 5),> >Occupation =>c>(>'Engineer'>,>'Teacher'>,>'Doctor'>,>'Lawyer'>),> >Salary =>c>(5000, 4000, 6000, 7000))> |
>
>
Voyons des exemples d'exécution de différents types de fusions à l'aide de la fonction « merge() » du package « data.table » :
1. Jointure interne (comportement par défaut) :
R.
inner_join <->merge>(df1, df2, by =>'ID'>)> print>(inner_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 2 B 30 Engineer 2000 2 3 C 40 Teacher 4000 3 4 D 50 Doctor 6000>
La trame de données 'inner_join' résultante n'inclura que le lignes communes où « ID » est présent à la fois dans « df1 » et « df2 ».
2. Jointure gauche ('all.x = TRUE') :
R.
left_join <->merge>(df1, df2, by =>'ID'>, all.x =>TRUE>)> print>(left_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 1 A 20 NA 2 2 B 30 Engineer 2000 3 3 C 40 Teacher 4000 4 4 D 50 Doctor 6000>
Le bloc de données « left_join » résultant comprendra tous Ne correspond pas de 'df1' et le lignes correspondantes de 'df2'. Les lignes non correspondantes de « df2 » auront des valeurs « NA ».
3. Rejoindre à droite ('all.y = TRUE') :
R.
chaîne en entiers
right_join <->merge>(df1, df2, by =>'ID'>, all.y =>TRUE>)> print>(right_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 2 B 30 Engineer 2000 2 3 C 40 Teacher 4000 3 4 D 50 Doctor 6000 4 5 NA Lawyer 7000>
La trame de données « right_join » résultante comprendra tous Ne correspond pas les lignes de « df2 » et les lignes correspondantes de « df1 ». Les lignes non correspondantes de « df1 » auront des valeurs « NA ».
3. Jointure externe complète ('all = TRUE') :
R.
full_join <->merge>(df1, df2, by =>'ID'>, all =>TRUE>)> print>(full_join)> |
>
>
Sortir:
ID Name Age Occupation Salary 1 1 A 20 NA 2 2 B 30 Engineer 2000 3 3 C 40 Teacher 4000 4 4 D 50 Doctor 6000 5 5 NA Lawyer 7000>
La trame de données « full_join » résultante comprendra tous Ne correspond pas lignes de « df1 » et « df2 ». Les lignes non correspondantes auront des valeurs « NA ».
L'un des avantages de l'utilisation de « dplyr » et « data.table » est qu'ils fournissent une syntaxe plus concise et plus lisible pour la manipulation des données par rapport à la base R.
Résumé:
- 'merge()' fournit une fonction générale pour fusionner des trames de données.
- « dplyr » se concentre sur la fusion en mettant l'accent sur la lisibilité et la facilité d'utilisation.
- 'données. table » offre un moyen rapide et efficace de gérer de grands ensembles de données avec des performances optimisées.
- Nous devons choisir l'approche en fonction de la complexité de la tâche et des exigences de performance.