superponer - ¿Qué es exactamente una conexión en R?

superponer graficas en r

Question

He leído y uso con éxito las ?connections en R, pero realmente no entiendo cuáles son.

Entiendo que puedo descargar un archivo, leer y escribir un archivo comprimido, ... ( es decir, entiendo el resultado de usar una conexión (abrir, hacer cosas, cerrar) pero realmente no entiendo lo que hacen en realidad , por qué tienes que abrirlos y cerrarlos, etc. ).

Espero que esto también me ayude a entender cómo usarlos de manera más efectiva (principalmente entiendo la mecánica de lo que está sucediendo para poder depurar de manera efectiva cuando algo no funciona).

Answer 1

Las conexiones se introdujeron en R 1.2.0 y descritas por Brian Ripley en el primer número de R NEWS (ahora llamado The R Journal) de enero de 2001 (página 16-17) como una interfaz abstraída a flujos de IO como un archivo, url, toma de corriente o tubería En 2013, Simon Urbanek agregó una API Connections.h C que permite a los paquetes R implementar tipos de conexión personalizados, como el paquete curl .

Una característica de las conexiones es que puede leer o escribir fragmentos de datos de forma gradual a / desde la conexión utilizando las readBin , writeBin , readLines y writeLines . Esto permite el procesamiento de datos asíncronos, por ejemplo cuando se trata de grandes conexiones de datos o de red:

# Read the first 30 lines, 10 lines at a time
con <- url("http://jeroen.github.io/data/diamonds.json")
open(con, "r")
data1 <- readLines(con, n = 10)
data2 <- readLines(con, n = 10)
data3 <- readLines(con, n = 10)
close(con)

Lo mismo para escribir, por ejemplo, a un archivo:

tmp <- file(tempfile())
open(tmp, "w")
writeLines("A line", tmp)
writeLines("Another line", tmp)
close(tmp)

Abra la conexión como rb o wb para leer / escribir datos binarios (llamados vectores sin formato en R):

# Read the first 3000 bytes, 1000 bytes at a time
con <- url("http://jeroen.github.io/data/diamonds.json")
open(con, "rb")
data1 <- readBin(con, raw(), n = 1000)
data2 <- readBin(con, raw(), n = 1000)
data3 <- readBin(con, raw(), n = 1000)
close(con)

La conexión pipe() se utiliza para ejecutar un comando del sistema y canalizar texto a stdin o stdout como lo haría con el | operador en un caparazón. Ej. (Sigamos con los ejemplos de curl), puede ejecutar el programa de línea de comando curl y canalizar la salida a R:

con <- pipe("curl -H ''Accept: application/json'' https://jeroen.github.io/data/diamonds.json")
open(con, "r")
data1 <- readLines(con, n = 10)
data2 <- readLines(con, n = 10)
data3 <- readLines(con, n = 10)

Algunos aspectos de las conexiones son un poco confusos: para leer / escribir incrementalmente los datos, necesita open() y close() explícitamente la conexión. Sin embargo, readLines y writeLines abren y cierran automáticamente (¡pero no destruyen!) Una conexión sin abrir. Como resultado, el siguiente ejemplo leerá las primeras 10 líneas una y otra vez, lo que no es muy útil:

con <- url("http://jeroen.github.io/data/diamonds.json")
data1 <- readLines(con, n = 10)
data2 <- readLines(con, n = 10)
data3 <- readLines(con, n = 10)
identical(data1, data2)

Otro problema es que la API C puede cerrar y destruir una conexión, pero R solo expone una función llamada close() que en realidad significa destruir . Después de llamar a close() en una conexión, se destruye y es completamente inútil.

Para transmitir datos en forma de conexión, quiere usar un patrón como este:

stream <- function(){
con <- url("http://jeroen.github.io/data/diamonds.json")
open(con, "r")
on.exit(close(con))
while(length(txt <- readLines(con, n = 10))){
some_callback(txt)
}
}

El paquete jsonlite depende en gran medida de las conexiones para importar / exportar datos ndjson :

library(jsonlite)
library(curl)
diamonds <- stream_in(curl("https://jeroen.github.io/data/diamonds.json"))

La transmisión (por defecto 1000 líneas a la vez) lo hace rápido y eficiente en la memoria:

library(nycflights13)
stream_out(flights, file(tmp <- tempfile()))
flights2 <- stream_in(file(tmp))
all.equal(flights2, as.data.frame(flights))

Finalmente, una buena característica de las conexiones es que el recolector de basura las cerrará automáticamente si se olvida de hacerlo, con una advertencia molesta:

con <- file(system.file("DESCRIPTION"), open = "r")
rm(con)
gc()