R Language
Lecture et écriture de chaînes

Remarques

Impression et affichage de chaînes

R possède plusieurs fonctions intégrées qui peuvent être utilisées pour imprimer ou afficher des informations, mais les fonctions d' print et de cat sont les plus élémentaires. Comme R est un langage interprété , vous pouvez les essayer directement dans la console R:

print("Hello World")
#[1] "Hello World"
cat("Hello World\n")
#Hello World

Notez la différence dans les deux entrées et sorties pour les deux fonctions. (Remarque: il n'y a pas de guillemets dans la valeur de x créée avec x <- "Hello World" . Ils sont ajoutés par print au niveau de la sortie.)

cat prend un ou plusieurs vecteurs de caractères comme arguments et les imprime sur la console. Si le vecteur de caractères a une longueur supérieure à 1, les arguments sont séparés par un espace (par défaut):

cat(c("hello", "world", "\n"))
#hello world

Sans le caractère de nouvelle ligne ( \n ), la sortie serait:

cat("Hello World")
#Hello World> 

L'invite pour la commande suivante apparaît immédiatement après la sortie. (Certaines consoles telles que RStudio peuvent automatiquement ajouter une nouvelle ligne à des chaînes qui ne se terminent pas par une nouvelle ligne.)

print est un exemple de fonction "générique", ce qui signifie que la classe du premier argument passé est détectée et qu'une méthode spécifique à une classe est utilisée pour générer une sortie. Pour un vecteur de caractères comme "Hello World" , le résultat est similaire à la sortie de cat . Cependant, la chaîne de caractères est citée et un nombre [1] est généré pour indiquer le premier élément d'un vecteur de caractères (dans ce cas, le premier et le seul élément):

print("Hello World")
#[1] "Hello World"

Cette méthode d'impression par défaut est également ce que nous voyons lorsque nous demandons simplement à R d'imprimer une variable. Notez comment la sortie de taper s est la même chose que d' appeler print(s) ou print("Hello World") tout le print("Hello World") :

s <- "Hello World"
s
#[1] "Hello World"

Ou même sans l'assigner à quoi que ce soit:

"Hello World"
#[1] "Hello World"

Si l' on ajoute une autre chaîne de caractères en tant que second élément du vecteur ( en utilisant le c() fonction c oncatenate les éléments ensemble), le comportement d' print() ressemble un peu différent de celui du cat :

print(c("Hello World", "Here I am."))
#[1] "Hello World" "Here I am."

Observez que la fonction c() ne fait pas de concaténation de chaîne. (On doit utiliser paste pour cela.) R montre que le vecteur de caractères a deux éléments en les citant séparément. Si nous avons un vecteur suffisamment long pour couvrir plusieurs lignes, R imprimera l'index de l'élément en commençant par chaque ligne, comme il imprime [1] au début de la première ligne.

c("Hello World", "Here I am!", "This next string is really long.")
#[1] "Hello World"                      "Here I am!"                      
#[3] "This next string is really long."

Le comportement particulier de print dépend de la classe de l'objet transmise à la fonction.

Si nous appelons print un objet avec une classe différente, telle que "numeric" ou "logical", les guillemets sont omis de la sortie pour indiquer que nous avons affaire à un objet qui n'est pas une classe de caractères:

print(1)
#[1] 1
print(TRUE)
#[1] TRUE

Les objets factoriels sont imprimés de la même manière que les variables de caractère, ce qui crée souvent une ambiguïté lorsque la sortie de la console est utilisée pour afficher des objets dans des corps de questions SO. Il est rare d'utiliser cat ou print sauf dans un contexte interactif. L'appel explicite de print() est particulièrement rare (sauf si vous souhaitez supprimer l'apparence des guillemets ou afficher un objet renvoyé comme invisible par une fonction), car entrer foo sur la console est un raccourci pour print(foo) . La console interactive de R est appelée REPL, une "read-eval-print-loop". La fonction cat est mieux enregistrée à des fins spéciales (comme écrire une sortie sur une connexion de fichier ouverte). Parfois, il est utilisé à l'intérieur de fonctions (où les appels à print() sont supprimés), mais l' utilisation de cat() dans une fonction pour générer une sortie sur la console est une mauvaise pratique . La méthode privilégiée est celle de message() ou d’ warning() pour les messages intermédiaires; ils se comportent de la même manière que cat mais peuvent éventuellement être supprimés par l'utilisateur final. Le résultat final doit simplement être retourné pour que l'utilisateur puisse l'assigner si nécessaire.

message("hello world")
#hello world
suppressMessages(message("hello world"))

Lecture ou écriture sur une connexion de fichier

Nous n’avons pas toujours la possibilité de lire ou d’écrire sur un chemin système local. Par exemple, si le mappage en continu de code R doit obligatoirement lire et écrire sur une connexion de fichier. Il peut aussi y avoir d'autres scénarios où l'un va au-delà du système local et avec l'avènement du cloud et du big data, cela devient de plus en plus courant. L'un des moyens d'y parvenir est la séquence logique.

Établissez une connexion de fichier à lire avec la commande file() ("r" correspond au mode lecture):

conn <- file("/path/example.data", "r") #when file is in local system
conn1 <- file("stdin", "r") #when just standard input/output for files are available

Comme cela établira une connexion de fichier, on peut lire les données de ces connexions de fichiers comme suit:

line <- readLines(conn, n=1, warn=FALSE)

Ici, nous lisons les données de la connexion de fichier conn par ligne comme n=1 . on peut changer la valeur de n (disons 10, 20 etc.) pour lire des blocs de données pour une lecture plus rapide (bloc de 10 ou 20 lignes lu en une seule fois). Pour lire le fichier complet en une fois, définissez n=-1 .

Après le traitement des données ou dire l'exécution du modèle; on peut écrire les résultats en connexion à un fichier en utilisant de nombreuses commandes différentes telles que writeLines(),cat() etc., capables d'écrire dans une connexion de fichier. Cependant, toutes ces commandes tireront parti de la connexion de fichiers établie pour l’écriture. Cela pourrait être fait en utilisant la commande file() comme:

conn2 <- file("/path/result.data", "w") #when file is in local system
conn3 <- file("stdout", "w") #when just standard input/output for files are available

Ensuite, écrivez les données comme suit:

writeLines("text",conn2, sep = "\n")

Capture de la commande du système d'exploitation

Fonctions qui renvoient un vecteur de caractère

Base R a deux fonctions pour appeler une commande système. Les deux nécessitent un paramètre supplémentaire pour capturer la sortie de la commande système.

system("top -a -b -n 1", intern = TRUE) 
system2("top", "-a -b -n 1", stdout = TRUE)

Les deux renvoient un vecteur de caractères.

  [1] "top - 08:52:03 up 70 days, 15:09,  0 users,  load average: 0.00, 0.00, 0.00"     
  [2] "Tasks: 125 total,   1 running, 124 sleeping,   0 stopped,   0 zombie"            
  [3] "Cpu(s):  0.9%us,  0.3%sy,  0.0%ni, 98.7%id,  0.1%wa,  0.0%hi,  0.0%si,  0.0%st"  
  [4] "Mem:  12194312k total,  3613292k used,  8581020k free,   216940k buffers"        
  [5] "Swap: 12582908k total,  2334156k used, 10248752k free,  1682340k cached"         
  [6] ""                                                                                
  [7] "  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            "
  [8] "11300 root      20   0 1278m 375m 3696 S  0.0  3.2 124:40.92 trala              "
  [9] " 6093 user1     20   0 1817m 269m 1888 S  0.0  2.3  12:17.96 R                  "
 [10] " 4949 user2     20   0 1917m 214m 1888 S  0.0  1.8  11:16.73 R                  "

A titre d'illustration, la commande UNIX top -a -b -n 1 est utilisée. Ceci est spécifique au système d'exploitation et peut avoir besoin d'être modifié pour exécuter les exemples sur votre ordinateur.

Package devtools a pour fonction d'exécuter une commande système et de capturer la sortie sans paramètre supplémentaire. Il renvoie également un vecteur de caractères.

devtools::system_output("top", "-a -b -n 1") 

Fonctions qui renvoient un bloc de données

La fonction fread dans le package data.table permet d'exécuter une commande shell et de lire la sortie comme read.table . Il retourne un data.table ou un data.frame .

fread("top -a -b -n 1", check.names = TRUE)
       PID     USER PR NI  VIRT  RES  SHR S X.CPU X.MEM     TIME.         COMMAND
  1: 11300     root 20  0 1278m 375m 3696 S     0   3.2 124:40.92           trala
  2:  6093    user1 20  0 1817m 269m 1888 S     0   2.3  12:18.56               R
  3:  4949    user2 20  0 1917m 214m 1888 S     0   1.8  11:17.33               R
  4:  7922    user3 20  0 3094m 131m 1892 S     0   1.1  21:04.95               R

Notez que ce fread automatiquement ignoré les 6 premières lignes d'en-tête.

Ici, le paramètre check.names = TRUE été ajouté pour convertir %CPU , %MEN et TIME+ en noms de colonne syntaxiquement valides.