INTRODUCTION

IMPORTING DATA IN R

Description du cours
L'importation de données dans R devrait être l'étape la plus simple de votre
analyse. Malheureusement, ce n'est presque jamais le cas. Les données peuvent
se présenter sous de nombreux formats, allant des fichiers .csv et texte aux
fichiers de logiciels statistiques, en passant par les bases de données et les
données HTML. Il est essentiel de savoir quelle approche utiliser pour
commencer l'analyse proprement dite. Dans ce cours, vous commencerez par
apprendre à lire les fichiers .csv et texte dans R. Vous couvrirez ensuite les
packages readr et data.table pour importer facilement et efficacement des
données de fichiers plats. Après cela, vous apprendrez à lire les fichiers .xls dans
R en utilisant readxl et gdata.

1- Importation de données à partir de fichiers plats avec

utils
De nombreuses données se présentent sous la forme de fichiers plats : de
simples fichiers texte tabulaires. Apprenez à importer les formats courants de
données de fichiers plats avec les fonctions de base R.

Données
https://assets.datacamp.com/production/repositories/453/datasets/
3e5a732b4467c1cbed6a8e8e7a1c9eec3fc86c58/hotdogs.txt
https://assets.datacamp.com/production/repositories/453/datasets/
b47d250de5379914100e28075556fb24e55ca2cd/potatoes.csv
https://assets.datacamp.com/production/repositories/453/datasets/
d78f476c64cf9bc91d4467ff64769afd64d4b450/potatoes.txt
https://assets.datacamp.com/production/repositories/453/datasets/
0badb39b50c7daf000698efbca476716db7c1a6f/swimming_pools.csv
http://data.gov.au/storage/f/2013-05-12T203717/tmpwyuGTwswimming.csv
Présentation et lecture.csv
1. Introduction & read.csv
Bonjour et bienvenue dans le premier cours d'importation de données dans R.

2. Importation de données dans R

Imaginez cette situation : un de vos collègues fait toujours ses analyses dans
Excel et a finalement décidé de passer à R. Il a besoin d'un moyen simple de
convertir les feuilles de calcul Excel en blocs de données R,

3. Importation de données dans R

mais il n'arrive pas à trouver les outils pour le faire. Eh bien, apprendre à
connaître ces outils est exactement ce que nous allons faire ici.

4. 5 types
Dans ce cours en deux parties, nous nous concentrerons sur 5 types de données :

5. 5 types
données de fichiers plats,

6. 5 types
données d'Excel,

7. 5 types
les données des bases de données,

8. 5 types
données du Web,
9. 5 types
et enfin les données d'autres logiciels statistiques comme SAS, SPSS et Stata.

10. 5 types
Vous apprendrez à convertir chaque format de données, l'un après l'autre, en un
bloc de données R, prêt à effectuer des analyses sophistiquées.

11. Fichiers plats

Commençons par les fichiers plats. Les fichiers plats sont généralement de
simples fichiers texte qui affichent des données sous forme de tableaux. Jetez un
œil à cet exemple, states-dot-csv, un fichier plat où CSV signifie valeurs
séparées par des virgules. Les données répertorient des informations de base sur
certains États américains. La première ligne donne ici les noms des différentes
colonnes ou champs. Après cela, chaque ligne est un enregistrement et les
champs sont séparés par une virgule, d'où l'extension CSV. Par exemple, il y a
l'État d'Hawaï avec la capitale Honolulu et une population totale de 1 virgule à
42 millions. À quoi ressembleraient ces données dans R ? Eh bien, en fait, la
structure correspond bien à une trame de données dans R, qui ressemble
idéalement à ceci : les lignes dans la trame de données correspondent aux
enregistrements et les colonnes de la trame de données correspondent aux
champs. Les noms de champs sont utilisés pour nommer les colonnes du bloc de
données. Mais comment passer du fichier CSV à cette trame de données ? Nous
avons de la chance, car la distribution standard de R fournit des fonctionnalités
pour importer ces fichiers plats dans R en tant que trame de données.

12. utilitaires - read.csv

Ces fonctions appartiennent au package utils qui est chargé par défaut lorsque
vous démarrez R. Plus précisément, nous aurons besoin de la fonction read-dot-
csv, comme suit : Le premier argument de read-dot-csv est le chemin d'accès au
fichier vous souhaitez importer dans R. Si le fichier se trouve dans votre
répertoire de travail actuel, il suffit de passer le nom du fichier sous forme de
chaîne de caractères. Si votre fichier se trouve ailleurs, les choses se
compliquent. Selon la plate-forme sur laquelle vous travaillez, Linux, Microsoft,
Mac, peu importe, les chemins de fichiers sont spécifiés différemment. Pour
créer un chemin d'accès à un fichier d'une manière indépendante de la plate-
forme, vous pouvez utiliser la fonction file-dot-path. Supposons que notre
fichier states-dot-csv se trouve dans le dossier datasets du répertoire de base.
Vous pouvez utiliser file-dot-path comme ceci : Parce que je travaille sur un
Mac, c'est le chemin résultant. Je peux maintenant utiliser ce chemin dans read-
dot-csv pour pointer vers le bon fichier, comme ceci. Le deuxième argument,
stringsAsFactors, est assez important. Disons que nous avons des colonnes qui
sont des chaînes. Nous pouvons choisir d'importer ces colonnes en tant que
chaînes réelles ou en tant que facteurs, que R utilise pour stocker des variables
catégorielles. Par défaut, l'argument stringsAsFactors est TRUE, il convertirait
donc les chaînes en facteurs. Dans notre cas, cependant, les noms d'état et de
majuscule ne doivent pas être des variables catégorielles, nous définissons donc
stringsAsFactors sur FALSE. il convertirait donc les chaînes en facteurs. Dans
notre cas, cependant, les noms d'état et de majuscule ne doivent pas être des
variables catégorielles, nous définissons donc stringsAsFactors sur FALSE. il
convertirait donc les chaînes en facteurs. Dans notre cas, cependant, les noms
d'état et de majuscule ne doivent pas être des variables catégorielles, nous
définissons donc stringsAsFactors sur FALSE.

13. read.csv()
Si nous exécutons cet appel maintenant, nous pouvons voir que nous obtenons
une base de données avec 5 observations et 4 variables. Cela correspond bien au
fichier CSV avec lequel nous avons commencé. Si nous affichons la structure de
cette trame de données, avec str, nous voyons qu'effectivement, les deux
premières colonnes sont des chaînes, et non des facteurs, exactement comme
nous le voulions !

14. Entraînons-nous !
D'accord, c'est suffisant pour commencer pour l'instant. Il est temps de donner
un premier essai à l'importation de données dans R dans les exercices !

lire.csv
Le utilspackage, qui est automatiquement chargé dans votre session R au
démarrage, peut importer des fichiers CSV avec la read.csv()fonction.
Dans cet exercice, vous travaillerez avec swimming_pools.csv; il contient des
données sur les piscines de Brisbane, en Australie (Source : data.gov.au ). Le
fichier contient les noms de colonnes dans la première ligne. Il utilise une
virgule pour séparer les valeurs dans les lignes.

Tapez dir()dans la console pour lister les fichiers dans votre répertoire de travail.
Vous verrez qu'il contient swimming_pools.csv, vous pouvez donc commencer
tout de suite.
Instructions
Utilisez read.csv()pour importer en "swimming_pools.csv"tant que bloc de
données avec le nom pools.
Imprimer la structure pools d'utilisation str().

ChaînesAsFactors
Avec stringsAsFactors, vous pouvez indiquer à R s'il doit convertir les chaînes
du fichier plat en facteurs.

Pour toutes les fonctions d'importation du utilspackage, cet argument est TRUE,
ce qui signifie que vous importez des chaînes en tant que facteurs. Cela n'a de
sens que si les chaînes que vous importez représentent des variables
catégorielles dans R. Si vous définissez stringsAsFactorssur FALSE, les
colonnes du bloc de données correspondant aux chaînes de votre fichier texte
seront character.

Vous travaillerez à nouveau avec le swimming_pools.csvfichier. Il contient deux

colonnes ( Nameet Address), qui ne devraient pas être des facteur
Instructions
Utilisez read.csv()pour importer les données dans "swimming_pools.csv"un bloc
de données appelé pools; assurez-vous que les chaînes sont importées en tant
que caractères et non en tant que facteurs.
À l'aide de str(), affichez la structure du jeu de données et vérifiez que vous
obtenez bien des vecteurs de caractères au lieu de facteurs.
Tout changement?
Considérez le code ci-dessous qui charge les données de swimming_pools.csv
deux manières distinctes :

# Option A
pools <- read.csv("swimming_pools.csv", stringsAsFactors = TRUE)

# Option B
pools <- read.csv("swimming_pools.csv", stringsAsFactors = FALSE)
Combien de variables dans le bloc de pools données résultant ont des types
différents si vous spécifiez l' stringsAsFactors argument différemment ?

Le swimming_pools.csv fichier est disponible dans votre répertoire de travail

actuel afin que vous puissiez expérimenter dans la console.
Instructions
Des réponses possibles
Deux variables : Name et Address.
Tu as la bonne réponse! En effet, les deux Name et Addresss ont touchés.

read.delim & read.table

1. read.delim & read.table
Dans la vidéo précédente, vous avez découvert read-dot-csv, qui est une
fonction R qui existe spécifiquement pour l'importation de données CSV.
Cependant, les données de fichier plat ne sont pas uniquement des valeurs
séparées par des virgules.

2. Fichier délimité par des tabulations

Un autre format courant de données de fichier plat est le fichier délimité par des
tabulations, comme celui-ci States-dot-txt, avec les mêmes données
qu'auparavant : pour l'importer, nous aurons besoin de read-dot-delim cette fois.
Comme d'habitude, vous spécifiez simplement le chemin d'accès au fichier, et
aussi que nous voulons importer des chaînes en tant que chaînes, et non en tant
que facteurs. Fonctionne comme un charme! Si vos données sont présentées
dans ce format typique séparé par des virgules ou des tabulations, votre vie est
facile et l'importation des données est une promenade dans le parc. Si ce n'est
pas le cas, vous devrez faire un peu plus de travail de personnalisation.

3. Format de fichier exotique

Supposons que nous ayons à nouveau les mêmes données d'état, mais cette fois,
les valeurs sont séparées par une barre oblique au lieu de virgules ou de
tabulations, dans un fichier states2.txt. Que faire à ce propos? read-dot-csv et
read-dot-delim ne vous seront d'aucune utilité dans ce cas.

4. read.table()
Ici, vous voudrez utiliser read-dot-table. C'est la principale fonction
d'importation du package utils, vous permettant de lire n'importe quel fichier au
format table et de créer un bloc de données à partir de celui-ci. Le nombre
d'arguments que vous pouvez spécifier pour cette fonction est énorme, je ne vais
donc pas passer en revue chacun de ces arguments. Au lieu de cela, examinons
l'appel read-dot-table qui importe states2.txt et essayons de comprendre ce qui se
passe. Comme d'habitude, le premier argument est le chemin du fichier que vous
souhaitez importer. L'argument d'en-tête est quelque chose que nous n'avons
jamais vu auparavant. Si vous définissez ceci sur TRUE, vous dites à R que la
première ligne du fichier texte contient les noms de variables, ce qui est le cas
ici. read-dot-table définit cet argument sur FALSE par défaut, ce qui signifierait
que la première ligne est toujours lue comme une observation, même si elle' sa
ligne de noms de variables. Ensuite, sep est l'argument qui spécifie comment les
champs d'un enregistrement sont séparés. Pour notre fichier ici, le séparateur de
champ est une barre oblique, comme celle-ci. Enfin, il y a à nouveau l'argument
stringsAsFactors, que nous définissons à nouveau sur FALSE car nous voulons
importer des chaînes en tant que chaînes. Le résultat est comme on le voudrait,
sympa ! Outre les arguments dont nous avons discuté ici, il existe également des
moyens de spécifier des noms de colonnes et des types de colonnes.

5. Entraînons-nous !
Obtenez un peu de pratique dans les exercices.
lire.delim
Outre les .csvfichiers, il existe également des .txtfichiers qui sont
essentiellement des fichiers texte. Vous pouvez importer ces fonctions avec
read.delim(). Par défaut, il définit l' separgument sur "\t"(les champs d'un
enregistrement sont délimités par des tabulations) et l' headerargument sur
TRUE(la première ligne contient les noms des champs).

Dans cet exercice, vous importerez hotdogs.txt, contenant des informations sur
les niveaux de sodium et de calories dans différents hot-dogs (Source : UCLA ).
L'ensemble de données a 3 variables, mais les noms des variables ne sont pas
disponibles dans la première ligne du fichier. Le fichier utilise des tabulations
comme séparateurs de champs.
Instructions
Importez les données "hotdogs.txt"avec read.delim(). Appelez la trame de
données résultante hotdogs. Les noms de variables ne figurent pas sur la
première ligne, alors assurez-vous de définir l' headerargument de manière
appropriée.
Appelez - summary()le hotdogs. Cela imprimera des statistiques récapitulatives
sur toutes les variables dans le bloc de données.

lire.table
Si vous travaillez avec des formats de fichiers plats plus exotiques, vous voudrez
utiliser read.table(). C'est la fonction d'importation la plus basique ; vous pouvez
spécifier des tonnes d'arguments différents dans cette fonction. A la différence
read.csv()et read.delim(), les headervaleurs par défaut d'arguments pour
FALSEet l' separgumentation est ""par défaut.

A vous encore ! Les données sont encore hotdogs.txt. Il n'a pas de noms de
colonnes dans la première ligne et les séparateurs de champs sont des
tabulations. Cette fois, cependant, le fichier se trouve dans le datadossier de
votre répertoire de travail actuel. Une variable pathavec l'emplacement de ce
fichier est déjà codée pour vous.
Instructions
Terminez l' read.table() appel qui a été préparé pour vous. Utilisez la path
variable et assurez-vous de la définir sep correctement.
Appelez - head() le hotdogs; cela imprimera les 6 premières observations dans le
bloc de données.
Génial! Pas besoin de spécifier l' headerargument : c'est FALSEpar défaut pour
read.table(), ce qui est exactement ce que vous voulez ici.

Arguments
Lily et Tom se disputent parce qu'ils veulent partager un hot-dog mais ils
n'arrivent pas à se mettre d'accord sur lequel choisir. Après un certain temps, ils
décident simplement qu'ils en auront un chacun. Lily veut avoir celui qui
contient le moins de calories tandis que Tom veut celui qui contient le plus de
sodium.

À côté de calorieset sodium, les hot-dogs ont une autre variable : type. Cela peut
être l'une des trois choses suivantes : Beef, Meat, ou Poultry, donc une variable
catégorielle : un facteur est correct.
Instructions
Terminez l' read.delim()appel pour importer les données au format
"hotdogs.txt". C'est un fichier délimité par des tabulations sans noms dans la
première ligne.
Le code qui sélectionne l'observation avec le nombre de calories le plus bas et le
stocke dans la variable lilyest déjà disponible. Il utilise la fonction which.min(),
qui renvoie l'indice de la plus petite valeur d'un vecteur.
Faites la même chose pour Tom : sélectionnez l'observation avec le plus de
sodium et stockez-la dans tom. Utilisez which.max()ce temps.
Enfin, imprimez à la fois les observations lily et tom.

Classes de colonnes
En plus des noms de colonnes, vous pouvez également spécifier les types de
colonnes ou les classes de colonnes du bloc de données résultant. Vous pouvez
le faire en définissant l' colClassesargument sur un vecteur de chaînes
représentant des classes :
read.delim("my_file.txt",
colClasses = c("character",
"numeric",
"logical"))
Cette approche peut être utile si vous avez des colonnes qui devraient être des
facteurs et d'autres qui devraient être des caractères. Vous n'avez plus à vous
soucier de cela stringsAsFactors ; indiquez simplement pour chaque colonne ce
que la classe devrait être.

Si une colonne est définie sur "NULL"dans le colClasses vecteur, cette colonne
sera ignorée et ne sera pas chargée dans le bloc de données.
Instructions
L' read.delim()appel d'avant est déjà inclus et crée le hotdogsbloc de données.
Allez-y et affichez la structure de hotdogs.
Modifiez le deuxième read.delim()appel. Attribuez le bon vecteur à l'
colClassesargument. NAdoit être remplacé par un vecteur de caractère :
c("factor", "NULL", "numeric").
Affichez la structure de hotdogs2et recherchez la différence.

Dernières pensées
1. Réflexions finales
Il y a quelque chose que je ne t'ai pas encore dit. Quand j'ai dit que read-dot-
table était les principales fonctions d'importation d'utils, j'étais sérieux.

2. Emballages
En fait, read-dot-csv et read-dot-delim, les fonctions permettant d'importer des
valeurs séparées par des virgules et des fichiers délimités par des tabulations,
sont des fonctions dites wrapper autour de read-dot-table. Ils appellent read-dot-
table dans les coulisses, mais avec des arguments par défaut différents pour
correspondre aux formats spécifiques.
3. lire.csv
Pour read-dot-csv, la valeur par défaut pour l'en-tête est TRUE et pour sep est
une virgule, vous n'avez donc plus besoin de les spécifier manuellement. Cela
signifie que cet appel read-dot-table pour importer la version CSV des états est
exactement le même que cet appel read-dot-csv. Plus court et plus facile à lire, si
vous me demandez.

4. read.delim
De même, read-dot-delim définit l'en-tête et l'argument sep, entre autres. Cet
appel pour importer la version des états délimitée par des tabulations est
exactement le même que cet appel read-dot-delim.

5. Documents
Si vous jetez un œil à la documentation de read-dot-table, vous verrez qu'il y a
deux autres fonctions dont nous n'avons pas encore parlé. read-dot-csv2 et read-
dot-delim2. Ces fonctions existent pour gérer les différences régionales dans la
représentation des nombres.

6. Différences locales
Jetez un œil à ce fichier csv, states_aye-dot-csv, typique des États-Unis et de la
Grande-Bretagne, et son homologue, states_nay-dot-csv. Vous remarquerez que
States_nay utilise des virgules pour les points décimaux, par opposition au point
pour States_aye-dot-csv. Cela signifie qu'ils ne peuvent plus utiliser la virgule
comme délimiteur de champ, ils ont besoin d'un point-virgule.

7. Différences locales
C'est pourquoi les fonctions read-dot-csv2 et read-dot-delim2 existent. Pouvez-
vous à nouveau repérer la différence dans les arguments par défaut ?

8. états_nay.csv
Essayons d'importer le fichier states_nay-dot-csv avec la fonction de base read-
dot-csv. R donne un résultat, mais ce n'est clairement pas le résultat que nous
voulons. C'est un jeu de données avec 5 observations mais une seule variable. Si
on réessaye avec read-dot-csv2, ça marche parfaitement cette fois ! Ce ne sont là
que quelques notes pour conclure ce chapitre. Vous savez maintenant comment
importer des formats de données séparés par des virgules, délimités par des
tabulations et encore plus exotiques. Mais il y a beaucoup plus à apprendre !

9. Entraînons-nous !
J'espère vous voir dans le prochain chapitre pour en savoir plus sur les puissants
packages readr et data-dot-table !

2- readr & data.table

En plus de la base R, il existe des packages dédiés pour importer facilement et
efficacement des données de fichiers plats. Nous parlerons de deux de ces
packages : readr et data.table.

1. lecteur : read_csv & read_tsv

A présent, vous savez déjà comment importer des fichiers plats en utilisant

2. Aperçu
le paquet utils. Le package utils est chargé par défaut lorsque vous démarrez R.
Bien sûr, R ne serait pas R s'il n'y avait pas de packages spécialisés pour
importer vos données. Dans ce chapitre, je vais parler de deux de ces packages :
readr et data-dot-table.

3. lecteur
Tout d'abord, plongeons-nous dans le package "readr", écrit par Hadley
Wickham ! C'est un package rapide et très facile à utiliser avec un nommage très
cohérent, tandis que utils est plus détaillé et plusieurs fois plus lent. Nous allons
commencer par installer et charger le package readr, comme ceci.
4. Fichiers CSV
Auparavant, vous utilisiez read dot csv pour importer des fichiers CSV en tant
que trame de données, comme cet appel, pour importer le fichier States dot csv.
Pour ce faire à la manière de readr, vous devrez utiliser read underscore csv.
Cela fera l'affaire : le résultat est à peu près le même. La seule différence est que
read_delim génère un tibble, qui est une version suralimentée d'une trame de
données introduite par Hadley Wickham ; vous pouvez l'utiliser comme une
trame de données normale, mais vous pouvez faire des choses supplémentaires
avec. L'impression montre commodément les classes de colonnes. En général,
tous les packages de Hadley fonctionnent avec des tibbles ; qu'ils affichent ou
non cette impression pratique dépend des packages dans lesquels vous avez
chargé. Dans les deux appels, le premier argument est le chemin d'accès au
fichier que vous souhaitez importer. Notez que dans readr, les chaînes ne sont
pas importées en tant que facteurs par défaut, un équivalent de l'argument
stringsAsFactors n'est donc pas requis. N'oubliez pas que les utilitaires
comportaient également la fonction read-dot-delim pour importer des fichiers
délimités par des tabulations.

5. Fichiers TSV
Cet appel a importé states-dot-txt. readr fournit également une fonction
similaire, mais elle s'appelle read underscore tsv, abréviation de valeur séparée
par des tabulations. C'est l'appel dont vous avez besoin. Encore une fois, pas
besoin de spécifier explicitement stringsAsFactors, ce qui est pratique.

6. Envelopper dans utils et readr

Tout comme dans utils, les fonctions read_csv et read_tsv sont des enveloppes
autour d'une "fonction d'importation mère",

7. Envelopper dans utils et readr

appelé read_delim. Ce tableau résume le fonctionnement de l'emballage pour
utils et readr, assurez-vous de ne pas mélanger les choses.

8. Entraînons-nous !
Je vous suggère déjà de vous diriger vers les exercices pour vous entraîner avant
de plonger dans d'autres possibilités de personnalisation pour read_delim. Je
vous reverrai dans la prochaine vidéo !

lire_csv
Les fichiers CSV peuvent être importés avec read_csv(). C'est une fonction
wrapper read_delim()qui gère tous les détails pour vous. Par exemple, il
supposera que la première ligne contient les noms de colonnes.

L'ensemble de données avec lequel vous allez travailler est potatoes.csv. Il

renseigne sur l'impact de la durée de stockage et de la cuisson sur la saveur des
pommes de terre. Il utilise des virgules pour délimiter les champs d'un
enregistrement et contient des noms de colonnes dans la première ligne. Le
fichier est disponible dans votre espace de travail. N'oubliez pas que vous
pouvez inspecter votre espace de travail avec dir().
Instructions
Chargez le readrpaquet avec library(). Vous n'avez pas besoin d'installer le
package, il est déjà installé sur les serveurs de DataCamp.
Importer à l' "potatoes.csv"aide de read_csv(). Affectez le bloc de données
résultant à la variable potatoes.

lire_tsv
Là où vous utilisez read_csv()pour lire facilement les fichiers CSV, vous utilisez
read_tsv()pour lire facilement les fichiers TSV. TSV est l'abréviation de valeurs
séparées par des tabulations.

Cette fois, les données des pommes de terre se présentent sous la forme d'un
fichier de valeurs séparées par des tabulations ; potatoes.txtest disponible dans
votre espace de travail. Contrairement à potatoes.csv, ce fichier ne contient
cependant pas de noms de colonnes dans la première ligne.

Il existe un vecteur propertiesque vous pouvez utiliser pour spécifier ces noms
de colonnes manuellement.
Instructions
Utilisez read_tsv()pour importer les données des pommes de terre potatoes.txtet
les stocker dans le bloc de données potatoes. En plus du chemin d'accès au
fichier, vous devrez également spécifier l' col_namesargument ; vous pouvez
utiliser le propertiesvecteur pour cela.
Appel head()à potatoesmontrer les premières observations de votre ensemble de
données.
Apprenons-en plus sur la read_delim() fonction !

lecteur : read_delim
1. lecteur : read_delim
Rappelez-vous le fichier states2.txt d'avant,

2. états2.txt
qui utilise des barres obliques comme séparateurs ? Avant, nous avons déjà écrit

3. états2.txt
cette table de points de lecture personnalisée l'appelle. Utilisons maintenant la
fonction read_delim plus bas niveau de readr pour faire la même chose : Comme
d'habitude, le premier argument est le chemin du fichier. Ensuite, l'argument
delim spécifie le caractère utilisé pour séparer les champs dans un
enregistrement ; c'est l'équivalent de l'argument sep dans read-dot-table. La
sortie correspond à la sortie de l'appel read-dot-table, mais la version readr
génère à nouveau un tibble. Comparons ici les appels utils et readr. Tout d'abord,
nous n'avons pas eu à spécifier quelque chose comme l'en-tête est VRAI, car par
défaut, read_delim s'attend à ce que la première ligne contienne les noms de
colonne. Il le fait avec l'argument col_names. De plus, les chaînes ne sont pas
importées en tant que facteurs par défaut, donc un équivalent stringsAsFactors
n'est pas nécessaire. Pour contrôler les types de colonnes, readr utilise
l'argument col_types, similaire à l'argument colClasses d'utils. Permettez-moi
d'abord de plonger dans col_names, puis de parler un peu plus de col_types.

4. col_names
col_names est TRUE par défaut. Supposons que vous ayez une autre version du
fichier states, sans noms de colonnes cette fois, states3.txt. La première ligne est
déjà un enregistrement maintenant.

5. col_names
La définition de col_names sur FALSE conduit à la génération automatique de
noms de colonnes, comme dans cet exemple. Vous pouvez également définir
manuellement col_names sur un vecteur de caractères. Les noms que vous
passez seront utilisés comme noms de colonnes, et la première ligne est lue
comme un enregistrement, comme ici :

6. types_col
Ensuite, il y a aussi col_types, pour contrôler les classes de colonnes. Si nous
importons simplement states2.txt, le fichier avec les noms d'en-tête, comme
auparavant, sans spécifier col_types, les types de colonnes seront devinés à
partir des 30 premières lignes de l'entrée. L'impression du tibble nous montre la
classe de chaque colonne, ce qui est très pratique. Les deux premières colonnes
sont des caractères, la troisième est double et la quatrième est un entier. Vous
pouvez également spécifier les classes de colonnes manuellement. Dans cet
appel, nous imposons que l'État et la ville soient un personnage et que la
population et la zone soient à la fois numériques. J'ai utilisé ici des
représentations de chaînes courtes : c pour caractère, d pour double ou
numérique, i pour entier et l pour logique. Le résultat est ce à quoi nous nous
attendions : la quatrième colonne est un double maintenant. Au lieu de c, d, i et
l, vous pouvez également utiliser un trait de soulignement pour sauter une
colonne. Une manière totalement différente de contrôler les types de colonnes
consiste à utiliser les fonctions de collecteur. Bien que plus compliqués, ils sont
plus polyvalents. Vous en saurez plus à ce sujet dans les exercices.

7. sauter et n_max
Si vous travaillez sur d'énormes fichiers plats, disons un million de lignes, vous
pourriez être intéressé par le traitement des données par morceaux de 50 points-
000 lignes par exemple. Cela permet de garder votre travail facile et vous
pouvez facilement suivre la progression de vos algorithmes. Dans readr, vous
pouvez le faire avec une combinaison des arguments skip et n_max. Jetez un œil
à la sortie de cet appel : nous avons sauté 2 lignes, puis nous avons lu trois
enregistrements. Il y a quand même un problème ! Parce que col_names est
TRUE par défaut, la première ligne lue est utilisée pour les noms de colonnes,
mais cette information a été ignorée ! Nous devrons spécifier manuellement
certains noms de colonnes cette fois, en définissant col_names sur un vecteur de
caractère. Cette fois, les deux premières lignes, donc les noms de colonnes et la
première observation sont ignorés, et les trois observations suivantes sont lues.
Parfait.

8. Entraînons-nous !
Voyons vos compétences d'importation progresser dans les exercices. Dans la
dernière vidéo de ce chapitre, nous parlerons de l'incroyable fonction fread du
package data-dot-table !

read_delim
Tout comme read.table()la utilsfonction principale , read_delim()est la
readrfonction principale .

read_delim() prend deux arguments obligatoires :

file: le fichier qui contient les données

delim: le caractère qui sépare les valeurs dans le fichier de données
Vous travaillerez à nouveau potatoes.txt; le fichier utilise des tabulations ( "\t")
pour délimiter les valeurs et ne contient pas de noms de colonnes dans sa
première ligne. Il est disponible dans votre répertoire de travail afin que vous
puissiez commencer tout de suite. Comme précédemment, le vecteur
propertiesest disponible pour définir le col_names.
Instructions
Importez toutes les données en "potatoes.txt"utilisant read_delim(); stocker la
trame de données résultante dans potatoes.
Imprimez potatoes.
Remarquez que vous auriez tout aussi bien pu utiliser read_tsv()ici. Passez à
l'exercice suivant pour en savoir plus sur les readrfonctions.
sauter et n_max
Grâce à skipet n_maxvous pouvez contrôler quelle partie de votre fichier plat
vous importez réellement dans R.

skip spécifie le nombre de lignes que vous ignorez dans le fichier plat avant de
commencer réellement à importer des données.
n_max spécifie le nombre de lignes que vous importez réellement.
Supposons, par exemple, que vous ayez un fichier CSV de 20 lignes et que vous
définissez skip = 2et n_max = 3, vous ne lisez que les lignes 3, 4 et 5 du fichier.

Attention : Une fois que vous avez skipquelques lignes, vous sautez également
la première ligne qui peut contenir des noms de colonnes !

potatoes.txt, un fichier plat avec des enregistrements délimités par des

tabulations et sans noms de colonnes, est disponible dans votre espace de travail.
Instructions
Terminez le premier read_tsv()appel pour importer les observations 7, 8, 9, 10 et
11 depuis potatoes.txt.

col_types
Vous pouvez également spécifier les types que doivent avoir les colonnes de
votre bloc de données importé. Vous pouvez le faire avec col_types. Si défini
sur NULL, la valeur par défaut, les fonctions du readrpackage essaieront de
trouver elles-mêmes les types corrects. Vous pouvez définir manuellement les
types avec une chaîne, où chaque caractère désigne la classe de la colonne :
caractère c, ddouble, ientier et logique l. _saute la colonne dans son ensemble.

potatoes.txt, un fichier plat avec des enregistrements délimités par des

tabulations et sans noms de colonnes, est à nouveau disponible dans votre
espace de travail.
Instructions
Dans le deuxième read_tsv()appel, modifiez l' col_typesargument pour importer
toutes les colonnes sous forme de caractères ( c). Stockez la trame de données
résultante dans potatoes_char.
Imprimez la structure de potatoes_charet vérifiez si tous les types de colonnes
sont chr, abréviation de character.

col_types avec les collectionneurs

Une autre façon de définir les types de colonnes importées consiste à utiliser des
collecteurs . Les fonctions de collecteur peuvent être passées dans a list()à l'
col_typesargument de read_fonctions pour leur dire comment interpréter les
valeurs d'une colonne.

Pour une liste complète des fonctions de collecteur, vous pouvez consulter la
collectordocumentation. Pour cet exercice, vous aurez besoin de deux fonctions
de collecteur :

col_integer(): la colonne doit être interprétée comme un entier.

col_factor(levels, ordered = FALSE): la colonne doit être interprétée comme un
facteur avec levels.
Dans cet exercice, vous allez travailler avec hotdogs.txt, qui est un fichier
délimité par des tabulations sans nom de colonne dans la première ligne.
Instructions
hotdogsest créé pour vous sans définir les types de colonnes. Inspectez son
résumé à l'aide de la summary()fonction.
Deux fonctions de collecteur sont définies pour vous : facet int. Regardez-les,
comprenez-vous ce qu'ils collectionnent ?
Dans le deuxième read_tsv()appel, modifiez l' col_typesargument : passez a
list()avec les éléments fac, intet int, de sorte que la première colonne est
importée en tant que facteur et les deuxième et troisième colonnes en tant
qu'entiers.
Créez un summary()de hotdogs_factor. Comparez ceci au résumé de hotdogs.
Le résumé de hotdogs_factorcontient clairement des informations plus
intéressantes pour la typecolonne, non?
data.table : effrayer
1. data.table : peur
L'autre paquet dont je voulais discuter est data-dot-table.

2. table.de.données
La mesure de performance clé pour les auteurs du tableau de données, Matt
Dowle et Arun Srinivasan, est la vitesse. Le package concerne principalement la
manipulation de données dans R, mais dispose également d'une fonction super
puissante pour lire vos données dans R : fread. Si vous avez d'énormes fichiers
que vous devez importer et grignoter dans R, vous voudrez utiliser le package
data-dot-table. Commençons par installer et charger la bibliothèque : Si vous
souhaitez tout savoir sur data-dot-table, DataCamp propose des supports de
cours dédiés à ce package. Dans ce cours, nous nous en tiendrons à la fonction
fread. Elle est assez similaire à la fonction "read-dot-table" que vous avez vue
auparavant, mais elle est plus pratique à utiliser. Permettez-moi de le présenter
avec un exemple.

3. effrayer()
Supposons que nous ayons deux versions du fichier csv d'états, une avec et une
sans noms de colonnes dans la première ligne.

4. effrayer()
Appelons fread sur ces deux fichiers csv, sans arguments supplémentaires. fread
traite automatiquement ces deux cas différents. Dans le premier cas, les noms de
colonnes sont correctement transférés dans le bloc de données, tandis que dans
le second cas, fread a lui-même composé certains noms de colonnes.

5. effrayer()
En plus de gérer automatiquement les noms, fread peut également déduire les
types de colonnes et les séparateurs de champs sans avoir à les spécifier. C'est ce
qui est cool avec fread : ça marche. En plus de ça, c'est ridiculement rapide. Bien
sûr, la fonction fread fait bien plus que découvrir automatiquement tous les
types de colonnes et conventions dans les fichiers que vous souhaitez lire. Vous
pouvez également spécifier manuellement le séparateur, les colClasses, le
nombre de lignes à sauter et le nombre de lignes à lire manuellement.
Considérez fread comme une version améliorée de read-dot-table qui est plus
rapide, plus pratique et ajoute des fonctionnalités.

6. Entraînons-nous !
Avec ces pointeurs sur data-dot-table, il est temps pour vous de vous entraîner
vous-même. Prendre plaisir!

peur
Vous vous souvenez toujours de l'utilisation de read.table(), non? Eh bien,
fread()est une fonction qui fait le même travail avec des arguments très
similaires. Il est extrêmement facile à utiliser et incroyablement rapide! Souvent,
il suffit de spécifier le chemin d'accès au fichier pour réussir à importer vos
données.

Ne nous croyez pas sur parole, essayez-le vous-même ! Vous travaillerez avec le
potatoes.csvfichier, qui est disponible dans votre espace de travail. Les champs
sont délimités par des virgules et la première ligne contient les noms de
colonnes.
Instructions
Utilisez library()pour charger (PAS installer) le data.tablepackage. Vous n'avez
pas besoin d'installer le package, il est déjà installé sur les serveurs de
DataCamp.
Importer "potatoes.csv"avec fread(). Transmettez-lui simplement le chemin du
fichier et voyez si cela a fonctionné. Stockez le résultat dans une variable
potatoes.
Imprimez potatoes.

fread : utilisation plus poussée

Maintenant que vous connaissez les bases de fread(), vous devez connaître deux
arguments de la fonction : dropet select, pour supprimer ou sélectionner les
variables d'intérêt.

Supposons que vous ayez un ensemble de données contenant 5 variables et que

vous souhaitiez conserver les première et cinquième variables, nommées "a" et
"e". Les options suivantes feront toutes l'affaire :

fread("path/to/file.txt", drop = 2:4)

fread("path/to/file.txt", select = c(1, 5))
fread("path/to/file.txt", drop = c("b", "c", "d"))
fread("path/to/file.txt", select = c("a", "e"))
Restons sur les pommes de terre car nous en sommes particulièrement friands ici
à DataCamp. Les données sont à nouveau disponibles dans le fichier
potatoes.csv, contenant des enregistrements séparés par des virgules.
Instructions
En utilisant fread()et selectou dropcomme arguments, importez uniquement les
colonnes textureet moistnessdu fichier plat. Elles correspondent aux colonnes 6
et 8 du "potatoes.csv". Stockez le résultat dans une variable potatoes.
plot()2 colonnes de la potatoestrame de données : textureen abscisse,
moistnessen ordonnée. Utilisez la notation du signe dollar deux fois. N'hésitez
pas à nommer vos axes et votre tracé.
Nous pouvons voir que l'humidité et la texture sont positivement corrélées.

Cours dédiés
Vous avez peut-être remarqué que la fread()fonction produit des trames de
données légèrement différentes lorsque vous les imprimez. C'est parce qu'une
autre classe nommée data.tableest affectée aux trames de données résultantes.
L'impression de ces data.tableobjets est différente. Est-ce que quelque chose de
similaire se produit avec les trames de données générées par readr?
Dans votre répertoire de travail actuel, nous avons préparé le potatoes.csvfichier.
Les packages data.tableet readrsont tous les deux chargés, vous pouvez donc
expérimenter immédiatement.

Laquelle des affirmations suivantes est vraie?

Instructions
Des réponses possibles
La classe du résultat de fread()est à la fois data.tableet data.frame.
read_csv()crée un objet avec trois classes : tbl_df, tblet data.frame.
Quel est l'intérêt de ces cours supplémentaires ? Eh bien, cela permet un
traitement différent des impressions, par exemple. Pour tout savoir, vous pouvez
consulter les cours DataCamp dédiés à dplyret data.table. Pour l'instant, vous
pouvez passer au chapitre suivant de ce cours !

3- Importation de données Excel

Excel est un outil d'analyse de données largement utilisé. Si vous préférez faire
vos analyses dans R, cependant, vous aurez besoin de comprendre comment
importer des données .csv dans R. Ce chapitre vous montrera comment utiliser
readxl et gdata pour le faire.

readxl (1)
1. readxl (1)
Un autre outil extrêmement courant dans l'analyse des données est

2. Microsoft Excel
Microsoft Excel. Il ne devrait pas être surprenant qu'il existe de nombreux
packages qui interagissent avec Excel afin que vous puissiez travailler avec les
données dans R. Dans ce chapitre, nous couvrirons tout ce que vous devez
savoir pour commencer avec les fichiers Excel. en R avec pratiquement aucun
travail supplémentaire. Dans cette vidéo, je parlerai du package readxl de
Hadley Wickham.
3. Structure typique des données Excel
Avant de plonger dans le côté R des choses, c'est une bonne idée de récapituler
rapidement ce qu'est généralement un fichier Excel. Pour la plupart des tâches
liées aux données, un fichier Excel contient différentes feuilles contenant des
données tabulaires. Prenons par exemple ce fichier excel, cities-dot-xlsx, qui
contient deux feuilles contenant des données sur la population totale de certaines
capitales pour deux années différentes. Lorsque vous travaillez dans R, vous
souhaiterez généralement d'abord explorer votre fichier Excel, puis importer des
données à partir de celui-ci. Mais comment t'y prends-tu ?

4. readxl
C'est là qu'intervient le package readxl. Il contient essentiellement deux
fonctions principales : excel_sheets et read_excel. Le premier est utilisé pour
répertorier les différentes feuilles de votre fichier excel, tandis que le second est
utilisé pour importer réellement une feuille dans votre session R. readxl est
capable de gérer les deux dot-xls en tant que fichiers dot-xlsx. Alors, essayons-le
! Commençons par installer et charger le package readxl, puis

5. feuilles_excel()
commencez par la fonction excel_sheets. Vous lui transmettez simplement le
chemin du fichier, qui est l'emplacement du fichier dot-xls sur votre propre
système. Le fichier est déjà dans notre répertoire de travail, comme le révèle dir,
nous pouvons donc simplement utiliser l'appel suivant. Le résultat est un simple
vecteur de caractères, qui contient les noms des différentes feuilles. En effet,
vous avez vu précédemment que les deux feuilles du fichier excel se nomment
année_1990 et année_2000. Génial. Nous connaissons déjà les noms des feuilles
maintenant, mais ce ne sont que les noms, pas les données de population réelles.

6. read_excel()
Heureusement, readxl propose également la fonction read_excel pour importer
réellement les données de la feuille dans votre session R. Dans son utilisation la
plus basique, vous spécifiez simplement à nouveau le chemin d'accès au fichier
Excel. Par défaut, la première feuille, year_1990 dans ce cas, est importée sous
forme de tibble. Vous pouvez également indiquer explicitement à read_excel
quelle feuille importer, en définissant l'argument de la feuille. Vous pouvez
utiliser à la fois un index ou le nom de la feuille. Supposons que vous vouliez
charger dans la deuxième feuille, nommée year_2000. Les deux appels suivants
le font tous les deux. Dans tous ces appels read_excel, il en résulte une trame de
données R qui contient les données Excel. Vous pouvez commencer vos
analyses tout de suite !

7. Entraînons-nous !
Essayez-le pour la première fois dans les exercices. Dans la prochaine vidéo, je
vais plonger un peu plus dans la fonction read_excel !

Lister les feuilles d'un fichier Excel

Avant de pouvoir commencer à importer à partir d'Excel, vous devez savoir
quelles feuilles sont disponibles dans le classeur. Vous pouvez utiliser la
excel_sheets()fonction pour cela.

Vous trouverez le fichier Excel urbanpop.xlsxdans votre répertoire de travail

(tapez dir()pour le voir). Cet ensemble de données contient des métriques de
population urbaine pour pratiquement tous les pays du monde à travers le temps
(Source : Gapminder ). Il contient trois feuilles pour trois périodes différentes.
Dans chaque feuille, la première ligne contient les noms des colonnes.
Instructions
Chargez le readxlpackage à l'aide de library(). Il est déjà installé sur les serveurs
de DataCamp.
Utilisez excel_sheets()pour imprimer les noms des feuilles au format
urbanpop.xlsx.
Comme vous pouvez le voir, le résultat de excel_sheets()est simplement un
vecteur de caractère ; vous n'avez encore rien importé. C'est quelque chose pour
la read_excel()fonction. Apprenez tout à ce sujet dans le prochain exercice!

Importer une feuille Excel

Maintenant que vous connaissez les noms des feuilles dans le fichier Excel que
vous souhaitez importer, il est temps d'importer ces feuilles dans R. Vous
pouvez le faire avec la read_excel()fonction. Jetez un œil à cette recette :
data <- read_excel("data.xlsx", sheet = "my_sheet")
Cet appel importe simplement la feuille avec le nom "my_sheet"du
"data.xlsx"fichier. Vous pouvez également passer un nombre à l'
sheetargument ; cela entraînera l' read_excel()importation de la feuille avec le
numéro de feuille donné. sheet = 1importera la première feuille, sheet =
2importera la deuxième feuille, et ainsi de suite.

Dans cet exercice, vous continuerez à travailler avec le urbanpop.xlsxfichier.

Instructions
Le code pour importer les première et deuxième feuilles est déjà inclus. Pouvez-
vous ajouter une commande pour importer également la troisième feuille et
stocker le bloc de données résultant dans pop_3?
Stockez les trames de données pop_1, pop_2et pop_3dans une liste, que vous
appelez pop_list.
Afficher la structure de pop_list.
vous avez urbanpop.xlsxcorrectement importé les feuilles . A partir de là, vous
pouvez lire et opérer sur le fichier importé. Dans l'exercice suivant, vous
apprendrez à utiliser à la fois excel_sheets()la read_excel()fonction et en
combinaison avec lapply()pour lire plusieurs feuilles à la fois.

Lire un classeur
Dans l'exercice précédent, vous avez généré une liste de trois feuilles Excel que
vous avez importées. Cependant, charger manuellement chaque feuille puis les
fusionner dans une liste peut être assez fastidieux. Heureusement, vous pouvez
automatiser cela avec lapply(). Si vous n'avez aucune expérience en la matière
lapply(), n'hésitez pas à suivre le chapitre 4 du cours Intermédiaire R .

Jetez un œil à l'exemple de code ci-dessous :

my_workbook <- lapply(excel_sheets("data.xlsx"),

read_excel,
 path = "data.xlsx")
La read_excel()fonction est appelée plusieurs fois sur le "data.xlsx"fichier et
chaque feuille est chargée l'une après l'autre. Le résultat est une liste de blocs de
données, chaque bloc de données représentant l'une des feuilles de data.xlsx.

Vous travaillez toujours avec le urbanpop.xlsxfichier.

Instructions
À utiliser lapply()en combinaison avec excel_sheets()et read_excel()pour lire
toutes les feuilles Excel au format "urbanpop.xlsx". Nommez la liste résultante
pop_list.
Imprimer la structure de pop_list.
Si vous êtes intelligent, la lecture de plusieurs feuilles Excel ne nécessite pas
beaucoup de codage du tout !

readxl (2)
1. readxl (2)
À côté des arguments de chemin et de feuille dont nous avons parlé dans la
vidéo précédente,

2. read_excel()
il y a aussi d'autres arguments que vous pouvez spécifier. Jetez un œil à
l'utilisation de la fonction read_excel telle qu'elle apparaît dans la documentation
; pouvez-vous dire le sens de ces arguments? chemin et feuilles n'ont plus de
secrets pour vous.

3. read_excel() - col_names
Ensuite, il y a col_names, qui peut être trois choses : TRUE, la valeur par défaut,
ce qui signifie que la première ligne de la feuille Excel contient les noms de
colonnes. Il peut également être FAUX, auquel cas R propose ses propres noms.
Enfin, vous pouvez également lui définir un vecteur de caractères spécifiant les
noms de colonnes. Excel peut contenir différents types de données, tels que du
texte, des chiffres et des dates. La façon dont cela se convertit en classes R est
contrôlée dans l'argument col_types :

4. read_excel() - col_types
Par défaut, c'est NULL, ce qui permet à R de deviner les types de données des
différentes colonnes. Mais vous pouvez également spécifier manuellement les
col_types. Supposons que vous souhaitiez importer toutes les colonnes de la
première feuille sous forme de texte. Cette commande fera l'affaire : les classes
de colonnes que nous pouvons voir dans l'impression révèlent qu'en effet, la
variable pop_data contient deux colonnes dont deux sont maintenant des
caractères, parfait. D'autres mots-clés pour appliquer un type sont "numérique",
"date" et "vide". « numérique » et « date » sont simples, mais qu'en est-il «
vierge » ?

5. read_excel() - col_types
Eh bien, si vous utilisez un espace vide, vous ignorez simplement cette colonne.
Si nous adaptons l'appel précédent comme ceci : Vous verrez que la colonne
population est manquante. Ce mot-clé "vide" peut s'avérer utile lorsque vous
avez un fichier Excel avec beaucoup de colonnes et que vous n'avez besoin que
de certaines d'entre elles dans R.

6. read_excel() - ignorer
Ensuite, il y a l'argument skip. Il spécifie le nombre de lignes de votre feuille
Excel que R doit ignorer avant d'importer réellement les données. Disons que les
deux premières lignes de la première feuille de cities-dot-xlsx ne sont pas
nécessaires pour notre analyse. Pour les ignorer, nous pouvons simplement
définir l'argument skip sur 2 et read_excel n'importera pas ces lignes. nous
devrons également définir l'argument col_names, car la première ligne avec les
noms de colonnes est également ignorée. si nous essayons ce code, en effet 2
lignes ont été sautées : la ligne contenant les noms des colonnes et les premières
observations. Cela nous laisse avec les trois dernières observations. Dans readr,
il y avait aussi l'argument n_max, pour spécifier le nombre d'enregistrements à
lire. Actuellement, cette fonctionnalité n'est pas disponible dans readxl, mais
cela pourrait être ajouté à l'avenir.
7. Conclusion
En fait, excel_sheets et read_excel sont les seules fonctions disponibles dans le
package readxl. Ces deux fonctions et les possibilités de personnalisation sont
tout ce dont vous avez besoin pour commencer avec vos données Excel dans R.
En plus de tout cela, readxl est extrêmement rapide. Vous avez peut-être
reconnu de nombreux arguments du package readr du chapitre précédent.
Hadley Wickham a rendu la lecture des données de différentes sources de
données assez cohérente. Cela ne peut que faciliter votre travail d'importation de
données, n'est-ce pas ?

8. Entraînons-nous !
Entraînez-vous un peu plus dans les exercices !

L'argument col_names
Outre pathet sheet, il existe plusieurs autres arguments que vous pouvez
spécifier dans read_excel(). L'un de ces arguments s'appelle col_names.

Par défaut, il s'agit de TRUE, indiquant si la première ligne des feuilles Excel
contient les noms de colonnes. Si ce n'est pas le cas, vous pouvez définir
col_namessur FALSE. Dans ce cas, R choisira les noms de colonnes pour vous.
Vous pouvez également choisir de définir col_namesun vecteur de caractères
avec des noms pour chaque colonne. Cela fonctionne exactement de la même
manière que dans le readrpaquet.

Vous travaillerez avec le urbanpop_nonames.xlsxfichier. Il contient les mêmes

données que urbanpop.xlsxmais n'a pas de nom de colonne dans la première
ligne des feuilles Excel.
Instructions
Importez la première feuille Excel de "urbanpop_nonames.xlsx"et stockez le
résultat dans pop_a. Demandez à R de définir les noms de colonne du bloc de
données résultant lui-même.
Importez la première feuille Excel de urbanpop_nonames.xlsx; cette fois,
utilisez le colsvecteur qui a déjà été préparé pour vous pour spécifier les noms
de colonnes. Stockez la trame de données résultante dans pop_b.
Imprimez le résumé de pop_a.
Imprimez le résumé de pop_b. Pouvez-vous repérer la différence avec l'autre
résumé?
Avez-vous remarqué la différence entre les résumés? Il est vraiment crucial de
dire correctement à R si vos données Excel contiennent des noms de colonnes.
Si vous ne le faites pas, la tête de la trame de données avec laquelle vous vous
retrouverez contiendra des informations incorrectes…

L'argument de saut
Un autre argument qui peut être très utile lors de la lecture dans des fichiers
Excel moins ordonnés est skip. Avec skip, vous pouvez dire à R d'ignorer un
nombre spécifié de lignes dans les feuilles Excel dont vous essayez d'extraire
des données. Regardez cet exemple :

read_excel("data.xlsx", skip = 15)

Dans ce cas, les 15 premières lignes de la première feuille de "data.xlsx"sont
ignorées.

Si la première ligne de cette feuille contenait les noms de colonnes, cette

information sera également ignorée par readxl. Assurez - vous de définir
col_namesà FALSE ou spécifier manuellement les noms de colonnes dans ce
cas!

Le fichier urbanpop.xlsx est disponible dans votre répertoire ; il a des noms de

colonnes dans les premières lignes.
Instructions
Importez la deuxième feuille de "urbanpop.xlsx", mais ignorez les 21 premières
lignes. Assurez-vous de définir col_names = FALSE. Stockez la trame de
données résultante dans une variable urbanpop_sel.
Sélectionnez la première observation urbanpop_selet imprimez-la.
C'est à peu près aussi compliqué que l' read_excel()appel peut l'être ! Il est
temps de découvrir un autre package pour importer des données depuis Excel :
gdata.

gdata
1. gdata
Avant, j'ai présenté le package readxl, qui est un package très efficace pour
importer des données d'Excel vers R. Mais il existe bien sûr des alternatives à
readxl. Dans cette vidéo, je vais discuter de l'une de ces alternatives :

2. gdata
le paquet gdata, actuellement maintenu par Gregory Warnes. En fait, le package
gdata est une suite complète d'outils permettant d'effectuer des manipulations de
données dans toutes sortes de domaines. Cela suralimente en quelque sorte votre
distribution R de base pour rendre la gestion de vos données moins pénible.
Parmi ces outils, il existe également une fonction qui permet d'importer des
données Excel : read dot xls. Prêt à l'emploi, gdata ne peut gérer que le format
xls, mais vous pouvez également installer facilement un pilote pour prendre en
charge le nouveau format xlsx. Il n'y a pas de fonction pour lister les différentes
feuilles dans un fichier excel, comme excel_sheets dans readxl.

3. gdata
Pour importer des données depuis Excel, gdata utilise Perl, un autre langage de
programmation interprété. Le code Perl convertit les données de la feuille Excel
en un fichier csv.

4. gdata
Ensuite, ce fichier csv est lu dans R à l'aide de la fonction read-dot-csv par
défaut du package utils.

5. gdata
read-dot-csv lui-même est un wrapper autour de read-dot-table, vous vous
souvenez ?

6. gdata
Cette fonction peut être personnalisée de millions de façons ; vous pouvez
spécifier plus de 15 arguments. Tous ces arguments read-dot-table sont
également disponibles pour la fonction gdata read-dot-xls. À cet égard, la
fonction read-dot-xls est une extension des fonctions de saisie de données du
package utils aux fichiers Excel. Cela le rend facile à utiliser pour les personnes
familiarisées avec les fonctions d'importation du package utils et leurs
arguments. D'un autre côté, convertir d'abord un fichier xls entier en un fichier
csv, puis l'importer dans R avec la fonction csv de point de lecture lente est
extrêmement inefficace. Et si vous avez affaire à d'énormes fichiers Excel ?
Vous devrez convertir le fichier en entier, puis le lire. C'est tout un travail
supplémentaire que vous faites. Le package readxl de Wickham est bien plus
rapide ici. Alors pourquoi utiliser gdata en premier lieu ? Bien, nous pensons
que readxl deviendra le package standard pour importer des données Excel.
Cependant, au moment où nous parlons, le package readxl est toujours en cours
de développement : la version avec laquelle nous travaillons est antérieure à la
V1. Si vous ne voulez pas vous fier à des packages qui sont encore en cours de
développement et dont la syntaxe peut encore changer, vous pouvez vous en
tenir à des packages plus établis comme gdata. Maintenant, passons à la
pratique. Vous vous souvenez encore du fichier city dot xlsx ?

7. villes.xls
Le voici sous forme de fichier xls cette fois, les villes pointent xls. Deux fiches,
contenant la population de certaines capitales en 1990 et 2000.

8. read.xls()
Commençons par installer et charger gdata, puis essayons la fonction read-dot-
xls de gdata pour importer les données Excel. Comme précédemment, le premier
argument que vous lui passez est le chemin d'accès au fichier ; dans notre cas,
cities-dot-xls est toujours dans le répertoire de travail. Si votre fichier Excel
contient plusieurs feuilles, seule la première feuille est importée. Vous pouvez à
nouveau choisir de spécifier une feuille différente par numéro de feuille ou par
nom de feuille, comme dans cet exemple.
9. Entraînons-nous !
En gros, c'est tout ce qu'il y a à faire. Dirigez-vous vers les exercices pour vous
familiariser avec le package gdata.

Importer un fichier local

Dans cette partie du chapitre, vous apprendrez comment importer
des .xlsfichiers à l'aide du gdatapackage. Semblable au readxlpackage, vous
pouvez importer des feuilles Excel individuelles à partir de feuilles Excel pour
démarrer votre analyse dans R.

Vous travaillerez avec l' urbanpop.xlsensemble de données, la .xlsversion du

fichier Excel avec laquelle vous avez déjà travaillé. Il est disponible dans votre
répertoire de travail actuel.
Instructions
Chargez le gdatapaquet avec library(). gdataet Perl sont déjà installés sur les
serveurs de DataCamp.
Importez la deuxième feuille, nommée "1967-1974", de "urbanpop.xls"avec
read.xls(). Stockez la trame de données résultante en tant que urban_pop.
Imprimez les 11 premières observations de urban_popavec head().
Il semble y avoir beaucoup de données manquantes, mais read.xls()sait comment
les gérer. Dans l'exercice suivant, vous apprendrez quels arguments vous pouvez
utiliser dans read.xls().

read.xls() s'enroule autour de read.table()

Rappelez-vous comment read.xls()fonctionne réellement? Cela se résume
essentiellement à deux étapes : convertir le fichier Excel en un .csvfichier à
l'aide d'un script Perl, puis lire ce .csvfichier avec la read.csv()fonction chargée
par défaut dans R, via le utilspackage.

Cela signifie que toutes les options que vous pouvez spécifier dans read.csv(),
peuvent également être spécifiées dans read.xls().
L' urbanpop.xlsensemble de données est déjà disponible dans votre espace de
travail. Il est toujours composé de trois feuilles et comporte des noms de colonne
dans la première ligne de chaque feuille.
Instructions
Terminer l' read.xls() appel qui lit les données de la deuxième feuille de
urbanpop.xls: ignorer les 50 premières lignes de la feuille. Assurez-vous de
définir headercorrectement et que les noms de pays ne sont pas importés en tant
que facteurs.
Imprimez les 10 premières observations de urban_pop avec head().

Travaillez ces données Excel !

Maintenant que vous pouvez lire les données Excel, essayons de les nettoyer et
de les fusionner. Vous avez déjà utilisé la cbind()fonction il y a quelques
exercices. Allons plus loin maintenant.

L' urbanpop.xlsensemble de données est disponible dans votre répertoire de

travail. Le fichier contient toujours trois feuilles et comporte des noms de
colonne dans la première ligne de chaque feuille.
Instructions
Ajoutez du code pour lire les données de la troisième feuille au format
"urbanpop.xls". Vous voulez vous retrouver avec trois trames de données :
urban_sheet1, urban_sheet2 et urban_sheet3.
Prolongez l' cbind() appel pour qu'il comprenne également urban_sheet3.
Assurez-vous que la première colonne de urban_sheet2 et urban_sheet3 est
supprimée afin de ne pas avoir de colonnes en double. Stockez le résultat dans
urban.
Utilisez na.omit()sur le urbanbloc de données pour supprimer toutes les lignes
qui contiennent des NAvaleurs. Stockez la trame de données nettoyée en tant
que urban_clean.
Imprimez un résumé urban_clean et affirmez qu'il n'y a plus de NA valeurs.
 4- Travail Excel reproductible avec XLConnect
Au-delà de l'importation de données depuis Excel, vous pouvez aller encore plus
loin avec XLConnect. Apprenez tout à ce sujet et comblez le fossé entre R et
Excel.

Feuilles de lecture

1. Feuilles de lecture
Vous connaissez déjà deux packages très utiles pour travailler avec des données
Excel - le package readxl et le package gdata. Imaginez maintenant cette
situation.

2. Insérez le titre ici...

Vous travaillez dans une grande entreprise qui utilise Excel pour tous ses
travaux d'analyse. Vous êtes obligé de travailler et de livrer ces fichiers Excel,
mais vous souhaitez travailler sur les données via R, afin de pouvoir modifier les
fichiers de manière reproductible ? Je suis heureux de vous dire qu'il existe un
package qui fait exactement cela :

3. XLConnect
XLConnect, écrit et maintenu par Martin Studer. Il a créé l'un des packages les
plus complets pour travailler avec des fichiers Excel via R. Vous pouvez
considérer XLConnect comme un pont entre Excel et R. Cela signifie que vous
pouvez effectuer pratiquement toutes les actions que vous pouvez effectuer dans
Excel, mais vous le faites depuis R. Éditer des feuilles Excel, formater des
données et adapter des feuilles de calcul entières, vous l'appelez. XLConnect a
une fonction pour cela. XLConnect fonctionne avec les fichiers xls et xlsx et
possède des fonctions faciles à utiliser. Pour que tout cela fonctionne si bien,
XLConnect dépend de Java. Ceci est totalement abstrait pour nous, utilisateurs
finaux, mais l'installation du package peut avoir ses difficultés.

4. Installation
If you're starting from a reasonably clean computing environment, this
traditional install-dot-packages command will work fine. From the messaging,
you'll see that it also installs the XLConnectJars package containing Java files
and class definitions that XLConnect depends on. If it wasn't installed already,
the rJava package will also be installed, providing a low-level R to Java
interface that XLConnect uses. If something goes wrong during installation, it's
possible that you first have to install the Java Development Kit, or JDK, from
Oracle's web site. If things still don't work out, I suggest you google the errors
you're getting: there's quite some people using this package so help is never far
away. With our package installed and not to forget, loaded,

5. loadWorkbook()
let's take the first step: loading a workbook into R. You do this with the
loadWorkbook function, by simply passing the name of the excel file you want
to interface to. Assuming that our cities-dot-xlsx file is still in the current
working directory, this call works. If you have a look at the structure of book,
we see that it is a so-called workbook object. This object is the actual "bridge"
between R and Excel I talked about earlier. After building a workbook object in
R, you can use it to get information on the Excel file it links to. To get the names
of the different sheets,

6. getSheets()
for example, you can use getSheets. The result is exactly the same to the
excel_sheets function from readxl: a character vector containing the two sheet
names. Apart from sheet information,

7. readWorksheet()
you can also read the actual data from the sheets, like readxl's read_excel
function and gdata's read dot xls function. Suppose we want to import the data
from the year_2000 sheet as a data frame. As the first argument to
readWorksheet, we pass the workbook object, book in our case. The second
argument, sheet, is the name or index of the sheet you want to import from.
Works just like before. The cool thing here is, that you can easily specify from
which row and which column to start reading information.
8. readWorksheet()
Say you only want the population information for Berlin and Madrid. You can
simply set startRow to 3, endRow to 4 and startCol to 2. Because you skipped
the first row, the column names are also skipped, so you should set header to
FALSE.

9. Let's practice!
Avant de passer à l'étape suivante, entraînons-nous un peu avec quelques
exercices.

Se connecter à un classeur
Lorsque vous travaillez avec XLConnect, la première étape consistera à charger
un classeur dans votre session R avec loadWorkbook(); cette fonction va
construire un "pont" entre votre fichier Excel et votre session R.

Dans cet exercice et les suivants, vous continuerez à travailler avec

urbanpop.xlsx, contenant des données sur la population urbaine au fil du temps.
Le fichier Excel est disponible dans votre répertoire de travail actuel

Instructions
Chargez le XLConnect package en utilisant library(); il est déjà installé sur les
serveurs de DataCamp.
Utilisez loadWorkbook() pour établir une connexion au "urbanpop.xlsx" fichier
dans R. Appelez le classeur my_book.
Imprimez la classe de my_book. Qu'est-ce que cela vous dit?

Lister et lire des feuilles Excel

Tout comme readxlet gdata, vous pouvez utiliser XLConnectpour importer des
données d'un fichier Excel dans R.
Pour répertorier les feuilles dans un fichier Excel, utilisez getSheets(). Pour
importer réellement des données à partir d'une feuille, vous pouvez utiliser
readWorksheet(). Les deux fonctions nécessitent un objet classeur XLConnect
comme premier argument.

Vous travaillerez à nouveau avec urbanpop.xlsx. L' my_bookobjet lié à ce

fichier Excel a déjà été créé.

Instructions
Imprimez les feuilles du fichier Excel qui my_bookrenvoie vers.
Importez la deuxième feuille en my_booktant que bloc de données. Imprimez le.

Personnaliser readWorksheet
Pour obtenir une vue d'ensemble claire urbanpop.xlsx sans avoir à ouvrir le
fichier Excel, vous pouvez exécuter le code suivant :

my_book <- loadWorkbook("urbanpop.xlsx")

sheets <- getSheets(my_book)
all <- lapply(sheets, readWorksheet, object = my_book)
str(all)
Supposons que nous nous intéressons uniquement aux données de population
urbaine des années 1968, 1969 et 1970. Les données pour ces années se trouvent
dans les colonnes 3, 4 et 5 de la deuxième feuille. Seule la sélection de ces
colonnes nous laissera dans l'ignorance des pays auxquels les chiffres
appartiennent.

Instructions
Étendez la readWorksheet()commande avec les arguments startColet endCol
pour n'importer que les colonnes 3, 4 et 5 de la deuxième feuille.
urbanpop_sel ne contient plus d'informations sur les pays maintenant. Pouvez-
vous écrire une autre readWorksheet() commande qui importe uniquement la
première colonne de la deuxième feuille ? Stockez la trame de données
résultante en tant que countries.
Utilisez cbind() pour coller ensemble countries et urbanpop_sel, dans cet ordre.
Stockez le résultat en tant que selection.

Fiches d'adaptation
1. Fiches d'adaptation
Jusqu'à présent, XLConnect ne vous épate pas, n'est-ce pas ? Le simple fait de
lister des feuilles et d'en importer des données dans R n'a rien de nouveau. Mais
XLConnect a plus à offrir que la simple importation de données Excel dans R.
Ce package est un outil simple pour modifier confortablement le contenu de
votre classeur via R.

2. Nouvelles données !
Supposons que vous ayez réussi à mettre la main sur de nouvelles données
démographiques de 2010, qui sont stockées dans un bloc de données, pop_2010.

3. créerFeuille()
Pour stocker ces informations dans une nouvelle feuille, nous commençons par
charger XLConnect et établir une connexion au classeur. Après cela, nous
pouvons utiliser createSheet et transmettre le classeur et le nom de la nouvelle
feuille, comme ceci.

4. créerFeuille()
Nous pouvons maintenant remplir notre nouvelle feuille avec les données, pour
lesquelles nous utiliserons

5. écrireFeuille de travail()
écrireFeuille de travail. Le premier argument, comme toujours, est le classeur,
suivi des données que nous voulons ajouter, donc pop_2010 et enfin la feuille à
laquelle nous voulons l'ajouter. Utilisons le nom de la feuille qui a été spécifié
dans createSheet, mais le numéro de la feuille, 3, fonctionnerait également bien.
Si vous ouvrez le fichier Excel, cependant, vous ne verrez pas la nouvelle
feuille. Vous devrez explicitement enregistrer l'intégralité du classeur dans un
fichier pour que les modifications prennent effet.

6. enregistrerClasseur()
Vous faites cela avec saveWorkbook, comme ceci.

7. enregistrerClasseur()
Je vous suggère de spécifier un nouveau nom de fichier, cities2.xlsx par
exemple, afin de ne pas écraser le fichier avec lequel vous avez commencé. Si
vous extrayez maintenant le nouveau fichier Excel, vous voyez que les données
supplémentaires s'y trouvent. Impressionnant! Supposons qu'après avoir créé
cette feuille de calcul supplémentaire, vous ne vous sentez pas à l'aise avec le
nom que vous avez choisi. En fait, vous voulez renommer toutes les feuilles.
Part de gâteau:

8. renommerFeuille()
utilisez simplement la fonction renameSheet. Comme uaual, le premier
argument est le classeur, puis vous passez l'ancien nom et le nouveau nom. Nous
utiliserons cette commande trois fois, l'année de changement avec y pour les
trois feuilles différentes.

9. renommerFeuille()
Enfin, nous enregistrons à nouveau le résultat dans un nouveau fichier avec
saveWorksheet : cities3.xlsx. Un rapide coup d'œil au nouveau fichier Excel
révèle que nous avons renommé les feuilles avec succès. Parfait.

10. removeSheet()
Un autre travail Excel serait de supprimer complètement une feuille. Pour
supprimer la troisième feuille ici, par exemple, utilisez simplement removeSheet
avec le classeur et le nom de la feuille ou le numéro de la feuille comme
arguments.
11. removeSheet()
Si vous enregistrez à nouveau le classeur dans un fichier et ouvrez le fichier,
notre troisième feuille a disparu.

12. Conclusion
Bien sûr, ce sont des opérations assez basiques, que vous pouvez facilement
faire dans Excel également, mais ce qui est cool, c'est que vous pouvez
programmer toutes ces tâches dans R de manière reproductible. Si vous mettez à
jour les commandes que nous avons utilisées ici et que vous les réexécutez
toutes, l'une après l'autre, tout devrait toujours fonctionner correctement. Outre
les fonctions dont j'ai parlé ici, il existe également des méthodes pour styliser les
cellules, obtenir, définir et recalculer des formules, fusionner et diviser des
cellules, tout le reste. Mais ne plongeons pas dans ceux-ci et commençons petit.

13. Entraînons-nous !
Dirigez-vous vers les exercices et essayez-le vous-même!

Ajouter une feuille de calcul

Là où readxl et gdata ne pouvaient importer que des données Excel, XLConnect
l'approche de fournir une interface réelle à un fichier Excel permet de modifier
vos fichiers Excel à partir de R. Dans cet exercice, vous allez créer une nouvelle
feuille. Dans l'exercice suivant, vous allez remplir la feuille avec des données et
enregistrer les résultats dans un nouveau fichier Excel.

Vous continuerez à travailler avec urbanpop.xlsx. L' my_book objet lié à ce

fichier Excel est déjà disponible.
Instructions
Utilisez createSheet(), pour créer une nouvelle feuille dans my_book, nommée
"data_summary".
Utilisez getSheets() pour vérifier que my_book représente maintenant un fichier
Excel avec quatre feuilles.
Remplir la feuille de calcul
La première étape de création d'une feuille est terminée ; remplissons-le
maintenant avec des données ! summ, un bloc de données avec quelques
statistiques récapitulatives sur les deux feuilles Excel est déjà codé afin que vous
puissiez le prendre à partir de là.

Instructions
Utilisez writeWorksheet() pour remplir la "data_summary" feuille avec le bloc
de summ données.
Appel saveWorkbook() pour stocker le classeur Excel adapté en tant que
nouveau fichier, "summary.xlsx".

Renommer des feuilles

À bien y penser, ce "data_summary" n'est pas un nom idéal. Comme le résumé
de ces feuilles Excel est toujours lié aux données, il vous suffit de nommer la
feuille "summary".

Le code pour établir une connexion "urbanpop.xlsx" et créer vous my_book est
déjà fourni. Il s'agit d'un fichier Excel avec 4 feuilles : les trois fiches
techniques, et la "data_summary" feuille.
Instructions
Utilisez renameSheet() pour renommer la quatrième feuille en "summary".
Ensuite, appelez getSheets() sur my_book pour imprimer les noms de feuille.
Enfin, assurez-vous de bien enregistrer l' my_book objet dans un nouveau fichier
Excel, "renamed.xlsx".