2.7: R y datos

Última actualización
Guardar como PDF

Page ID: 149971

\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

Cómo ingresar los datos desde dentro de R

Ahora necesitamos saber cómo introducir datos en R. El comando básico es c () (atajo de la palabra concatenar):

Código\(\PageIndex{1}\) (R):

c(1, 2, 3, 4, 5)

No obstante, de esa manera tus números serán olvidados porque R no recuerda nada que no se guarda en objeto:

Código\(\PageIndex{2}\) (R):

aa <- c(2, 3, 4, 5, 6, 7, 8)
aa

(Aquí creamos un objeto aa, le asignamos vector de números del uno al cinco, y luego imprimimos el objeto con escribir su nombre.)

Si desea crear e imprimir objetos simultáneamente, utilice paréntesis externos:

Código\(\PageIndex{3}\) (R):

(aa <- c(1, 2, 3, 4, 5, 6, 7, 8, 9))
aa

(Por cierto, aquí creamos aa objeto de nuevo, y R silenciosamente lo reescribió. R nunca da una advertencia si el objeto ya existe!)

Además de c (), podemos usar los comandos rep (), seq (), y también el operador colon (:):

Código\(\PageIndex{4}\) (R):

rep(1, 5)
rep(1:5, each=3)
seq(1, 5)
1:5

Cómo nombrar tus objetos

R no tiene reglas estrictas para nombrar tus objetos, pero es mejor seguir algunas pautas:

Tenga en cuenta que R distingue entre mayúsculas y minúsculas y, por ejemplo, X y x son nombres diferentes.
Para los objetos, use solo letras, números, puntos y (posiblemente) guiones bajos en inglés. No pongas números y puntos al principio del nombre. Uno de los enfoques recomendados es la doble letra (o triple letra) cuando nombras objetos como aa, jjj, xx y así sucesivamente.
En los marcos de datos, te recomendamos nombrar tus columnas (caracteres) con letras mayúsculas y puntos. Los ejemplos están a lo largo de este libro.
No reasignar nombres ya dados a funciones populares (como c ()), palabras reservadas (especialmente T, F, NA, NaN, Inf y NULL) y objetos predefinidos como pi\(^{[1]}\), LETRAS y letras. Si accidentalmente lo hiciste, existe la función conflict () para ayudar en estas situaciones. Para ver todas las palabras reservadas, escriba? Reservado.

Cómo cargar los datos de texto

En esencia, los datos que deben procesarse podrían ser de dos tipos: texto y binario. Para evitar detalles innecesarios, aceptaremos aquí que los datos de texto son algo que puedes leer y editar en el sencillo editor de texto como Geany\(^{[2]}\). Pero si quieres editar los datos binarios, normalmente necesitas un programa que haya generado este archivo en el pasado. Sin el software específico, los datos binarios no son fáciles de leer.

Los datos de texto para el procesamiento estadístico suelen ser tablas de texto donde cada fila corresponde con la fila de la tabla, y las columnas se separan con delimitadores, ya sea invisibles, como espacios o símbolos de tabulación, o visibles, como comas o punto y coma. Si desea que R “ingiera” este tipo de datos, es necesario asegurarse primero de que el archivo de datos se encuentre dentro del mismo directorio que R considera un directorio de trabajo:

Código\(\PageIndex{5}\) (R):

getwd()

Si este no es el directorio que desea, puede cambiarlo con el comando:

Código\(\PageIndex{6}\) (R):

setwd("e:\\wrk\\temp")   # Windows only!
getwd()

Observe cómo funciona R con barras inversas en Windows. En lugar de una diagonal inversa, debe ingresar dos. Sólo en ese caso R bajo Windows lo entenderá. También es posible usar barras en Windows, similares a Linux y macOS:

Código\(\PageIndex{7}\) (R):

setwd("e:/wrk/temp")
getwd()

Por favor, siempre comience cada una de sus sesiones R desde el cambio de directorio de trabajo. En realidad, no es absolutamente necesario recordar largos caminos. Puedes copiarlo desde tu gestor de archivos a R. Entonces, la R gráfica bajo Windows y macOS tienen un sistema de menús rudimentario, y a veces es más fácil cambiar directorio de trabajo a través del menú. Finalmente, collection asmisc.r contiene la función Files () que es el navegador de archivos textual, por lo que es posible ejecutar setwd (Files ()) y luego seguir las instrucciones de la pantalla\(^{[3]}\).

El siguiente paso después de que te hayas asegurado de que el directorio de trabajo es correcto, es verificar si tu archivo de datos está en su lugar, con el comando dir ():

Código\(\PageIndex{8}\) (R):

dir("data")

Es muy útil separar los datos de todas las demás cosas. Por lo tanto, asumimos anteriormente que tienes datos de subdirectorio en tu directorio de trabajo, y tus archivos de datos (incluyendo mydata.txt) están en ese subdirectorio. Por favor créelo (y por supuesto, cree el directorio de trabajo) si aún no lo tiene. Puedes crearlos con tu administrador de archivos, o incluso con la propia R:

Código\(\PageIndex{9}\) (R):

dir.create("data")

Ahora puedes cargar tus datos con el comando read.table (). ¡Pero espera un minuto! Primero necesitas entender la estructura de tu archivo.

Command read.table () es sofisticado pero no es lo suficientemente inteligente como para determinar la estructura de datos sobre la marcha\(^{[4]}\). Es por ello que es necesario verificar los datos. Puedes abrirlo en cualquier editor de texto simple disponible, en tu navegador web, o incluso desde dentro de R con el comando file.show () o url.show (). Da salida a los datos “tal cual”. Esto es lo que verás:

Código\(\PageIndex{10}\) (R):

file.show("data/mydata.txt")

(Por cierto, si escribes file.show (“datos/my y presionas Tab, la finalización te mostrará si tu archivo está aquí, si realmente está aquí. Esto guardará tanto escribiendo el nombre del archivo como verificando la presencia con dir ().)

¿Cómo apareció el archivo mydata.txt en tu subdirectorio de datos? Suponemos que ya lo descargaste del repositorio mencionado en el prólogo. Si no lo hiciste, por favor hazlo ahora. Es posible realizar con cualquier navegador e incluso con R:

Código\(\PageIndex{11}\) (R):

download.file("http://ashipunov.info/data/mydata.txt","data/mydata.txt")

(Dentro de paréntesis, la parte izquierda es para URL mientras que la derecha le dice a R cómo colocar y nombrar el archivo descargado).

Alternativamente, puede verificar su archivo directamente desde la URL con url.show () y luego usar read.table () desde la misma URL.

Ahora finalmente llegó el momento de cargar datos en R. Sabemos que todas las columnas tienen nombres, y por lo tanto usamos head=true, y también sabemos que el delimitador es el punto y coma, por eso usamos sep=”;”:

Código\(\PageIndex{12}\) (R):

mydata <- read.table("data/mydata.txt", sep=";", head=TRUE)

Inmediatamente después de cargar los datos, debemos verificar el nuevo objeto. Hay tres formas:

Código\(\PageIndex{13}\) (R):

mydata <- read.table("data/mydata.txt", sep=";", head=TRUE)
str(mydata)

La tercera forma es simplemente escribir mydata pero esto no es óptimo ya que cuando los datos son grandes, la pantalla de su computadora estará enredada con el contenido. Los comandos head () y str () son mucho más eficientes.

Para resumir, el archivo de datos locales debe cargarse en R en tres pasos:

Asegúrese de que sus datos estén en su lugar, con el comando dir (), completar tabulación o a través del navegador web;
Eche un vistazo a los datos con el comando file.show () o url.show () y determine su estructura;
Cargarlo con el comando read.table () usando las opciones apropiadas (ver más abajo).

Cómo cargar datos desde Internet

La carga de datos remotos toma los mismos tres pasos desde arriba. No obstante, como los datos no están en disco sino en otro lugar, para verificar su presencia, la mejor manera es abrirlos en el navegador de Internet usando URL que se le debe dar; esto también da el segundo paso porque verá su estructura en la ventana del navegador. También es posible verificar la estructura con el comando:

Código\(\PageIndex{14}\) (R):

url.show("http://ashipunov.info/data/mydata.txt")

Entonces puedes ejecutar read.table () pero con URL en lugar del nombre del archivo:

Código\(\PageIndex{15}\) (R):

read.table("http://ashipunov.info/data/mydata.txt", sep=";", head=TRUE)

(Aquí y abajo a veces omitiremos la creación de un nuevo paso de objeto. No obstante, recuerda que debes crear un nuevo objeto si quieres usar los datos en R más adelante. De lo contrario, el contenido se mostrará y se olvidará de inmediato.)

Cómo usar read.table ()

A veces, quieres que R “ingiera” no solo los nombres de las columnas sino también los nombres de las filas:

Código\(\PageIndex{16}\) (R):

read.table("data/mydata1.txt", head=TRUE)

(Archivo mydata1.txt\(^{[5]}\) se construye de la manera inusual: su primera fila tiene tres elementos mientras que todas las demás filas tienen cada una cuatro elementos delimitados con el símbolo de tabulación — “gran espacio invisible”. Por favor, no olvide verificarlo de antemano, por ejemplo usando el comando file.show () o url.show ().)

A veces, hay tanto espacios (dentro de celdas) como tabulaciones (entre celdas):

Código\(\PageIndex{17}\) (R):

read.table("data/mydata2.txt", sep="	", quote="", head=TRUE)

Si ejecutamos read.table () sin la opción sep= "\ t” (que es “separator is a tab”), R dará un error. Pruébalo. Pero, ¿por qué funcionó para mydata1.txt? Esto se debe a que el separador predeterminado es tanto el espacio como la tabulación. Si uno de ellos se utiliza como parte de los datos, el otro debe indicarse como separador explícitamente.

Tenga en cuenta también que dado que los nombres de fila contienen comillas, las citas deben deshabilitarse, de lo contrario los datos se leerán silenciosamente de manera incorrecta.

¿Cómo saber qué separador hay aquí, tab o espacio? Esto suele ser simple ya que la mayoría de los editores, navegadores y comandos file.show ()/url.show () visualizan tab como un espacio que es mucho más amplio que una sola letra. Sin embargo, no olvides usar fuente monoespaciada en tu software, otras fuentes podrían ser engañosas.

En ocasiones, los números tienen coma como separador decimal (este es otro estándar mundial). Para ingresar este tipo de datos, use la opción dec:

Código\(\PageIndex{18}\) (R):

read.table("data/mydata3.txt", dec=",", se=";", h=T)

(Tenga en cuenta los atajos. Los atajos guardan la escritura, pero podrían ser peligrosos si coinciden con varios nombres posibles. Solo hay un argumento read.table () que comienza con se, pero varios de ellos comienzan con s (e.g., skip); por lo tanto, es imposible reducirse más, en s. Tenga en cuenta también que VERDADERO y FALSO son posibles de encogerse en T y F, respectivamente (pero esta es la única forma posible); sin embargo, evitaremos esto en el libro.)

Cuando read.table () ve columnas de caracteres, las convierte en factores (ver abajo). Para evitar este comportamiento, utilice la opción AS.is=True.

Command scan () es similar a read.table () pero lee todos los datos en una sola “columna” (un vector). Tiene, sin embargo, una característica única:

Código\(\PageIndex{19}\) (R):

scan()

(¿Qué pasó aquí? Primero, ingresamos scan () con el primer argumento vacío, y R cambió su prompt a números permitiendo escribir datos numéricos en, elemento tras elemento. Para terminar, ingrese la fila vacía\ (^ {[6]}. ¡Aquí se pueden pegar números pares del portapapeles!)

Cómo cargar datos binarios

Las funciones del paquete externo (está instalado por defecto) pueden leer datos en formatos binarios MiniTab, S, SAS, SPSS, Stata, Systat y FoxPro DBF. Para obtener más información, es posible que desee llamarlo primero con la biblioteca de comandos (foránea) y luego llamar a help sobre todos sus comandos help (package=foreign).

R puede subir imágenes. Existen múltiples paquetes para esto, uno de los más desarrollados es pixmap. R también puede subir mapas SIG de diferentes formatos incluyendo ArcInfo (paquetes de mapas, maptools y otros).

R tiene su propio formato binario. Es muy rápido de escribir y de cargar\(^{[7]}\) (útil para big data) pero imposible de usar con cualquier programa que no sea R:

Código\(\PageIndex{20}\) (R):

xx <- "apple"
save(xx, file="xx.rd")
exists("xx")
rm(xx)
exists("xx")
dir()
load("xx.rd")
xx

(Aquí usamos varios comandos nuevos. Para guardar y cargar archivos binarios, se necesitan los comandos save () y load (), respectivamente; para eliminar el objeto, existe el comando rm (). Para mostrarle que el objeto fue eliminado, utilizamos el comando exists ().)

Tenga en cuenta también que todo lo que se escribe después del símbolo “#” en la misma cadena de texto es un comentario. R se salta todos los comentarios sin leer.

Hay muchas interfaces que conectan R a bases de datos incluyendo MySQL, PostgresSQL y sqlite (es posible llamar a la última directamente desde dentro de R ver la documentación de los paquetes RSQLite y sqldf).

Pero lo que la mayoría de los usuarios realmente necesitan es cargar los datos de la hoja de cálculo hechos con MS Excel o programas similares (como Gnumeric o LibreOffice Calc). Hay tres formas.

Primera forma recomendamos a todos los usuarios de este libro: convertir el archivo Excel en el texto, y luego proceder con el comando read.table () explicado anteriormente\(^{[8]}\). En macOS, la mejor manera es probable que guarde los datos de la hoja de cálculo como archivo de texto delimitado por tabulaciones. En Windows y Linux, si copia alguna hoja de cálculo en el portapapeles y luego la pegas en el editor de texto (incluido el editor de scripts R), se convierte en el texto delimitado por tabuladores. Lo mismo es posible en macOS pero necesitarás usar algún editor de terminal (como nano).

Otra forma es usar paquetes externos que conviertan hojas de cálculo binarias “sobre la marcha”. Uno es el paquete readxl con el comando principal read_excel (), otro es el paquete xlsx con el comando principal read.xlsx (). Tenga en cuenta que estos paquetes no están disponibles de forma predeterminada, por lo que debe descargarlos e instalarlos (consulte a continuación las explicaciones).

Cómo cargar datos desde el portapapeles

La tercera forma es usar el portapapeles. Ya es bastante fácil: en Linux o Windows necesitarás seleccionar datos en la hoja de cálculo abierta, copiarlos al portapapeles, y luego en la ventana R escriba comando como:

Código\(\PageIndex{21}\) (R):

read.table("clipboard", sep="	", head=TRUE)

En macOS, esto es ligeramente diferente:

Código\(\PageIndex{22}\) (R):

read.table(pipe("pbpaste"), sep="	", head=TRUE)

(Ignorar las advertencias sobre “líneas incompletas” o “conexión cerrada”. Package clipr unifica el trabajo con el portapapeles en los sistemas operativos principales.)

La “manera del portapapeles” es especialmente buena cuando tus datos salen de un software no típico. Tenga en cuenta también que ingresar scan () y luego pegar desde el portapapeles (ver arriba) funcionan de la misma manera en todos los sistemas.

Resumiendo lo anterior, el flujo de trabajo de datos recomendado en R podría verse así:

Introducir datos en la hoja de cálculo;
Guárdelo como un archivo de texto con delimitadores conocidos (se prefieren tabulación y punto y coma), encabezados y nombres de filas (si es necesario);
Cargarlo en R con read.table ();
Si debes cambiar los datos en R, escríbalos después en el archivo externo usando el comando write.table () (ver abajo);
Ábrala nuevamente en el programa de hoja de cálculo y pasa a la siguiente ronda.

Una de sus grandes ventajas de este flujo de trabajo es la separación entre la edición de datos y el procesamiento de datos.

Cómo editar datos en R

Si es necesario cambiar los objetos existentes, podría editarlos a través de R. Sin embargo, no recomendamos esto, las hojas de cálculo y los editores de texto son mucho más avanzados que las herramientas internas de R.

Sin embargo, hay un subprograma de hoja de cálculo incrustado en R que está configurado para editar objetos similares a tablas (matrices o marcos de datos). Para iniciarlo en la matriz bb (ver arriba), ingresa el comando fix (bb) y edita “in place”. Todo lo que ingrese cambiará inmediatamente su objeto. Esto es algo contradictorio con los principios R por lo que existe la función similar edit () que no cambia el objeto sino que emite el resultado a la ventana R.

Para otros tipos de objetos (no similares a tablas), los comandos fix ()/edit () llaman al editor de texto interno (en Windows o macOS) o externo (en Linux). Para usar editor externo, es posible que deba proporcionar un argumento adicional, edit (..., editor="name”) donde name podría ser cualquier editor de texto que esté disponible en el sistema.

R en Linux tiene editor vi por defecto pero es demasiado avanzado para el principiante\(^{[9]}\); recomendamos usar nano en su lugar\(^{[10]}\). Además, hay un comando pico () que suele ser igual a edit (..., editor="nano”). nano editor suele estar disponible también a través del terminal macOS.

Cómo guardar los resultados

Los principiantes en R simplemente copian los resultados del trabajo (como los resultados de pruebas estadísticas) de la consola R en algún archivo de texto. Esto es suficiente si eres el principiante. Antes o después, sin embargo, se hace necesario guardar objetos más grandes (como marcos de datos):

Código\(\PageIndex{23}\) (R):

write.table(file="trees.txt", trees, row.names=FALSE, sep="	", quote=FALSE)

(El archivo trees.txt, que se realiza a partir del marco de datos de árboles internos, se escribirá en el directorio de trabajo.)

Por favor, tenga mucho cuidado con write.table () ya que R es perfectamente silencioso si el archivo con el mismo nombre trees.txt ya está aquí. En lugar de darte alguna advertencia, ¡simplemente lo sobrescribe!

Por cierto, “datos internos” significa que es accesible desde el interior de R directamente, sin carga preliminar. Es posible que desee verificar qué datos internos están disponibles con los datos de comando ().

Mientras que un scan () es una variante de un solo vector de read.table (), write () es la variante de vector único de write.table ().

Ahora es un buen momento para hablar sobre las convenciones de nombre de archivo en este libro. Recomendamos encarecidamente seguir estas reglas simples:

Use solo letras, números y guiones bajos en inglés en minúsculas para los nombres de archivo y directorio (y también punto, pero solo para separar la extensión del archivo).
¡No uses letras mayúsculas, espacios y otros símbolos!
Haga sus nombres cortos, preferiblemente más cortos que 15—20 símbolos.
Para archivos de comandos R (script), utilice la extensión *.r

Por cierto, para el trabajo cómodo en R, se recomienda encarecidamente cambiar aquellas opciones de su sistema operativo que le permitan ocultar extensiones de archivo. En macOS, vaya a las preferencias del Finder, elija la pestaña Avanzado y seleccione la casilla correspondiente. En Windows, haga clic en la pestaña Ver en el Explorador de archivos, elija Opciones, luego Ver nuevamente, desactive la casilla correspondiente y aplique esto a todas las carpetas. Linux, por regla general, no oculta las extensiones de archivo.

Pero, ¿y si necesitamos escribir en el archivo externo nuestros resultados (como el resultado de la prueba estadística)? Existe el comando sink ():

Código\(\PageIndex{24}\) (R):

sink("1.txt", split=TRUE)
2+2
sink()

(Aquí la cadena “[1] 4” se escribirá en el archivo externo. ),

Especificamos split=true argumento porque queríamos ver el resultado en la pantalla. Especifique también append=True si desea agregar salida al archivo existente. Para dejar de hundirse, use sink () sin argumentos. ¡Asegúrate de que siempre cierras el fregadero ()!

Hay muchas herramientas y paquetes externos que mejoran R para que se comporte como un sistema de informes con todas las funciones que no solo calcula algo para usted sino que también le ayuda a escribir los resultados. Uno de los más simples es Rresults shell script (http://ashipunov.info/shipunov/r) que funciona en macOS y Linux. El apéndice del libro explica el sistema Sweave. También hay géneros de punto y mucho más.

Historia y guiones

Para ver lo que escribiste durante la sesión R actual, ejecuta history ()\(^{[11]}\):

Código\(\PageIndex{25}\) (R):

history(100) # 100 last commands
history(Inf) # all session commands
history(p="plot") # last plot commands

Si quieres guardar tu historial de comandos, usa savehistory () con el nombre de archivo apropiado (entre comillas) como argumento\ (^ {[12]}).

Mientras trabajas con este libro, es una buena idea usar savehistory () y guardar todos los comandos de cada sesión R en el archivo llamado, diciendo, antes de la fecha (como 20170116.r) y almacenar este archivo en tu carpeta de trabajo.

Para hacerlo en macOS, use el menú R -> Preferencias -> Inicio -> Historial, desmarque Leer archivo de historial al inicio e ingrese el nombre del archivo de historial de hoy. Cuando cierras R, el archivo aparecerá en tu directorio de trabajo.

Para guardar todos los objetos en el archivo binario, escriba save.image (). Es posible que desee usarlo si, por ejemplo, está experimentando con R.

R permite crear scripts que podrían ejecutarse más tarde para reproducir su trabajo. En realidad, los scripts R podrían escribirse en cualquier editor de texto\(^{[13]}\).

En el apéndice, hay mucho más sobre los scripts R, pero lo siguiente te ayudará a crear tu propio primero:

Abra el editor de texto, o simplemente escriba file.edit (“hola.r”)\(^{[14]}\)
Escribe ahí la cadena impresa (“¡Hola, mundo!”)
Guarda el archivo bajo el nombre hola.r en tu directorio de trabajo
Llámalo desde R usando el comando source (“hola.r”)
... y verás [1] “¡Hola, mundo!” en consola R como si la escribieras.

(De hecho, incluso puedes escribir en el guión “¡Hola mundo!” sin print (), R va a entender qué hacer.)

Entonces, cada vez que agregues algún comando R al hello.r, verás cada vez más resultados. Pruébalo.

Para ver entrada (comandos) y salida (resultados) juntos, escriba source (“hello.r”, echo=true).

El scripting es la “característica asesina” de R. Si todos sus archivos de datos están en su lugar, y el script R está hecho, ¡puede volver fácilmente a sus cálculos años después! Además, otros pueden hacer exactamente lo mismo con tus datos y por lo tanto tu investigación se vuelve completamente reproducible. Aún más, si encuentra que sus datos deben cambiarse, ejecuta el mismo script y generará resultados que tienen en cuenta todos los cambios.

Command source () permite cargar comandos no solo desde el archivo local sino también desde Internet. Solo necesitas reemplazar el nombre del archivo con URL.

Referencias

1. Por cierto, si quieres el número de Euler, e, escribe exp (1).

2. Y también como editor que está incrustado en R para Windows o en la GUI de R macOS, o el editor del paquete rite R, ¡pero no software de oficina como MS Word o Excel!

3. Otra posibilidad es establecer el directorio de trabajo en preferencias (esto es bastante diferente entre sistemas operativos) pero esta no es la mejor solución porque podría (y probablemente querrá) diferentes directorios de trabajo para diferentes tareas.

4. Hay paquete rio que puede determinar la estructura de los datos.

5. Nuevamente, descárguelo primero de Internet al subdirectorio de datos. Alternativamente, reemplace el subdirectorio con URL y cárguelo en R directamente, por supuesto, después de verificar la estructura.

6. En macOS, escriba Enter dos veces.

7. Con los comandos dput () y dget (), R también guarda y carga representaciones textuales de objetos.

8. Esto es un poco similar a la broma sobre matemático que, para hervir la tetera llena de agua, la vaciaría primero y por lo tanto reduciría el problema a uno que ya estaba resuelto!

9. Si, por casualidad, empezó y no tienes idea de cómo dejar de fumar, presiona ZQ mayúscula.

10. Dentro de nano, usa Ctrl+O para guardar tus ediciones y Ctrl+X para salir.

11. No funciona en macOS gráficos.

12. Bajo MacOS gráfico, este comando no es accesible, y es necesario utilizar el menú de la aplicación.

13. También puede usar el comando savehistory () para hacer un script “starter”.

14. En Windows y macOS, esto abrirá el editor interno; en Linux, es mejor establecer la opción del editor manualmente, por ejemplo, file.edit (“hola.r”, editor="geany”).