R Language
Tekenreeksen lezen en schrijven

Opmerkingen

Tekenreeksen afdrukken en weergeven

R heeft verschillende ingebouwde functies die kunnen worden gebruikt om informatie af te drukken of weer te geven, maar print en cat zijn het meest basaal. Omdat R een geïnterpreteerde taal is , kunt u deze rechtstreeks in de R-console uitproberen:

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

Let op het verschil in invoer en uitvoer voor de twee functies. (Opmerking: er zijn geen aanhalingstekens in de waarde van x gemaakt met x <- "Hello World" . Ze worden in de uitgangsfase door print toegevoegd.)

cat neemt een of meer karaktervectoren als argumenten en print deze naar de console. Als de tekenvector een lengte heeft die groter is dan 1, worden argumenten gescheiden door een spatie (standaard):

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

Zonder het teken van de nieuwe regel ( \n ) zou de uitvoer zijn:

cat("Hello World")
#Hello World> 

De prompt voor de volgende opdracht verschijnt direct na de uitvoer. (Sommige consoles zoals RStudio's voegen automatisch een nieuwe regel toe aan tekenreeksen die niet eindigen op een nieuwe regel.)

print is een voorbeeld van een "generieke" functie, wat betekent dat de klasse van het eerste doorgegeven argument wordt gedetecteerd en een klassespecifieke methode wordt gebruikt om uit te voeren. Voor een tekenvector zoals "Hello World" is het resultaat vergelijkbaar met de uitvoer van cat . De tekenreeks wordt echter tussen aanhalingstekens geplaatst en een nummer [1] wordt uitgevoerd om het eerste element van een tekenvector aan te geven (in dit geval het eerste en enige element):

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

Deze standaardafdrukmethode is ook wat we zien wanneer we R eenvoudigweg vragen om een variabele af te drukken. Merk op dat de uitvoer van het typen van s hetzelfde is als het aanroepen van print(s) of print("Hello World") :

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

Of zelfs zonder het aan iets toe te wijzen:

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

Als we een tekenreeks toevoegen tweede element van de vector (met de c() functie c oncatenate de elementen samen), dan is het gedrag van print() ziet er nogal verschilt van die van cat :

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

Merk op dat de functie c() geen string-aaneenschakeling uitvoert. (Men moet daarvoor paste gebruiken.) R laat zien dat de karaktervector twee elementen heeft door ze afzonderlijk te citeren. Als we een vector hebben die lang genoeg is om meerdere lijnen te overbruggen, drukt R de index af van het element dat elke regel begint, net zoals het wordt afgedrukt [1] aan het begin van de eerste regel.

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

Het specifieke gedrag van print hangt af van de klasse van het object dat aan de functie is doorgegeven.

Als we een object met een andere klasse, zoals "numeriek" of "logisch", print noemen, worden de aanhalingstekens weggelaten om aan te geven dat we te maken hebben met een object dat geen tekenklasse is:

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

Factorobjecten worden op dezelfde manier afgedrukt als tekenvariabelen, wat vaak dubbelzinnigheid creëert wanneer console-uitvoer wordt gebruikt om objecten weer te geven in SO-vragen. Het is zeldzaam om cat of print behalve in een interactieve context. Expliciet aanroepen van print() is bijzonder zeldzaam (tenzij je de weergave van de aanhalingstekens wilt onderdrukken of een object wilt bekijken dat door een functie als invisible wordt geretourneerd), omdat foo invoeren op de console een snelkoppeling is voor print(foo) . De interactieve console van R staat bekend als een REPL, een "read-eval-print-loop". De cat functie kan het beste worden opgeslagen voor speciale doeleinden (zoals het schrijven van uitvoer naar een open bestandsverbinding). Soms wordt het gebruikt in functies (waar aanroepen van print() worden onderdrukt), maar het is een slechte gewoonte om cat() in een functie te gebruiken om uitvoer naar de console te genereren . De voorkeursmethode is message() of warning() voor tussentijdse berichten; ze gedragen zich op dezelfde manier als cat maar kunnen optioneel worden onderdrukt door de eindgebruiker. Het eindresultaat moet eenvoudig worden geretourneerd, zodat de gebruiker het kan toewijzen om het indien nodig op te slaan.

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

Lezen van of schrijven naar een bestandsverbinding

We hebben niet altijd de vrijheid om te lezen van of te schrijven naar een lokaal systeempad. Als bijvoorbeeld R-code streaming map-reduce moet moeten lezen en schrijven naar bestandsverbinding. Er kunnen ook andere scenario's zijn waarbij men verder gaat dan het lokale systeem en met de komst van cloud en big data wordt dit steeds gebruikelijker. Een van de manieren om dit te doen is in logische volgorde.

Breng een bestandsverbinding tot stand om te lezen met de opdracht file() ("r" is voor de leesmodus):

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

Aangezien dit alleen een bestandsverbinding tot stand zal brengen, kan men de gegevens van deze bestandsverbindingen als volgt lezen:

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

Hier lezen we de gegevens van bestandsverbinding conn regel voor regel als n=1 . men kan de waarde van n (zeg 10, 20 etc.) voor het lezen van datablokken voor sneller lezen (10 of 20 regels blok lezen in één keer). Als u het volledige bestand in één keer wilt lezen, stelt u n=-1 .

Na gegevensverwerking of zeg maar modeluitvoering; men kan de resultaten terugschrijven naar een bestandsverbinding met behulp van veel verschillende commando's zoals writeLines(),cat() etc. die in staat zijn om naar een bestandsverbinding te schrijven. Al deze opdrachten maken echter gebruik van een bestandsverbinding die is ingesteld voor schrijven. Dit kan worden gedaan met de opdracht file() als:

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

Schrijf vervolgens de gegevens als volgt:

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

Capture output van besturingssysteem commando

Functies die een karaktervector retourneren

Base R heeft twee functies voor het aanroepen van een systeemopdracht. Beide vereisen een extra parameter om de uitvoer van de systeemopdracht vast te leggen.

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

Beide retourneren een tekenvector.

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

Ter illustratie wordt het UNIX-commando top -a -b -n 1 gebruikt. Dit is besturingssysteemspecifiek en moet mogelijk worden aangepast om de voorbeelden op uw computer uit te voeren.

Pakket devtools heeft een functie om een systeemopdracht uit te voeren en de uitvoer vast te leggen zonder een extra parameter. Het retourneert ook een tekenvector.

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

Functies die een gegevensframe retourneren

De fread functie in pakket data.table maakt het mogelijk om een shell-commando uit te voeren en de uitvoer te lezen zoals read.table . Het retourneert een data.table of een 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

Merk op dat dat fread automatisch de top 6 kopregels heeft overgeslagen.

Hier is de parameter check.names = TRUE toegevoegd om %CPU , %MEN en TIME+ te converteren naar syntactisch geldige kolomnamen.