R Language
Lettura e scrittura di stringhe

Osservazioni

Stampa e visualizzazione di stringhe

R ha diverse funzioni incorporate che possono essere utilizzate per stampare o visualizzare informazioni, ma print e cat sono le più elementari. Poiché R è un linguaggio interpretato , puoi provarli direttamente nella console R:

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

Notare la differenza di input e output per le due funzioni. (Nota: non ci sono caratteri di citazione nel valore di x creato con x <- "Hello World" . Sono aggiunti per print allo stadio di uscita.)

cat prende uno o più vettori di caratteri come argomenti e li stampa sulla console. Se il vettore di caratteri ha una lunghezza maggiore di 1, gli argomenti sono separati da uno spazio (per impostazione predefinita):

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

Senza il carattere di nuova riga ( \n ) l'output sarebbe:

cat("Hello World")
#Hello World> 

Il prompt per il comando successivo viene visualizzato immediatamente dopo l'output. (Alcune console come RStudio possono aggiungere automaticamente una nuova riga alle stringhe che non terminano con una nuova riga.)

print è un esempio di una funzione "generica", ovvero la classe del primo argomento passato viene rilevata e un metodo specifico della classe viene utilizzato per l'output. Per un vettore di caratteri come "Hello World" , il risultato è simile all'output di cat . Tuttavia, la stringa di caratteri viene citata e viene emesso un numero [1] per indicare il primo elemento di un vettore di caratteri (in questo caso, il primo e l'unico elemento):

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

Questo metodo di stampa predefinito è anche quello che vediamo quando chiediamo semplicemente a R di stampare una variabile. Nota come l'output della digitazione s equivale a chiamare le print(s) o print("Hello World") :

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

O anche senza assegnarlo a nulla:

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

Se aggiungiamo un'altra stringa di caratteri come un secondo elemento del vettore (usando la funzione c() per c oncatenare insieme gli elementi), allora il comportamento di print() sembra abbastanza diverso da quello di cat :

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

Si osservi che la c() funzione non fa stringa concatenazione. (Uno ha bisogno di usare paste per quello scopo.) R mostra che il vettore di caratteri ha due elementi citandoli separatamente. Se abbiamo un vettore abbastanza lungo da estendersi su più righe, R stamperà l'indice dell'elemento iniziando ogni riga, così come stampa [1] all'inizio della prima riga.

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."

Il particolare comportamento della print dipende dalla classe dell'oggetto passato alla funzione.

Se chiamiamo print un oggetto con una classe diversa, come "numerico" o "logico", le virgolette vengono omesse dall'output per indicare che abbiamo a che fare con un oggetto che non è una classe di caratteri:

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

Gli oggetti fattoriali vengono stampati allo stesso modo delle variabili di carattere che spesso creano ambiguità quando l'output della console viene utilizzato per visualizzare gli oggetti nei corpi delle domande SO. È raro utilizzare cat o print tranne che in un contesto interattivo. Il richiamo esplicito di print() è particolarmente raro (a meno che non si desideri sopprimere l'aspetto delle virgolette o visualizzare un oggetto restituito come invisible da una funzione), poiché l'immissione di foo nella console è una scorciatoia per la print(foo) . La console interattiva di R è nota come REPL, un "read-eval-print-loop". La funzione cat è salvata al meglio per scopi speciali (come la scrittura di output su una connessione di file aperta). A volte viene utilizzato all'interno delle funzioni (dove vengono soppresse le chiamate a print() ), tuttavia l' uso di cat() all'interno di una funzione per generare output sulla console è una cattiva pratica . Il metodo preferito è message() o warning() per i messaggi intermedi; si comportano in modo simile al cat ma possono essere opzionalmente soppressi dall'utente finale. Il risultato finale dovrebbe semplicemente essere restituito in modo che l'utente possa assegnarlo per memorizzarlo se necessario.

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

Leggere o scrivere su una connessione file

Non sempre abbiamo la libertà di leggere o scrivere su un percorso di sistema locale. Ad esempio se il codice R streaming map-reduce deve avere bisogno di leggere e scrivere sulla connessione file. Ci possono essere anche altri scenari in cui si va oltre il sistema locale e con l'avvento di cloud e big data, questo sta diventando sempre più comune. Uno dei modi per farlo è nella sequenza logica.

Stabilire una connessione file da leggere con file() comando file() ("r" è per la modalità lettura):

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

Poiché ciò stabilirà solo la connessione dei file, è possibile leggere i dati da queste connessioni di file come segue:

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

Qui stiamo leggendo i dati dalla connessione file conn linea per linea come n=1 . si può cambiare il valore di n (ad esempio 10, 20 ecc.) per leggere i blocchi di dati per una lettura più veloce (blocco di 10 o 20 righe letto in una volta sola). Per leggere il file completo in una volta, impostare n=-1 .

Dopo l'elaborazione dei dati o dire esecuzione del modello; si possono scrivere i risultati sulla connessione di file usando molti comandi diversi come writeLines(),cat() ecc. che sono in grado di scrivere su una connessione di file. Tuttavia, tutti questi comandi sfrutteranno la connessione ai file stabilita per la scrittura. Questo può essere fatto usando file() comando file() come:

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

Quindi scrivi i dati come segue:

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

Cattura l'output del comando del sistema operativo

Funzioni che restituiscono un vettore di caratteri

Base R ha due funzioni per richiamare un comando di sistema. Entrambi richiedono un parametro aggiuntivo per acquisire l'output del comando di sistema.

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

Entrambi restituiscono un vettore di caratteri.

  [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                  "

Per illustrazione, viene utilizzato il comando UNIX top -a -b -n 1 . Questo è specifico del sistema operativo e potrebbe dover essere modificato per eseguire gli esempi sul tuo computer.

Il pacchetto devtools ha una funzione per eseguire un comando di sistema e acquisire l'output senza un parametro aggiuntivo. Restituisce anche un vettore di caratteri.

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

Funzioni che restituiscono un frame di dati

La funzione fread nel pacchetto data.table consente di eseguire un comando shell e di leggere l'output come read.table . Restituisce un data.table o 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

Nota, che il fread ha saltato automaticamente le prime 6 linee di intestazione.

Qui è stato aggiunto il parametro check.names = TRUE per convertire %CPU , %MEN e TIME+ in nomi di colonne validi in modo sintattico.