Ajouter, supprimer et renommer des colonnes dans R à laide de Dplyr

dplyr est un package R populaire pour la manipulation de données, ce qui permet aux utilisateurs de travailler plus facilement avec des trames de données. Une tâche courante lorsque vous travaillez avec des données consiste à renommer des colonnes, que dplyr gère efficacement à l'aide de la fonction rename().

La fonction rename() dans dplyr est particulièrement utile lorsqu'il s'agit d'ensembles de données qui ont des colonnes avec des noms peu clairs ou ambigus. En fournissant une syntaxe simple et intuitive pour renommer les colonnes, dplyr facilite la compréhension et la maintenance de leur code par les utilisateurs.

De plus, cette fonction peut être facilement combinée avec d'autres opérations dplyr, telles que le filtrage et la synthèse, pour créer un flux de travail de manipulation de données transparent dans R.

Ces fonctionnalités sont également disponibles dans Power Query , elles ne sont donc pas propres au programme R. Cependant, R est meilleur pour les gérer.

Dans l'article suivant, nous explorerons les détails de la fonction rename() de dplyr et ses diverses applications, illustrant son efficacité dans la gestion des trames de données.

Nous apprendrons également comment ajouter et supprimer des colonnes dans R à l'aide de dyplr.

En apprenant ces techniques, les utilisateurs peuvent améliorer le caractère pratique de leurs efforts de manipulation de données, produire des analyses plus robustes et sans erreur et s'amuser en cours de route !

Passons à la science des données, il est temps de tibbler, ou devrions-nous dire, d'apporter la base R !

Table des matières

• Comprendre Dplyr Renommer
• Installation et chargement de Dplyr
• Utilisation de la fonction de renommage de Dplyr
  • Syntaxe de base
  • Renommer plusieurs colonnes
  • Chaînage avec d'autres fonctions Dplyr
• Cas d'utilisation courants de Dplyr Rename
• Gestion des erreurs et des cas extrêmes
• Autres exemples concrets - Ajouter, supprimer et renommer des colonnes
• Fonctions de base pour les opérations sur les colonnes
  • 1. Ajouter de nouvelles colonnes dans R
  • 2. Sélectionnez les colonnes dans R
  • 3. Renommer les colonnes dans R
• Le dernier mot
• FAQ
  • Quelle est la différence entre R et Python ?
  • Qu'est-ce que c'est ?
  • Qu'est-ce que Petal.Length dans R ?
  • Qu'est-ce qu'un DataFrame en R ?
  • Que signifie dbl ?

Comprendre Dplyr Renommer

Le package dplyr dans R est un package tidyverse populaire pour la manipulation de données qui offre un ensemble de fonctions utiles pour transformer et organiser des ensembles de données. Parmi ces fonctions, la fonction rename() est particulièrement pratique lorsqu'il s'agit de modifier les noms de colonnes dans un data frame.

Pour utiliser la fonction rename(), fournissez simplement le nouveau nom de colonne suivi de l'ancien, comme ceci : new_name = old_name. Par exemple, considérons un exemple de trame de données dans laquelle nous voulons changer le nom de la colonne "old1" en "new1". La syntaxe ressemblerait à ceci :

library(dplyr)
df %>% rename(new1 = old1)

De plus, la fonction rename_with() vous permet de renommer des colonnes à l'aide d'une fonction de transformation spécifiée. Par exemple, vous pouvez utiliser la fonction toupper pour convertir tous les noms de colonne en majuscule :

df %>% rename_with(toupper)

Si vous devez renommer plusieurs colonnes à la fois, dplyr propose deux méthodes. La première consiste à utiliser la fonction rename(), en fournissant plusieurs nouveaux et anciens noms de colonne comme arguments :

df %>% rename(new1 = old1, new2 = old2)

La deuxième méthode consiste à utiliser la fonction rename_with(), où vous définissez des tableaux d'anciens et de nouveaux noms de colonnes :

new <- c('new1',="" 'new2')="" old=""><- c('old1',="" 'old2')="" df="" %="">% rename_with(~ new, all_of(old))

Les deux méthodes, comme indiqué dans les exemples ci-dessus, produiront le même résultat.

Installation et chargement de Dplyr

Pour commencer à utiliser le package dplyr pour renommer les colonnes, vous devez d'abord installer et charger le package dans votre environnement R. L'installation de dplyr est un processus simple qui peut être effectué à l'aide de la commande suivante :

install.packages("dplyr")

Une fois l'installation terminée, vous pouvez charger le package dplyr dans votre script R à l'aide de la fonction de bibliothèque :

library("dplyr")

Avec le package dplyr installé et chargé, vous pouvez désormais utiliser ses puissantes fonctions de manipulation de données, y compris la fonction rename() pour renommer les colonnes de votre bloc de données.

Voici un exemple d'utilisation de la fonction rename() avec le jeu de données iris bien connu. Supposons que vous souhaitiez renommer la colonne "Sepal.Length" en "sepal_length". Vous pouvez y parvenir en utilisant le code suivant :

iris_renamed <- iris="" %="">%
  rename(sepal_length = Sepal.Length)

Dans cet extrait de code, l'opérateur %>% est utilisé pour diriger l'ensemble de données iris vers la fonction rename(). Le nouveau nom de colonne "sepal_length" est attribué à l'ancien nom de colonne "Sepal.Length". La trame de données résultante avec la colonne renommée est ensuite affectée aux noms de variables, iris_renamed.

La fonction rename() peut également gérer le renommage de plusieurs colonnes à la fois. Par exemple, si vous souhaitez renommer les colonnes "Sepal.Length" et "Sepal.Width" respectivement en "sepal_length" et "sepal_width", vous pouvez utiliser le code suivant :

iris_renamed <- iris="" %="">%
  rename(
    sepal_length = Sepal.Length,
    sepal_width = Sepal.Width
  )

Cet extrait de code montre à quel point il est facile de renommer plusieurs colonnes dans un bloc de données à l'aide de la fonction rename() de dplyr.

Utilisation de la fonction de renommage de Dplyr

Le package dplyr dans R est un outil puissant pour la manipulation de données lorsque vous travaillez avec des trames de données. L'une des nombreuses fonctions utiles qu'il fournit est la fonction de renommage, qui vous permet de renommer facilement les colonnes de votre bloc de données.

Syntaxe de base

La syntaxe de base pour utiliser la fonction de renommage dans dplyr est la suivante :

library(dplyr)
your_dataframe %>% rename(new_column_name = old_column_name)

Cette commande renommera l'ancienne colonne spécifiée avec le nouveau nom de colonne souhaité, sans modifier les autres colonnes du bloc de données.

Renommer plusieurs colonnes

Vous pouvez également renommer plusieurs colonnes à la fois en utilisant la même fonction de renommage. Pour cela, il suffit de séparer chaque colonne en renommant la paire par une virgule :

your_dataframe %>%
   rename(new_column1 = old_column1,
          new_column2 = old_column2,
          new_column3 = old_column3)

En utilisant cette approche, vous pouvez renommer autant de colonnes que nécessaire dans une seule instruction.

Vous pouvez également utiliser la rename_with()fonction pour appliquer une transformation aux noms de colonne. Cette fonction prend une trame de données et une fonction qui sera appliquée aux noms de colonnes pour générer les nouveaux noms. Par exemple:

your_dataframe %>%
  rename_with(.cols = c("old_column1", "old_column2"), .fn = toupper)

Cela convertira les noms de colonnes spécifiés en majuscules.

Chaînage avec d'autres fonctions Dplyr

L'une des forces de dplyr est sa capacité à enchaîner plusieurs actions à l'aide de l' %>%opérateur. Cela vous permet d'effectuer une série de manipulations de données de manière concise et facile à lire. Lorsque vous utilisez la fonction renommer, vous pouvez l'enchaîner avec d'autres fonctions dplyr telles que filter(), mutate()et summarize():

your_dataframe %>%
  filter(some_condition) %>%
  rename(new_column_name = old_column_name) %>%
  mutate(new_column = some_expression) %>%
  summarize(some_aggregation)

Cet exemple illustre une série de manipulations de données où le filtrage des données est effectué en premier, suivi du changement de nom d'une colonne, de la création d'une nouvelle colonne à l'aide de mutate et enfin de la synthèse des données avec une fonction d'agrégation.

En tirant parti de la puissance de la fonction de renommage et des capacités de chaînage de dplyr, les utilisateurs de R peuvent effectuer des manipulations de données efficaces et lisibles sur leurs trames de données.

Cas d'utilisation courants de Dplyr Rename

Dplyr est un package puissant dans R qui fournit un ensemble de fonctions pour effectuer des tâches de manipulation de données. Une tâche courante consiste à renommer des colonnes dans un bloc de données. Dans cette section, nous discuterons de certains cas d'utilisation courants de la fonction de renommage dans dplyr.

1. Renommage simple des colonnes :

Renommer une seule colonne est simple à l'aide de la rename()fonction. La syntaxe est rename(dataframe, new_name = old_name). Voici un exemple :

library(dplyr)
dataframe <- dataframe="" %="">% rename(new_column_name = old_column_name)

2. Renommer plusieurs colonnes :

Vous pouvez également renommer plusieurs colonnes dans un seul appel de fonction en fournissant un mappage de colonne supplémentaire dans rename()la fonction. Voici un exemple :

dataframe <- dataframe="" %="">%
  rename(new_col_name1 = old_col_name1,
         new_col_name2 = old_col_name2)

3. Renommer des colonnes à l'aide de fonctions de chaîne :

Vous pouvez renommer des colonnes à l'aide de fonctions de chaîne, telles que tolower()ou toupper(), à l'aide de la rename_with()fonction. Selon Stack Overflow , cette fonction remplace les fonctions rename_if, rename_atet maintenant remplacées rename_all. Voici un exemple :

dataframe <- dataframe="" %="">%
  rename_with(tolower)  # Converts column names to lowercase

4. Renommer des colonnes en fonction d'une condition :

Avec rename_with(), vous pouvez appliquer des fonctions de renommage personnalisées et même utiliser des conditions. L'exemple suivant montre comment renommer des colonnes selon qu'elles contiennent ou non une certaine chaîne :

rename_function <- function(x)="" {="" if="" (grepl("length",="" x))="" {="" return(paste0(x,="" "_length"))="" }="" else="" {="" return(paste0(x,="" "_default"))="" }="" }="" dataframe=""><- dataframe="" %="">% rename_with(rename_function)

Gestion des erreurs et des cas extrêmes

Lors de l'utilisation de la fonction de renommage dplyr pour modifier les noms de colonne dans un bloc de données, vous pouvez rencontrer des erreurs ou des cas extrêmes en raison de noms de colonne en double, d'espaces dans les noms de colonne ou d'une syntaxe incorrecte. Cette section fournit des conseils sur la manière de résoudre ces problèmes.

Lorsqu'il s'agit de noms de colonnes en double, dplyr ne peut pas renommer les colonnes avec le même nom de sortie. Cependant, une solution de contournement pour dédoubler les noms de colonne consiste à utiliser la rename_allfonction du package dplyr avec paste0:

d %>% rename_all(~paste0(., 1:2))

Ce code ajoutera un numéro de 1 à 2 à chaque nom de colonne, garantissant qu'il n'y a pas de doublons. Plus de détails peuvent être trouvés dans cette discussion sur Stack Overflow .

S'il y a des espaces dans les noms de colonne, vous pouvez utiliser des backticks pour entourer les noms de colonne comme ceci :

df %>% rename(foo = `test col`)

Enfin, si vous rencontrez des problèmes liés au fait que dplyr n'accepte pas la paste0()fonction comme ancien_nom dans rename(), une solution possible consiste à construire les nouveaux noms de colonne en dehors de la rename()fonction, puis à les utiliser comme entrée. Une discussion pertinente sur un problème similaire peut être trouvée dans cette question Stack Overflow .

En traitant ces erreurs et ces cas extrêmes, vous serez mieux équipé pour gérer des scénarios de changement de nom complexes dans dplyr.

Dans cette dernière section de notre article sur le renommage dplyr, nous avons discuté de son importance dans les tâches de manipulation de données. La fonction rename() permet aux utilisateurs de modifier efficacement les noms de colonnes, ce qui permet d'obtenir des blocs de données plus clairs et plus concis. Cela devient particulièrement utile lorsqu'il s'agit de grands ensembles de données ou lors des étapes de prétraitement des données.

En utilisant le package dplyr, renommer des colonnes dans R est simple, ce n'est pas une science des données, consultez ce qui suit :

  rename(new_column_name = old_column_name)

Cette syntaxe simple vous permet de remplacer les anciens noms de colonne par de nouveaux, améliorant ainsi la lisibilité et assurant la cohérence de vos données. De plus, la fonction rename_with() peut être utilisée pour modifier les noms de colonne à l'aide d'une fonction spécifique. Cela offre un meilleur contrôle et une personnalisation de vos manipulations de données.

En exploitant la puissance de dplyr et la fonction de renommage, vous pouvez manipuler vos données en toute confiance et améliorer les capacités globales de traitement des données. N'oubliez pas de toujours utiliser des sources fiables lorsque vous apprenez de nouvelles techniques de programmation R, telles que

Avec dplyr rename dans votre boîte à outils, vous êtes bien équipé pour relever divers défis de manipulation de données et continuer à faire progresser votre expertise en programmation R.

Autres exemples concrets - Ajouter, supprimer et renommer des colonnes

Les opérations sur les colonnes vous permettent de calculer, d'ajouter, de supprimer et de renommer des colonnes dans R à l'aide de dplyr . Ouvrez un nouveau script R dans RStudio. Si vous ne savez pas comment faire, cliquez sur les liens pour savoir comment installer RStudio et créer un script R.

Pour cette démonstration, le package de jeu de données Lahman est utilisé. Celui-ci contient des records de baseball datant de plus de cent ans. C'est un bon ensemble de données à utiliser pour la pratique. Vous pouvez le télécharger en faisant une recherche rapide sur Google.

De plus, le package Lahman a un ensemble de données intitulé Teams , avec un T majuscule. Une bonne pratique pour les conventions de dénomination dans R consiste à utiliser des lettres minuscules. Donc, cela doit d'abord être converti en équipes , comme le montre l'image ci-dessous.

Fonctions de base pour les opérations sur les colonnes

1. Ajouter de nouvelles colonnes dans R

La première fonction est mutate() . Cela crée une nouvelle colonne basée sur les colonnes existantes.

Si vous souhaitez calculer une nouvelle colonne, vous pouvez utiliser la fonction mutate suivant l'argument :

df est un nom de remplacement pour tout type de bloc de données. Ainsi, lors de l'utilisation réelle, remplacez df par le nom de la trame de données que vous souhaitez muter. Ensuite, vous placez les nouvelles variables qui doivent être nommées avec la formule pour dériver la nouvelle colonne.

A titre d'exemple, la fonction mutate sera utilisée pour trouver le pourcentage de gain pour chaque colonne. Dans le jeu de données Lahman, il y a une colonne Win et Loss. Pour obtenir le pourcentage, divisez le gain par la somme du gain et de la perte. Mais avant de pouvoir le faire, vous devez apporter le package dplyr.

Voici ce qui se passe si vous exécutez la fonction mutate sans dplyr :

Vous obtiendrez une erreur disant "n'a pas pu trouver la fonction mutate".

Alors, voici comment intégrer dplyr dans R. Il vous suffit d'exécuter library (tidyverse) .

Vous verrez que dplyr fait partie des nombreuses fonctions du package tidyverse . Une autre option consiste à exécuter la bibliothèque (dplyr) .

Maintenant, si vous placez votre curseur sur le code avec la fonction mutate et que vous l'exécutez, vous verrez alors la colonne Wpct contenant les pourcentages gagnants.

Dans ce cas, le résultat de la fonction mutate a seulement été exécuté ; il n'a pas été affecté aux données.

Si vous souhaitez affecter le résultat de la fonction mutate aux équipes de données , vous devez utiliser l' opérateur d'affectation ( <-> ). Une fois terminé, lancez-le. Puis dans une autre ligne, lancez head (teams) . Cela affectera le résultat à l' ensemble de données des équipes .

Si vous souhaitez vérifier quelles colonnes sont disponibles dans un ensemble de données, utilisez la fonction names ( ) . Cela listera tous les noms de colonnes dans les données.

Vous pouvez également utiliser des fonctions existantes dans le cadre de la fonction mutate . Par exemple, vous pouvez prendre le journal d'un ensemble de données spécifique à l'aide de la fonction log ( ) .

2. Sélectionnez les colonnes dans R

Une autre fonction de dplyr est select() . Il supprime ou sélectionne des colonnes données. Son algorithme de base est :

Vous devez saisir le nom du bloc de données, puis les colonnes que vous souhaitez sélectionner.

Par exemple, si vous souhaitez conserver les colonnes yearID, wins et loss dans l'ensemble de données, il vous suffit d'exécuter :

Vous obtiendrez alors le résultat souhaité :

Cependant, si vous n'utilisez pas la fonction head ( ) , le résultat affichera les lignes inférieures des colonnes. Donc, si vous avez affaire à plusieurs lignes de données, vous devrez continuellement faire défiler vers le haut pour atteindre le haut de la colonne.

Une bonne pratique consiste à utiliser la fonction head avec select. Ainsi, lorsque vous exécutez le code, le résultat affiche d'abord les premières lignes de la colonne.

Désormais, si vous souhaitez supprimer des colonnes de l'ensemble de données, il vous suffit de placer un signe moins ( - ) avant le nom de la colonne.

Pour vérifier si une colonne a bien été supprimée, vous pouvez comparer le nouveau jeu de données à l'ancien. Voici comment procéder :

Attribuez d'abord le code R avec la fonction de sélection à un objet. Dans cet exemple, il a été attribué à teams_short . Pour compter le nombre de colonnes, utilisez la fonction ncol() . Exécutez la fonction ncol pour teams_short et teams .

Vous verrez alors qu'une colonne a été supprimée de l'ensemble de données.

3. Renommer les colonnes dans R

La dernière fonction de colonne dans dplyr est rename() . Et comme son nom l'indique, il peut renommer les colonnes sélectionnées dans R.

Voici son algorithme de base :

Et vous remarquerez que c'est un peu contre-intuitif ; le nouveau nom vient en premier tandis que l'ancien nom vient après. Assurez-vous donc de ne pas les mélanger.

Par exemple, les colonnes yearID et divID actuelles seront renommées respectivement year_id et division_id . Avant d'exécuter le code, assurez-vous de l'affecter à un nouvel objet afin de ne pas perturber l'ensemble de données d'origine.

Pour vérifier si les noms de ces colonnes sélectionnées ont été modifiés avec succès, utilisez la fonction names ( ) .

Vous verrez que les colonnes ont bien été renommées.

Vous êtes-vous déjà demandé à quel point R est puissant lorsqu'il est utilisé avec LuckyTemplates, découvrez cette technique géniale, elle vous fera gagner une tonne de temps.

Le dernier mot

Ce didacticiel a présenté trois fonctions dplyr de base que vous pouvez utiliser pour effectuer des opérations sur les colonnes. Plus précisément, vous avez appris à ajouter, supprimer et renommer des colonnes dans R.

Il y a encore d'autres fonctions que vous n'avez pas encore explorées. Mais il est important de connaître et de se familiariser avec mutate ( ) , select ( ) et rename ( ) car ce sont les plus courants.

Ces techniques de modification de colonne peuvent également être effectuées dans Power Query. Mais c'est bien de savoir comment faire cela dans dplyr aussi. Cela vous aidera sûrement lorsque vous passerez à l'analyse d'ensembles de données statistiques.

FAQ

Quelle est la différence entre R et Python ?

Pour commencer, R et Python sont des langages de programmation, mais Python est plutôt un langage d'utilisation générale et R est un langage de programmation statistique. Python est un langage plus couramment utilisé, compris et polyvalent.

Qu'est-ce que c'est ?

str affiche simplement les structures de r objets

Qu'est-ce que Petal.Length dans R ?

Petal.length est un format utilisé dans R pour raconter les relations que nous testons.

Qu'est-ce qu'un DataFrame en R ?

Une trame de données R est une structure de données tabulaire couramment utilisée pour stocker des valeurs de tout type de données.

Que signifie dbl ?

Dbl signifie "double classe", c'est un type de données utilisé pour contenir des valeurs numériques contenant des points décimaux.