Notes de programmation R pour les analystes de données

Notes de programmation R pour Certificat d'analyste de données IBM

Installer un paquet
install.packages("tidyverse")
Chargement d'un colis
bibliothèque (tidyverse)
La fonction installée.packages() affiche une liste des packages actuellement installés dans une session RStudio. Vous pouvez ensuite localiser les noms des packages et ce qui est nécessaire pour utiliser les fonctions du package.
installé.packages()
CRAN est une archive en ligne couramment utilisée avec des packages R et d'autres ressources R. Le CRAN s'assure que les ressources qu'il partage respectent les normes de qualité requises et
sont authentiques et valides Le package dplyr est le package spiceverse qui contient un ensemble de fonctions, telles que select(), qui facilitent la manipulation des données. Par exemple, select() sélectionne uniquement les variables pertinentes en fonction de leurs noms.

Achetez le catalogue complet de notes d'analyse de données

Vecteurs

Un vecteur est un groupe d'éléments de données du même type, stockés dans une séquence dans R. Vous ne pouvez pas avoir un vecteur contenant à la fois des valeurs logiques et numériques.

Il existe deux types de vecteurs : les vecteurs atomiques et les listes. Il existe six principaux types de vecteurs atomiques : logique, entier, double, caractère (qui contient des chaînes), complexe,
et cru.

Une façon de créer un vecteur consiste à utiliser la fonction c() (appelée fonction « combiner »). La fonction c() dans R combine plusieurs valeurs dans un vecteur. Dans R, cette fonction est juste la lettre « c » suivie des valeurs que vous souhaitez dans votre vecteur entre parenthèses, séparées par une virgule : c(x, y, z, …)

Chaque vecteur que vous créez aura deux propriétés clés : le type et la longueur.

Vous pouvez déterminer le type de vecteur avec lequel vous travaillez en utilisant la fonction typeof(). Placez le code du vecteur entre les parenthèses de la fonction. Lorsque vous exécutez la fonction, R vous indiquera le type.

Vous pouvez déterminer la longueur d'un vecteur existant, c'est-à-dire le nombre d'éléments qu'il contient, en utilisant la fonction length().

Vous pouvez également vérifier si un vecteur est d'un type spécifique en utilisant une fonction is : is.logical(), is.double(), is.integer(), is.character().

Tous les types de vecteurs peuvent être nommés. Les noms sont utiles pour écrire du code lisible et décrire des objets dans R. Vous pouvez nommer les éléments d'un vecteur avec la fonction names().

Résumé du code pour les vecteurs

x <-c(1, 3, 5) ### crée un vecteur et l'attribue à x
noms(x) <- c("a", "b", "c") ### création de noms pour les éléments
est.caractère(x) ### vérifier si le vecteur est un caractère
vecteur
type de (x) ### vérifiant le type de vecteur.

Listes

Les listes sont différentes des vecteurs atomiques car leurs éléments peuvent être de n'importe quel type, comme des dates, des blocs de données, des vecteurs, des matrices, etc. Les listes peuvent même contenir d'autres listes.

Vous pouvez créer une liste avec la fonction list(). Semblable à la fonction c(), la fonction list() est simplement une liste suivie des valeurs que vous souhaitez dans votre liste entre parenthèses.

Si vous souhaitez savoir quels types d’éléments contient une liste, vous pouvez utiliser la fonction str().

Code

liste("a", 1L, 1.5, VRAI)
str(liste("a", 1L, 1.5, VRAI))
z <- liste(liste(liste(1 , 3, 5)))
chaîne(z)
Listes de dénomination ###
liste("Chicago" = 1, "New York" = 2, "Los Angeles" = 3)

Date et l'heure

Dans R, il existe trois types de données qui font référence à un instant :

Une date ("2016-08-16")
Une heure dans une journée (« 20-11-59 UTC »)
Et une date-heure. Il s'agit d'une date plus une heure (« 2018-03-31
18-15-48 UTC »).

Conversion à partir de chaînes

Les données de date/heure se présentent souvent sous forme de chaînes. Vous pouvez convertir des chaînes en dates et dates-heures à l'aide des outils fournis par lubridate. Ces outils déterminent automatiquement le format date/heure. Tout d’abord, identifiez l’ordre dans lequel l’année, le mois et le jour apparaissent dans vos dates. Ensuite, disposez les lettres y, m et d dans le même ordre. Cela vous donne le nom de la fonction de lubrification qui va
analysez votre date. Par exemple, pour la date 20/01/2021, vous utilisez la commande ymd :

Code

jour("20/01/2021")
mdy(« 20 janvier 2021 »)
dmy(« 20 janvier 2021 »)
jour(20210120)

La sortie ### pour tous est ci-dessous
#> [1] « 20/01/2021 »

Création de composants date-heure

La fonction ymd() et ses variantes créent des dates. Pour créer une date-heure à partir d'une date, ajoutez un trait de soulignement et une ou plusieurs des lettres h, m et s (heures, minutes, secondes) au nom de la fonction.

Code

ymd_hms(«2021-01-20 20:11:59»)
### #> [1] «2021-01-20 20:11:59 UTC»
mdy_hm(«20/01/2021 08:01»)
### #> [1] «2021-01-20 08:01:00 UTC»

Basculer entre les objets date-heure existants

Vous pouvez utiliser la fonction as_date() pour convertir une date-heure en date. Par exemple, mettez la date-heure actuelle—now()—entre parenthèses de la fonction

Code

as_date(maintenant())
#> [1] « 20/01/2021 »

Trames de données

Un bloc de données est un ensemble de colonnes, semblable à une feuille de calcul ou à une table SQL. Chaque colonne porte un nom en haut qui représente une variable et comprend une observation par ligne. Les blocs de données aident à résumer les données et à les organiser dans un format facile à lire et à utiliser.

Si vous devez créer manuellement un bloc de données dans R, vous pouvez utiliser la fonction data.frame(). La fonction data.frame() prend des vecteurs en entrée. Entre parenthèses, saisissez le nom de la colonne, suivi d'un signe égal, puis du vecteur que vous souhaitez saisir pour cette colonne.

La fonction mutate() peut être utilisée pour apporter des modifications à une donnée
cadre

Code

### La colonne _x_ est un vecteur avec les éléments 1, 2, 3 et la colonne _y_ est un vecteur avec les éléments 1.5, 5.5, 7.5
data.frame(x = c(1, 2, 3) , y = c(1,5, 5,5, 7,5))

Des dossiers

Utilisez la fonction dir.create pour créer un nouveau dossier ou répertoire pour contenir vos fichiers. Placez le nom du dossier entre parenthèses de la fonction.

Utilisez la fonction file.create() pour créer un fichier vierge. Placez le nom et le type du fichier entre parenthèses de la fonction. Vos types de fichiers seront généralement quelque chose comme .txt, .docx ou .csv.

La copie d'un fichier peut être effectuée à l'aide de la fonction file.copy(). Entre parenthèses, ajoutez le nom du fichier à copier. Ensuite, tapez une virgule et ajoutez le nom du dossier de destination dans lequel vous souhaitez copier le fichier.

Vous pouvez supprimer les fichiers R à l'aide de la fonction unlink(). Entrez le nom du fichier entre parenthèses de la fonction.

Code

dir.create (« dossier_destination »)
fichier.create (« new_text_file.txt »)
fichier.create (« nouveau_word_file.docx »)
fichier.create (« nouveau_csv_file.csv »)
fichier.copie (« new_text_file.txt », « destination_folder »)
dissocier (« some_.file.csv »)

Matrices

Une matrice est une collection bidimensionnelle d’éléments de données. Cela signifie qu'il comporte à la fois des lignes et des colonnes. En revanche, un vecteur est une séquence unidimensionnelle d’éléments de données. Mais comme les vecteurs, les matrices ne peuvent contenir qu’un seul type de données. Par exemple, vous ne pouvez pas avoir à la fois des valeurs logiques et numériques dans une matrice.

Pour créer une matrice dans R, vous pouvez utiliser la fonction matrice(). La fonction matrice() a deux arguments principaux que vous entrez entre parenthèses. Tout d’abord, ajoutez un vecteur. Le vecteur contient les valeurs que vous souhaitez placer dans la matrice. Ensuite, ajoutez au moins une dimension matricielle. Vous pouvez choisir de spécifier le nombre de lignes ou le nombre de colonnes en utilisant le code nrow = ou ncol =.

Par exemple, imaginez que vous souhaitiez créer une matrice 23 (deux lignes par trois colonnes) contenant les valeurs 38. Tout d’abord, entrez un vecteur contenant cette série de nombres : c(38. Ensuite, entrez une virgule. Enfin, entrez nrow = 2 pour spécifier le nombre de lignes.

Vous pouvez également choisir de spécifier le nombre de colonnes (ncol = ) au lieu du nombre de lignes (nrow = ).

Code

matrice(c(3:8), nrow = 2)
matrice(c(3:8), ncol = 2)

Opérateurs logiques et instructions conditionnelles

Les opérateurs logiques renvoient un type de données logique tel que VRAI ou FAUX.
Il existe trois principaux types d'opérateurs logiques :
● AND (parfois représenté par & ou && dans R)
● OR (parfois représenté par | ou || dans R)
● PAS (!)

Voyons comment créer des instructions conditionnelles dans R à l'aide de trois instructions liées :
● si()
● autre()
● sinon si()
L'instruction if définit une condition, et si la condition est évaluée à TRUE, le code R associé à l'instruction if est exécuté.
si (x > 0) {
print("x est un nombre positif")
}
L'instruction else est utilisée en combinaison avec une instruction if. Voici comment le code est structuré dans R :

Code
x <- 7
si (x > 0) {
print("x est un nombre positif")
}
autre {
print (« x est soit un nombre négatif, soit zéro »)
}
Dans certains cas, vous souhaiterez peut-être personnaliser encore plus votre instruction conditionnelle en ajoutant l'instruction else if. L’instruction else if se situe entre l’instruction if et l’instruction else.

Code
x <- -1
si (x < 0) {
print("x est un nombre négatif")
}
sinon si (x == 0) {
print("x vaut zéro")
}
autre {
print("x est un nombre positif")
}
La principale différence entre les opérateurs logiques élément par élément (&, |) et les opérateurs logiques (&&, ||) réside dans la manière dont ils s'appliquent aux opérations avec des vecteurs. Les opérations avec doubles signes, ET
(&&) et OU logique (||), examinez uniquement le premier élément de chaque vecteur. Les opérations avec des signes simples, AND (&) et OR (|), examinent tous les éléments de chaque vecteur.

Un tube est un outil permettant d'exprimer une séquence de plusieurs opérations dans R (dans ce cas, le filtrage et le regroupement). L'opérateur d'un tuyau est %>%.

Code

voitures mt %>%
filtre (carb > 1) %>%
group_by(cyl) %>%

Tibbles

Les Tibbles sont comme des blocs de données rationalisés qui sont automatiquement configurés pour afficher uniquement les 10 premières lignes d'un ensemble de données, et seulement autant de colonnes que peut tenir l'écran. Dans l'ensemble, vous pouvez apporter davantage de modifications aux trames de données, mais les tibbles sont plus faciles à utiliser.

Code

### chargement du Tidyverse
bibliothèque (tidyverse)
### chargement de l'ensemble de données sur les diamants
données (diamants)
### afficher l'ensemble de données
Vue(diamants)
### crée le tibble à partir de l'ensemble de données
as_tibble (diamants)

Importation de données

Vous pouvez utiliser la fonction data() pour charger ces ensembles de données dans R. Si vous exécutez la fonction data sans argument, R affichera une liste des ensembles de données disponibles.
Si vous souhaitez charger un ensemble de données spécifique, entrez simplement son nom entre parenthèses dans la fonction data()

lecteur

Le package readr fait partie du noyau Tidyverse. En plus d'utiliser les ensembles de données intégrés de R, il est également utile d'importer des données provenant d'autres sources pour les utiliser à des fins de pratique ou d'analyse. Le package readr dans R est un excellent outil pour lire des données rectangulaires. Les données rectangulaires sont des données qui s'intègrent parfaitement dans un rectangle de lignes et de colonnes, chaque colonne faisant référence à une seule variable et chaque ligne faisant référence à une seule observation.

L'objectif de readr est de fournir un moyen rapide et convivial de lire des données rectangulaires. readr prend en charge plusieurs fonctions read_. Chaque fonction fait référence à un format de fichier spécifique.

read_csv() : fichiers CSV séparés par des virgules
read_tsv() : fichiers séparés par des tabulations
read_delim() : fichiers délimités généraux
read_fwf() : fichiers à largeur fixe
read_table() : fichiers tabulaires où les colonnes sont séparées par
espace blanc
read_log() : fichiers journaux Web

Code

### Pour répertorier les exemples de fichiers, vous pouvez exécuter le
fonction readr_example() sans arguments
readr_example()
### Lorsque vous exécutez la fonction, R imprime une spécification de colonne qui donne le nom et le type de chaque colonne.
read_csv(readr_example("mtcars.csv"))
read_csv("mtcars.csv")

lirexl

Pour importer des données de feuille de calcul dans R, vous pouvez utiliser le package readxl. Le package readxl facilite le transfert de données d'Excel vers R. Readxl prend en charge à la fois l'ancien format de fichier .xls et le format de fichier .xlsx moderne basé sur XML.

Code

bibliothèque (readxl)
readxl_example()
read_excel(readxl_example("type-me.xlsx"))
### Vous pouvez utiliser la fonction excel_sheets() pour lister les noms des feuilles individuelles
excel_sheets(readxl_example("type-me.xlsx"))
### Vous pouvez également spécifier une feuille par son nom ou son numéro. Tapez simplement « sheet = » suivi du nom ou du numéro de la feuille. Par exemple, vous pouvez utiliser la feuille nommée « numeric_coercion » dans la liste ci-dessus.
read_excel(readxl_example(“type-me.xlsx”), feuille ="coercition_numérique")
### Lorsque vous exécutez la fonction, R renvoie un tibble de la feuille

Les opérateurs

Dans R, il existe quatre principaux types d’opérateurs :

Arithmétique
Relationnel
Logique
Affectation

Des données ordonnées

Il existe des raisons impérieuses d’utiliser les deux formats. Mais en tant qu’analyste, il est important de savoir comment ranger les données lorsque cela est nécessaire. Dans R, vous pouvez avoir un bloc de données dans un format large comportant plusieurs variables et conditions pour chaque variable. Cela pourrait sembler un peu compliqué.

C'est là que pivot_longer() entre en jeu. Dans le cadre du package Tidyr, vous pouvez utiliser cette fonction R pour allonger les données d'un bloc de données en augmentant le nombre de lignes et en diminuant le nombre de colonnes. De même, si vous souhaitez convertir vos données pour avoir plus de colonnes et moins de lignes, vous utiliserez la fonction pivot_wider().

Visualiser des données avec ggplot2

Le package ggplot2 vous permet de créer des tracés personnalisables de haute qualité de vos données. Pour rappel, ggplot2 est basé sur la grammaire des graphiques, qui est un système permettant de décrire et de créer des visualisations de données. L'idée essentielle derrière la grammaire graphique est que vous pouvez construire n'importe quelle intrigue à partir des mêmes composants de base, comme les blocs de construction.

Ces éléments de base comprennent :

Un ensemble de données
Un ensemble de géométries : une géom fait référence à l'objet géométrique utilisé pour représenter vos données. Par exemple, vous pouvez utiliser des points pour créer un nuage de points, des barres pour créer un graphique à barres, des lignes pour créer un diagramme linéaire, etc.
Un ensemble d'attributs esthétiques : Une esthétique est une propriété visuelle d'un objet dans votre parcelle. Vous pouvez considérer une esthétique comme une connexion, ou une cartographie, entre un élément visuel de votre intrigue
et une variable dans vos données. Par exemple, dans un nuage de points, l'esthétique inclut des éléments tels que la taille, la forme, la couleur ou l'emplacement (axe des x, axe des y) de vos points de données.

Pour créer un tracé avec ggplot2, vous choisissez d'abord un ensemble de données. Ensuite, vous déterminez comment organiser visuellement vos données sur un système de coordonnées en choisissant une géométrie pour représenter vos points de données et une esthétique pour cartographier vos variables.

Code

install.packages('ggplot2')
install.packages('dplyr')
### Installer l'ensemble de données
install.packages('palmerpenguins')
bibliothèque (ggplot2)
bibliothèque (dplyr)
### charger l'ensemble de données
bibliothèque (pingouins palmiers)
données (pingouins)
### Afficher l'ensemble de données
Vue(pingouins)
### ggplot(data = penguins) :** Dans ggplot2, vous commencez un tracé avec la fonction ggplot(). La fonction ggplot() crée un système de coordonnées auquel vous pouvez ajouter des calques. Le premier argument de la fonction ggplot() est l'ensemble de données à utiliser dans le tracé. Dans ce cas, ce sont des « pingouins ».
### Ensuite, vous ajoutez un symbole «+» pour ajouter un nouveau calque à votre tracé. Vous complétez votre tracé en ajoutant une ou plusieurs couches à ggplot().
### geom_point()** : Ensuite, vous choisissez une géom en ajoutant une fonction geom. La fonction geom_point() utilise des points pour créer des nuages de points, la fonction geom_bar utilise des barres pour créer des graphiques à barres, etc. Dans ce cas, choisissez la fonction geom_point pour créer un nuage de points de points. Le package ggplot2 est livré avec de nombreuses fonctions geom différentes. Vous en apprendrez davantage sur les géoms plus tard dans ce cours.
### (mapping = aes(x = flipper_length_mm, y = body_mass_g))** : Chaque fonction geom dans ggplot2 prend un argument de mappage. Cela définit la façon dont les variables de votre ensemble de données sont mappées aux propriétés visuelles. L'argument mapping est toujours associé à la fonction aes(). Les arguments x et y de la fonction aes() spécifient les variables à mapper sur l'axe x et l'axe y du système de coordonnées. Dans ce cas, vous souhaitez mapper la variable « flipper_length_mm » sur l'axe des x et la variable « body_mass_g » sur l'axe des y.
ggplot(data = pingouins) + geom_point(mapping = aes(x = flipper_length_mm, y = body_mass_g))
### ou préciser également les attributs esthétiques
ggplot(pingouins, aes(x = flipper_length_mm, y = body_mass_g,color=carrier, size=air_time, shape = carrier )) + géom_point()
### Smoothing** permet de détecter une tendance des données même lorsque vous ne pouvez pas facilement remarquer une tendance à partir des points de données tracés. La fonctionnalité de lissage de Ggplot2 est utile car elle ajoute une **ligne de lissage** comme autre calque à un tracé ; la ligne de lissage aide les données à avoir un sens pour un observateur occasionnel
### **Lissage Gam** utile pour lisser les tracés comportant un grand nombre de points.
ggplot(pingouins, aes(x = flipper_length_mm, y = body_mass_g)) + geom_point() + geom_smooth(method=”gam” , formule = y ~s(x))
### **Lissage au loess** Le processus de lissage au loess est idéal pour lisser les tracés de moins de 1 000 points.
ggplot(pingouins, aes(x = flipper_length_mm, y = body_mass_g)) + geom_point() + geom_smooth(method=”loess”)
### géom_jitter()
### L'analyste pourrait utiliser la fonction geom_jitter() pour faciliter la recherche des points. La fonction geom_jitter() ajoute une petite quantité de bruit aléatoire à chaque point du tracé, ce qui permet de gérer le chevauchement des points.
### La fonction facet_wrap(~ variable_name) vous permet d'afficher des groupes plus petits, ou sous-ensembles, de vos données.
### labs() pour créer un titre pour votre visualisation et annoter() pour ajouter des notes à votre tracé.
### **ggsave('filename.jpg')** pour enregistrer votre tracé

Documentation et rapports

R Markdown est un outil utile qui vous permet d'enregistrer et d'exécuter du code et de générer des rapports partageables pour les parties prenantes.
R Markdown est un format de fichier permettant de créer des documents dynamiques avec R. Ces documents, également appelés cahiers, sont des enregistrements d'analyse qui vous aident, ainsi que les membres de votre équipe et les parties prenantes, à comprendre ce que vous avez fait dans votre analyse pour parvenir à vos conclusions. Vous pouvez publier un bloc-notes sous forme de fichier HTML, PDF ou Word, ou dans un autre format comme un diaporama.

Les fonctions

- organiser ()

La fonction dplyr arrange() peut être utilisée pour réorganiser (ou trier) les lignes selon une ou plusieurs variables.

Réorganiser les lignes par Sepal.Length par ordre croissant
Réorganisez les lignes par Sepal.Length par ordre décroissant. Utilisez la fonction desc() :
Réorganiser les lignes selon plusieurs variables : Sepal.Length et Sepal.width

Code

my_data %>% organiser (Sepal.Length)
mes_données %>% organiser(desc(Sepal.Length))
organiser (mes_données, -Sepal.Length)

– as_data_frame()

Convertir les données chargées en tibble

Code

# Créer mes_données
mes_données <- iris
# Convertir en bibliothèque tibble (« tibble »)
mes_données <- as_data_frame(mes_données)
# Imprimer
mes données

- données()

Pour répertorier les ensembles de données disponibles

– unir()
La fonction unit() peut être utilisée pour combiner des colonnes
– noms_clean()
La fonction clean_names() s'assurera automatiquement que les noms de colonnes sont uniques et cohérents
– noms de colonnes (ensemble de données ou dataframe)

Obtenez une liste des noms de colonnes

– skim_without_charts(dataset) ou glimpse() ou summary()

Obtenez une vue complète et des informations sur l’ensemble de données.

– filtre ()
La fonction de filtre permet à l'analyste de données de spécifier quelle partie des données il souhaite afficher

Code

Question 5

Un analyste de données travaille avec les données des pingouins. Ils
écrivez le code suivant :
pingouins %>%
La variable _species_ comprend trois espèces de manchots : Adélie, à Jugulaire et Gentoo. Quel morceau de code l'analyste ajoute-t-il pour créer un bloc de données qui inclut uniquement le
Espèce Gentoo ?
filtre(espèce == « Gentoo »)

- subir une mutation ()

Manipuler le dataframe et les colonnes

Code

Question 7
Un analyste de données travaille avec un bloc de données appelé _salary_data_. Ils souhaitent créer une nouvelle colonne nommée _total_wages_ qui additionne les données des colonnes _standard_wages_ et _overtime_wages_. Quel morceau de code permet à l'analyste de créer la colonne _total_wages_ ?
muter (salary_data, total_wages = standard_wages + heures supplémentaires_wages)

- biais()

La fonction biais() peut être utilisée pour calculer la différence moyenne entre le résultat prédit et le résultat réel afin de déterminer si le modèle de données est biaisé.

Étude de cas

En tant que membre de l'équipe de science des données chez Gourmet Analytics, vous utilisez l'analyse de données pour conseiller les entreprises de l'industrie alimentaire. Vous nettoyez, organisez et visualisez les données pour obtenir des informations qui profiteront à vos clients. En tant que membre d'une équipe collaborative, partager votre analyse avec d'autres est une partie importante de votre travail.

Votre client actuel est Chocolate and Tea, une chaîne de cafés en plein essor.

Le restaurant combine une vaste carte de thés raffinés avec des barres de chocolat du monde entier. Leur sélection diversifiée comprend de tout, du chocolat au lait plantain au chocolat blanc à la mandarine, en passant par le chocolat noir à la pistache et à la figue. La liste encyclopédique des barres chocolatées est à la base de l'attrait de la marque Chocolate and Tea. Les ventes de barres chocolatées constituent le principal moteur de revenus.

Chocolate and Tea vise à servir des barres de chocolat très appréciées par les critiques professionnels. Ils ajustent également continuellement le menu pour s'assurer qu'il reflète la diversité mondiale de la production de chocolat. L'équipe de direction met régulièrement à jour la liste des barres chocolatées afin de s'aligner sur les dernières évaluations et de s'assurer que la liste contient des barres provenant d'une variété de pays.

Ils vous ont demandé de collecter et d'analyser des données sur les dernières évaluations du chocolat. Ils aimeraient notamment savoir quels pays produisent les barres de chocolat super noir les mieux notées (un pourcentage élevé de cacao). Ces données les aideront à créer leur prochain menu de barre chocolatée.

Code

bibliothèque (tidyverse)
### Avant de commencer à travailler avec vos données, vous devez les importer et les enregistrer sous forme de bloc de données. Pour commencer, vous ouvrez votre espace de travail RStudio et chargez la bibliothèque Tidyverse. Vous téléchargez un fichier .csv contenant les données sur RStudio et le stockez dans un dossier de projet nommé spices_of_cacao.csv.
### **Vous utilisez la fonction read_csv() pour importer les données du fichier .csv. Supposons que le nom du bloc de données est bars_df et que le fichier .csv se trouve dans le répertoire de travail.** **Quel morceau de code vous permet de créer le bloc de données ?**
bars_df <- read_csv(“flavors_of_cacao.csv”)
### Maintenant que vous avez créé un bloc de données, vous souhaitez en savoir plus sur la manière dont les données sont organisées. Le bloc de données comporte des centaines de lignes et de nombreuses colonnes.
### **Supposons que le nom de votre bloc de données soit spices_df.**
**Quel morceau de code vous permet de consulter les noms de colonnes dans le bloc de données ?**
noms de colonnes (flavors_df)
### Ensuite, vous commencez à nettoyer vos données. Lorsque vous consultez les en-têtes de colonnes dans votre bloc de données, vous remarquez que la première colonne est nommée _Company…Maker.if.known._ (Remarque : le point après _known_ fait partie du nom de la variable.) Par souci de clarté et de cohérence. , vous décidez de renommer cette colonne _Société_ (sans point à la fin).
renommer (Entreprise… Créateur.if.connu. <- Entreprise)
### Après avoir prévisualisé et nettoyé vos données, vous déterminez quelles variables sont les plus pertinentes pour votre analyse. Votre objectif principal est _Rating_, _Cocoa.Percent_ et _Company_. Vous décidez d'utiliser la fonction select() pour créer un nouveau bloc de données avec uniquement ces trois variables. **Ajoutez le morceau de code qui vous permet de sélectionner les trois variables.**
sélectionnez (Note, Cocoa.Percent, Entreprise)
### Ensuite, vous sélectionnez les statistiques de base qui peuvent aider votre équipe à mieux comprendre le système de notation de vos données.
### **Supposons que la première partie de votre code soit :**
### trimmed_flavors_df %>%
### **Vous souhaitez utiliser les fonctions summary() et max() pour trouver la note maximale de vos données. Ajoutez le morceau de code qui vous permet de trouver la valeur maximale de la variable** **_Rating_**
###Après avoir complété votre analyse du système de notation, vous déterminez que toute note supérieure ou égale à 3,9 points peut être considérée comme une note élevée. Vous savez également que Chocolate and Tea considère une barre comme du chocolat super noir si le pourcentage de cacao de la barre est supérieur ou égal à 75%. Vous décidez de créer un nouveau bloc de données pour savoir quelles tablettes de chocolat remplissent ces deux conditions.
###**Supposons que la première partie de votre code soit :**
### best_trimmed_flavors_df <- trimmed_flavors_df %>%
###**Vous souhaitez appliquer la fonction filter() aux variables** **_Cocoa.Percent_** **et** **_Rating_****. Ajoutez le morceau de code qui vous permet de filtrer le bloc de données pour les barres de chocolat contenant au moins 75% de cacao et ayant une note d'au moins 3,9 points.**
filtre (Cocoa.Percent >= '75%' & Note >= 3.9)
### Maintenant que vous avez nettoyé et organisé vos données, vous êtes prêt à créer des visualisations de données utiles. Votre équipe vous confie la tâche de créer une série de visualisations basées sur les demandes de l'équipe de direction de Chocolat et Thé. Vous décidez d'utiliser ggplot2 pour créer vos visuels.
### **Supposons que votre première ligne de code soit :**
### ggplot(données = best_trimmed_flavors_df) +
### **Vous souhaitez utiliser la fonction geom_bar() pour créer un graphique à barres. Ajoutez le morceau de code qui vous permet de créer un graphique à barres avec la variable** **_Rating_** **sur l'axe des x**
geom_bar(mapping = aes(x =Note))
### Votre graphique à barres révèle les emplacements qui produisent les barres de chocolat les mieux notées. Pour avoir une meilleure idée de la note spécifique de chaque emplacement, vous souhaitez mettre en évidence chaque barre.
### **Supposons que vous travaillez avec les éléments suivants code:**
### ggplot(données = best_trimmed_flavors_df) +
### geom_bar(mapping = aes(x = Company.Location))
### **Ajoutez un morceau de code à la deuxième ligne de code pour mapper l'esthétique** **_fill_** **à la variable** **_Rating_****.**
### **REMARQUE : les trois points (…) indiquent où ajouter le morceau de code.**
geom_bar(mapping = aes(x = Company.Location, fill=Rating))
### Un coéquipier crée un nouveau tracé basé sur les données de la barre de chocolat. Le coéquipier vous demande d'apporter quelques révisions à son code.
### **Supposons que votre coéquipier partage le code suivant
tronçon:**
### ggplot(données = best_trimmed_flavors_df) +
geom_bar(mapping = aes(x = Société)) +
### **Quel morceau de code ajoutez-vous à la troisième ligne pour créer des facettes de bouclage de la variable** **_Company_**
facet_wrap(~Société)
### Votre équipe a créé quelques visualisations de base pour explorer différents aspects des données sur les barres de chocolat. Vous vous êtes porté volontaire pour ajouter des titres aux intrigues. Vous commencez avec un nuage de points.
### **Supposons que la première partie de votre bloc de code soit :**
### ggplot(data = trimmed_flavors_df) + geom_point(mapping = aes(x = Cocoa.Percent, y = Note)) +
### **Quel morceau de code ajoutez-vous à la troisième ligne pour ajouter le titre** **_Suggested Chocolate_** **à votre intrigue**
laboratoires(titre = « Chocolat suggéré »)
### Ensuite, vous créez un nouveau nuage de points pour explorer la relation entre différentes variables. Vous souhaitez sauvegarder votre parcelle pour pouvoir y accéder plus tard. Vous savez que la fonction ggsave() enregistre par défaut le dernier tracé que vous avez affiché dans RStudio, vous êtes donc prêt à écrire le code pour enregistrer votre nuage de points.
### **Supposons que vos deux premières lignes de code soient :**
### ggplot(data = trimmed_flavors_df) + geom_point(mapping = aes(x = Cocoa.Percent, y = Note))
### **Quel morceau de code ajoutez-vous à la troisième ligne pour enregistrer votre tracé sous forme de fichier JPEG avec** **_chocolate_** **comme nom de fichier**
ggsave("chocolat.jpeg")