R Language
Leyendo y escribiendo cuerdas.

Observaciones

Imprimir y mostrar cadenas

R tiene varias funciones integradas que se pueden usar para imprimir o mostrar información, pero las más básicas son print y cat . Como R es un lenguaje interpretado , puede probar esto directamente en la consola R:

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

Note la diferencia tanto en la entrada como en la salida para las dos funciones. (Nota: no hay caracteres de comillas en el valor de x creado con x <- "Hello World" . Se agregan mediante print en la etapa de salida).

cat toma uno o más vectores de caracteres como argumentos y los imprime en la consola. Si el vector de caracteres tiene una longitud mayor que 1, los argumentos están separados por un espacio (de manera predeterminada):

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

Sin el carácter de nueva línea ( \n ) la salida sería:

cat("Hello World")
#Hello World> 

La solicitud para el siguiente comando aparece inmediatamente después de la salida. (Algunas consolas, como RStudio, pueden agregar automáticamente una nueva línea a las cadenas que no terminan con una nueva línea).

print es un ejemplo de una función "genérica", lo que significa que se detecta la clase del primer argumento que se pasa y se utiliza un método específico de la clase para dar salida. Para un vector de caracteres como "Hello World" , el resultado es similar a la salida de cat . Sin embargo, la cadena de caracteres se cita y se emite un número [1] para indicar el primer elemento de un vector de caracteres (en este caso, el primer y único elemento):

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

Este método de impresión predeterminado también es lo que vemos cuando simplemente le pedimos a R que imprima una variable. Observe que el resultado de escribir s es lo mismo que llamar a print(s) o print("Hello World") :

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

O incluso sin asignarlo a nada:

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

Si añadimos otra cadena de caracteres como un segundo elemento del vector (utilizando el c() función para c oncatenate los elementos entre sí), entonces el comportamiento de print() se ve un poco diferente de la de cat :

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

Observe que la función c() no hace concatenación de cadenas. (Uno necesita usar paste para ese propósito). R muestra que el vector de caracteres tiene dos elementos al citarlos por separado. Si tenemos un vector lo suficientemente largo para abarcar varias líneas, R imprimirá el índice del elemento que comienza en cada línea, tal como se imprime [1] al comienzo de la primera línea.

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

El comportamiento particular de la print depende de la clase del objeto pasado a la función.

Si llamamos print un objeto con una clase diferente, como "numérico" o "lógico", las comillas se omiten de la salida para indicar que estamos tratando con un objeto que no es una clase de caracteres:

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

Los objetos factoriales se imprimen de la misma manera que las variables de caracteres, lo que a menudo crea ambigüedad cuando la salida de la consola se usa para mostrar objetos en los cuerpos de las preguntas SO. Es raro usar cat o print excepto en un contexto interactivo. Llamar explícitamente a print() es particularmente raro (a menos que desee suprimir el aspecto de las comillas o ver un objeto que una función devuelve como invisible ), ya que ingresar foo en la consola es un atajo para print(foo) . La consola interactiva de R se conoce como REPL, un "read-eval-print-loop". La función cat se guarda mejor para fines especiales (como escribir resultados en una conexión de archivo abierto). A veces se usa dentro de las funciones (donde se suprimen las llamadas a print() ), sin embargo, usar cat() dentro de una función para generar resultados en la consola es una mala práctica . El método preferido es message() o warning() para mensajes intermedios; se comportan de manera similar a cat pero el usuario final puede suprimirlos opcionalmente. El resultado final simplemente debe devolverse para que el usuario pueda asignarlo para almacenarlo si es necesario.

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

Leyendo desde o escribiendo a una conexión de archivo

No siempre tenemos la libertad de leer o escribir en una ruta del sistema local. Por ejemplo, si el código R que transmite map-reduce debe leer y escribir en la conexión de archivos. También puede haber otros escenarios donde uno va más allá del sistema local y con el advenimiento de la nube y el big data, esto se está volviendo cada vez más común. Una de las formas de hacerlo es en secuencia lógica.

Establezca una conexión de archivo para leer con file() comando file() ("r" es para el modo de lectura):

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

Como esto solo establecerá la conexión de archivos, se pueden leer los datos de estas conexiones de archivos de la siguiente manera:

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

Aquí estamos leyendo los datos de conexión de archivo conn línea por línea como n=1 . se puede cambiar el valor de n (por ejemplo, 10, 20, etc.) para leer bloques de datos para una lectura más rápida (lectura de bloques de 10 o 20 líneas de una sola vez). Para leer el archivo completo de una sola vez, establezca n=-1 .

Después del procesamiento de datos o decir la ejecución del modelo; uno puede escribir los resultados de nuevo a la conexión de archivos usando muchos comandos diferentes como writeLines(),cat() etc., que son capaces de escribir en una conexión de archivos. Sin embargo, todos estos comandos aprovecharán la conexión de archivos establecida para la escritura. Esto podría hacerse usando file() comando file() como:

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

Luego escribe los datos de la siguiente manera:

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

Salida de captura del comando del sistema operativo

Funciones que devuelven un vector de caracteres.

Base R tiene dos funciones para invocar un comando del sistema. Ambos requieren un parámetro adicional para capturar la salida del comando del sistema.

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

Ambos devuelven un vector de caracteres.

  [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 modo de ilustración, se utiliza el comando top -a -b -n 1 UNIX. Esto es específico del sistema operativo y es posible que deba modificarse para ejecutar los ejemplos en su computadora.

El paquete devtools tiene una función para ejecutar un comando del sistema y capturar la salida sin un parámetro adicional. También devuelve un vector de caracteres.

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

Funciones que devuelven un marco de datos.

La función fread en el paquete data.table permite ejecutar un comando de shell y leer la salida como read.table . Devuelve 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

Tenga en cuenta que fread se ha saltado automáticamente las 6 líneas de encabezado superiores.

Aquí se agregó el parámetro check.names = TRUE para convertir %CPU , %MEN , y TIME+ en nombres de columna sintácticamente válidos.