arrange

réorganiser (`<column>`)
Trier les lignes, par ordre croissant, en fonction des colonnes spécifiées.

arrange (desc (`<column>`))
trie les lignes par ordre décroissant en fonction de la colonne spécifiée.

disposer (`<column>`, `<column>`)
Trier les lignes, par ordre croissant, en fonction de chaque colonne successive spécifiée, en conservant l'ordre du tri précédent intact.

nombre

count ()
Total des données par groupe.

count (`<column>`)
Regrouper les données en fonction de la colonne spécifiée et renvoyer le nombre de lignes avec des valeurs uniques (pour les valeurs de chaîne) ou renvoyer le total pour chaque groupe (pour les valeurs numériques).

count (`<column>`, wt= `<column>`)
Regrouper les données en fonction de la colonne spécifiée et renvoyer le nombre de lignes avec des valeurs uniques (pour les valeurs de chaîne) ou renvoyer le total pour chaque groupe (pour les valeurs numériques) dans la colonne de pondération spécifiée.

count (`<column>`, wt=<func>(`<column>`))
Regrouper les données en fonction de la colonne spécifiée et renvoyer le résultat de la fonction appliquée à la colonne de pondération spécifiée.

count (`<column>`, wt=<func>(`<column>`), sort = <logical>)
Regrouper les données en fonction de la colonne spécifiée et renvoyer le résultat de la fonction appliquée à la colonne de pondération spécifiée, triée ou non.

distinct

distinct ()
Conservez des lignes distinctes et uniques en fonction de toutes les colonnes ou des colonnes spécifiées.

- filtre

filter (`<column>` <logicalOperator> provide_value)
Conserver les lignes qui remplissent la condition spécifiée et filtrer toutes les autres lignes.
Pour le type de colonne booléen, provide_value doit avoir la valeur TRUE ou FALSE (en majuscules).

filter (`<column>` == <logical>)
Conserver les lignes qui répondent aux conditions de filtre spécifiées en fonction de la valeur logique TRUE ou FALSE.

filter (<func>(`<column>`) <logicalOperator> provide_value)
Conserver les lignes qui remplissent la condition spécifiée et filtrer toutes les autres lignes. La condition peut appliquer une fonction à une colonne à gauche de l'opérateur.

filter (`<column>` <logicalOperator> <func(column)>)
Conserver les lignes qui remplissent la condition spécifiée et filtrer toutes les autres lignes. La condition peut appliquer une fonction à une colonne à droite de l'opérateur.

filter (<logicalfunc(column)>)
Conserver les lignes qui remplissent la condition spécifiée et exclure toutes les autres lignes. La condition peut appliquer une fonction logique à une colonne.

filter (`<column>` <logicalOperator> provide_value <andor> `<column>` <logicalOperator> provide_value)
Conserver les lignes qui remplissent les conditions spécifiées et filtrer toutes les autres lignes.

group_by

group_by (`<column>`)
Regrouper les données en fonction de la colonne spécifiée.

group_by (desc (`<column>`))
Regrouper les données, par ordre décroissant, en fonction de la colonne spécifiée.

mutate

mutate (provide_new_column = `<column>`)
Ajoutez une nouvelle colonne et conservez les colonnes existantes.

mutate (provide_new_column = <func(column)>)
Ajoute une nouvelle colonne à l'aide de l'expression spécifiée, qui applique une fonction à une colonne. Conservez les colonnes existantes.

mutate (provide_new_column = case_when (`<column>` <operator> provide_value_or_column_to_compare ~ provide_value_or_column_to_replace, `<column>` <operator> provide_value_or_column_to_compare ~ provide_value_or_column_to_replace, TRUE ~ provide_default_value_or_column)
Ajoutez une nouvelle colonne à l'aide de l'expression conditionnelle spécifiée.

mutate (provide_new_column = `<column>` <operator> `<column>`)
Ajoute une nouvelle colonne à l'aide de l'expression spécifiée, qui effectue un calcul avec des colonnes existantes. Conservez les colonnes existantes.

mutate (provide_new_column = coalesce (`<column>`, `<column>`))
Ajouter une nouvelle colonne à l'aide de l'expression spécifiée, qui remplace les valeurs manquantes dans la nouvelle colonne par les valeurs d'une autre colonne spécifiée. Comme alternative à la spécification d'une autre colonne, vous pouvez indiquer une valeur, une fonction sur une colonne ou une fonction sur une valeur. Conservez les colonnes existantes.

mutate (provide_new_column = if_else (`<column>` <logicalOperator> provide_value, provide_value_for_true, provide_value_for_false))
Ajoutez une nouvelle colonne à l'aide de l'expression conditionnelle spécifiée. Conservez les colonnes existantes.

mutate (provide_new_column = `<column>`, provide_new_column = `<column>`)
Ajoutez plusieurs nouvelles colonnes et conservez les colonnes existantes.

mutate (provide_new_column = n ())
Dénombre les valeurs dans les groupes. Vérifiez que le regroupement est déjà effectué à l'aide de group_by. Conservez les colonnes existantes.

mutate_all

mutate_all (funs (<func>))
Applique la fonction spécifiée à toutes les colonnes et remplace les valeurs existantes dans ces colonnes. Indiquez s'il faut supprimer les valeurs manquantes.

mutate_all (funs (. <operator> provide_value))
Applique l'opérateur spécifié à toutes les colonnes et remplace les valeurs existantes dans ces colonnes.

mutate_all (funs ("valeur_fournisseur" =. <operator> provide_value))
Appliquer l'opérateur spécifié à toutes les colonnes et créer de nouvelles colonnes pour contenir les résultats. Affectez aux nouvelles colonnes des noms qui se terminent par la valeur spécifiée.

mutate_at

mutate_at (vars (`<column>`), funs (<func>))
Applique des fonctions aux colonnes spécifiées.

mutate_if

mutate_if (<predicateFunc>, <func>)
Applique des fonctions aux colonnes qui remplissent la condition spécifiée.

mutate_if (<predicateFunc>, funs (. <operator> provide_value)
Appliquer l'opérateur spécifié aux colonnes qui remplissent la condition spécifiée.

mutate_if (<predicateFunc>, funs (<func>))
Applique des fonctions aux colonnes qui remplissent la condition spécifiée. Indiquez s'il faut supprimer les valeurs manquantes.

renommer

rename (provide_new_column = `<column>`)
Renommer la colonne spécifiée.

sample_frac

sample_frac (provide_number_between_0_and_1, weight= `<column>`, replace=<logical>)
Génère un échantillon aléatoire basé sur un pourcentage des données. Le paramètre weight est facultatif et représente le taux de probabilité que la ligne soit choisie. Indiquez une colonne numérique. Le paramètre replace est facultatif et sa valeur par défaut est FALSE.

sample_n

sample_n (provide_number_of_rows, weight = `<column>`, replace=<logical>)
Génère un échantillon aléatoire de données basé sur un certain nombre de lignes. Le paramètre weight est facultatif et représente le taux de probabilité que la ligne soit choisie. Indiquez une colonne numérique. Le paramètre replace est facultatif et sa valeur par défaut est FALSE.

sélectionner

select (`<column>`)
Conserver la colonne spécifiée.

select (-`<column>`)
Supprime la colonne spécifiée.

select (starts_with ("valeur_texte_fournisseur"))
Conserver les colonnes dont les noms commencent par la valeur spécifiée.

select (ends_with ("valeur_texte_fournisseur"))
Conserver les colonnes dont les noms se terminent par la valeur spécifiée.

select (contient ("provide_text_value"))
Conserver les colonnes dont les noms contiennent la valeur spécifiée.

select (matches ("valeur_texte_fournisseur"))
Conserver les colonnes dont les noms correspondent à la valeur spécifiée. La valeur spécifiée peut être un texte ou une expression régulière.

select (`<column>`: `<column>`)
Conserver les colonnes dans la plage spécifiée. Indiquez la plage entre deux colonnes.

select (`<column>`, all ())
Conserver toutes les colonnes, mais faire de la colonne spécifiée la première colonne.

select (`<column>`, `<column>`)
Conserver les colonnes spécifiées.

select_if

select_if(<predicateFunc>) Conserve les colonnes qui répondent à la condition spécifiée. Les fonctions prises en charge sont les suivantes :

• contient
• ends_with
• correspond à
• num_range
• starts_with

récapituler

résumez (provide_new_column = <func>(`<column>`))
Appliquer des fonctions d'agrégation aux colonnes spécifiées pour réduire les valeurs de plusieurs colonnes à une seule valeur. Veillez à regrouper d'abord les données de colonne à l'aide de l'opération group_by.

summarize_all

summarize_all (<func>)
Appliquer une fonction d'agrégation à toutes les colonnes pour réduire les valeurs de plusieurs colonnes à une seule valeur. Indiquez s'il faut supprimer les valeurs manquantes. Veillez à regrouper d'abord les données de colonne à l'aide de l'opération group_by.

summarize_all (funs (<func>))
Applique plusieurs fonctions d'agrégation à toutes les colonnes pour réduire les valeurs de plusieurs colonnes à une seule valeur. Créez de nouvelles colonnes pour contenir les résultats. Indiquez s'il faut supprimer les valeurs manquantes. Veillez à regrouper d'abord les données de colonne à l'aide de l'opération group_by.

summarize_if

Summarize_if (<predicate_conditions>, ...)
Applique des fonctions d'agrégation aux colonnes qui répondent aux conditions spécifiées pour réduire plusieurs valeurs de colonne à une seule valeur. Indiquez s'il faut supprimer les valeurs manquantes. Veillez à regrouper d'abord les données de colonne à l'aide de l'opération group_by. Les fonctions prises en charge sont les suivantes :

• nombre
• maximal
• moyenne
• min.
• écart type
• somme

compter

()
Compte le nombre de lignes (pour les colonnes de chaîne) ou calcule la somme des données (pour les valeurs numériques) par groupe. Veillez à regrouper d'abord les données de colonne à l'aide de l'opération group_by.

(wt = `<column>`)
Compte le nombre de lignes (pour les colonnes de chaîne) ou additionne les données (pour les colonnes numériques) par groupe pour la colonne pondérée.

(wt=<func>(`<column>`), sort = <logical>)
Applique une fonction à la colonne pondérée spécifiée et renvoie le résultat, par groupe, trié ou non.

top_n

top_n (provide_value)
Sélectionnez les N premières ou les dernières lignes (par valeur) de chaque groupe. Indiquez un entier positif pour sélectionner les N premières lignes ou un entier négatif pour sélectionner les N dernières lignes.

top_n (provide_value, `<column>`)
Sélectionnez les N premières ou dernières lignes (par valeur) dans chaque groupe, en fonction de la colonne spécifiée. Indiquez un entier positif pour sélectionner les N premières lignes ou un entier négatif pour sélectionner les N dernières lignes.

Si des lignes en double affectent le nombre, utilisez l'opération d'interface graphique Supprimer les doublons avant d'utiliser l'opération top_n ().

transmute

transmute (<new_or_existing_column> = `<column>`)
Ajoute une nouvelle colonne ou remplace une colonne existante à l'aide de l'expression spécifiée. Conservez uniquement les colonnes qui sont mentionnées dans l'expression.

transmute (<new_or_existing_column> = <func(column)>)
Ajoute une nouvelle colonne ou remplace une colonne existante en appliquant une fonction à la colonne spécifiée. Conservez uniquement les colonnes qui sont mentionnées dans l'expression.

transmute (<new_or_existing_column> = `<column>` <operator> `<column>`)
Ajouter une nouvelle colonne ou remplacer une colonne existante en appliquant un opérateur à la colonne spécifiée. Conservez uniquement les colonnes qui sont mentionnées dans l'expression.

transmute (<new_or_existing_column> = `<column>`, <new_or_existing_column> = `<column>`)
Ajoutez plusieurs nouvelles colonnes. Conservez uniquement les colonnes qui sont mentionnées dans l'expression.

transmute (<new_or_existing_column> = if_else (provide_value, provide_value_for_true, provide_value_for_false))
ajoute une nouvelle colonne ou remplace une colonne existante à l'aide des expressions conditionnelles spécifiées. Conservez uniquement les colonnes qui sont mentionnées dans les expressions.

dissocier

ungroup ()
Dégrouper les données.

Agréger

• moyenne
• min.
• n
• sd
• somme

Logique

• is.na

Numérique

• abs
• fusionner
• coupe
• exp
• plancher

Texte

• c
• fusionner
• coller
• tolower
• toupper

Type

• as.character
• as.double
• as.integer
• as.logical