Saltar al contenido principal

3.2: Escribir comandos en la consola R

$$\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}}$$

$$\newcommand{\vectorA}[1]{\vec{#1}} % arrow$$

$$\newcommand{\vectorAt}[1]{\vec{\text{#1}}} % arrow$$

$$\newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} }$$

$$\newcommand{\vectorC}[1]{\textbf{#1}}$$

$$\newcommand{\vectorD}[1]{\overrightarrow{#1}}$$

$$\newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}}$$

$$\newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}}$$

$$\newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} }$$

$$\newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}}$$

$$\newcommand{\avec}{\mathbf a}$$ $$\newcommand{\bvec}{\mathbf b}$$ $$\newcommand{\cvec}{\mathbf c}$$ $$\newcommand{\dvec}{\mathbf d}$$ $$\newcommand{\dtil}{\widetilde{\mathbf d}}$$ $$\newcommand{\evec}{\mathbf e}$$ $$\newcommand{\fvec}{\mathbf f}$$ $$\newcommand{\nvec}{\mathbf n}$$ $$\newcommand{\pvec}{\mathbf p}$$ $$\newcommand{\qvec}{\mathbf q}$$ $$\newcommand{\svec}{\mathbf s}$$ $$\newcommand{\tvec}{\mathbf t}$$ $$\newcommand{\uvec}{\mathbf u}$$ $$\newcommand{\vvec}{\mathbf v}$$ $$\newcommand{\wvec}{\mathbf w}$$ $$\newcommand{\xvec}{\mathbf x}$$ $$\newcommand{\yvec}{\mathbf y}$$ $$\newcommand{\zvec}{\mathbf z}$$ $$\newcommand{\rvec}{\mathbf r}$$ $$\newcommand{\mvec}{\mathbf m}$$ $$\newcommand{\zerovec}{\mathbf 0}$$ $$\newcommand{\onevec}{\mathbf 1}$$ $$\newcommand{\real}{\mathbb R}$$ $$\newcommand{\twovec}[2]{\left[\begin{array}{r}#1 \\ #2 \end{array}\right]}$$ $$\newcommand{\ctwovec}[2]{\left[\begin{array}{c}#1 \\ #2 \end{array}\right]}$$ $$\newcommand{\threevec}[3]{\left[\begin{array}{r}#1 \\ #2 \\ #3 \end{array}\right]}$$ $$\newcommand{\cthreevec}[3]{\left[\begin{array}{c}#1 \\ #2 \\ #3 \end{array}\right]}$$ $$\newcommand{\fourvec}[4]{\left[\begin{array}{r}#1 \\ #2 \\ #3 \\ #4 \end{array}\right]}$$ $$\newcommand{\cfourvec}[4]{\left[\begin{array}{c}#1 \\ #2 \\ #3 \\ #4 \end{array}\right]}$$ $$\newcommand{\fivevec}[5]{\left[\begin{array}{r}#1 \\ #2 \\ #3 \\ #4 \\ #5 \\ \end{array}\right]}$$ $$\newcommand{\cfivevec}[5]{\left[\begin{array}{c}#1 \\ #2 \\ #3 \\ #4 \\ #5 \\ \end{array}\right]}$$ $$\newcommand{\mattwo}[4]{\left[\begin{array}{rr}#1 \amp #2 \\ #3 \amp #4 \\ \end{array}\right]}$$ $$\newcommand{\laspan}[1]{\text{Span}\{#1\}}$$ $$\newcommand{\bcal}{\cal B}$$ $$\newcommand{\ccal}{\cal C}$$ $$\newcommand{\scal}{\cal S}$$ $$\newcommand{\wcal}{\cal W}$$ $$\newcommand{\ecal}{\cal E}$$ $$\newcommand{\coords}[2]{\left\{#1\right\}_{#2}}$$ $$\newcommand{\gray}[1]{\color{gray}{#1}}$$ $$\newcommand{\lgray}[1]{\color{lightgray}{#1}}$$ $$\newcommand{\rank}{\operatorname{rank}}$$ $$\newcommand{\row}{\text{Row}}$$ $$\newcommand{\col}{\text{Col}}$$ $$\renewcommand{\row}{\text{Row}}$$ $$\newcommand{\nul}{\text{Nul}}$$ $$\newcommand{\var}{\text{Var}}$$ $$\newcommand{\corr}{\text{corr}}$$ $$\newcommand{\len}[1]{\left|#1\right|}$$ $$\newcommand{\bbar}{\overline{\bvec}}$$ $$\newcommand{\bhat}{\widehat{\bvec}}$$ $$\newcommand{\bperp}{\bvec^\perp}$$ $$\newcommand{\xhat}{\widehat{\xvec}}$$ $$\newcommand{\vhat}{\widehat{\vvec}}$$ $$\newcommand{\uhat}{\widehat{\uvec}}$$ $$\newcommand{\what}{\widehat{\wvec}}$$ $$\newcommand{\Sighat}{\widehat{\Sigma}}$$ $$\newcommand{\lt}{<}$$ $$\newcommand{\gt}{>}$$ $$\newcommand{\amp}{&}$$ $$\definecolor{fillinmathshade}{gray}{0.9}$$

Una de las cosas más fáciles que puedes hacer con R es usarla como una calculadora simple, por lo que es un buen lugar para comenzar. Por ejemplo, intente escribir 10 + 20, y golpear enter. 18 Cuando haces esto, has ingresado un comando, y R “ejecutará” ese comando. Lo que ves ahora en pantalla será esto:

> 10 + 20
[1] 30

No hay muchas sorpresas en este extracto. Pero hay algunas cosas de las que vale la pena hablar, incluso con un ejemplo tan sencillo. En primer lugar, es importante que entiendas cómo leer el extracto. En este ejemplo, lo que escribí fue la parte 10 + 20. No escribí el símbolo >: eso es solo el símbolo del sistema R y no es parte del comando real. Y tampoco escribí la [1] 30 parte. Eso es lo que R imprimió en respuesta a mi orden.

En segundo lugar, es importante entender cómo se formatea la salida. Obviamente, la respuesta correcta a la suma 10 + 20 es 30, y no es sorprendente que R haya impreso eso como parte de su respuesta. Pero también está impresa esta [1] parte, que probablemente no tenga mucho sentido para ti en este momento. Eso lo vas a ver mucho. Hablaré de lo que esto significa con un poco más de detalle más adelante, pero por ahora se puede pensar en [1] 30 como si R estuviera diciendo “la respuesta a la 1ª pregunta que hiciste es 30”. Esa no es exactamente la verdad, pero está lo suficientemente cerca por ahora. Y en cualquier caso no es realmente muy interesante por el momento: solo le pedimos a R que calculara una cosa, así que obviamente solo hay una respuesta impresa en la pantalla. Posteriormente esto cambiará, y la [1] parte comenzará a tener un poco más de sentido. Por ahora, simplemente no quiero que te confundas ni te preocupes por ello.

digresión importante sobre el formateo

Ahora que te he enseñado estas reglas las voy a cambiar prácticamente de inmediato. Eso es porque quiero que puedas copiar código del libro directamente a R si quieres probar cosas o realizar tus propios análisis. Sin embargo, si copia este tipo de código (que muestra el símbolo del sistema y los resultados) directamente en R, obtendrá un error

> 10 + 20
[1] 30
## Error: <text>:1:1: unexpected '>'
## 1: >
##     ^

Entonces, en cambio, voy a proporcionar código en un formato ligeramente diferente para que se vea así...

10 + 20
## [1] 30

Hay dos diferencias principales.

• En tu consola, escribes después del >, pero a partir de ahora no voy a mostrar el símbolo del sistema en el libro.
• En el libro, la salida se comenta con ##, en tu consola aparece directamente después de tu código.

Estas dos diferencias significan que si estás trabajando con una versión electrónica del libro, puedes copiar fácilmente código fuera del libro y en la consola.

Entonces, por ejemplo, si copiaste las dos líneas de código del libro obtendrías esto

10 + 20
## [1] 30
## [1] 30

muy cuidadoso para evitar errores tipográficos

Antes de continuar hablando de otro tipo de cálculos que podemos hacer con R, hay algunas otras cosas que quiero señalar. Lo primero es que, si bien R es un buen software, sigue siendo software. Es bastante estúpido, y porque es estúpido no puede manejar errores tipográficos. Se necesita por fe que querías escribir exactamente lo que hiciste escribir. Por ejemplo, supongamos que olvidaste presionar la tecla Mayús al intentar escribir +, y como resultado tu comando terminó siendo 10 = 20 en lugar de 10 + 20. Esto es lo que sucede:

10 = 20
## Error in 10 = 20: invalid (do_set) left-hand side to assignment


Lo que ha pasado aquí es que R ha intentado interpretar 10 = 20 como un comando, y escupe un mensaje de error porque el comando no tiene ningún sentido para ello. Cuando un humano mira esto, y luego mira hacia abajo su teclado y ve que + y = están en la misma tecla, es bastante obvio que el comando era un error tipográfico. Pero R no lo sabe, así que se molesta. Y, si lo miras desde su perspectiva, esto tiene sentido. Todo lo que R “sabe” es que 10 es un número legítimo, 20 es un número legítimo, y = es una parte legítima del idioma también. En otras palabras, desde su perspectiva esto realmente parece que el usuario pretendía escribir 10 = 20, ya que todas las partes individuales de esa afirmación son legítimas y es demasiado estúpido para darse cuenta de que probablemente se trata de un error tipográfico. Por lo tanto, R toma con fe que esto es exactamente lo que quisiste decir... sólo “descubre” que el mandamiento es una tontería cuando trata de seguir tus instrucciones, error tipográfico y todo. Y luego lloriquea, y escupe un error.

Aún más sutil es el hecho de que algunos errores tipográficos no producirán ningún error, porque suceden que corresponden a comandos R “bien formados”. Por ejemplo, supongamos que no sólo me olvidé de presionar la tecla Mayús al intentar escribir 10 + 20, también logré presionar la tecla al lado de una que quise decir hacer. El error tipográfico resultante produciría el comando 10 - 20. Claramente, R no tiene forma de saber que querías sumar 20 a 10, no restar 20 de 10, entonces lo que pasa esta vez es esto:

10 - 20
## [1] -10


En este caso, R produce la respuesta correcta, pero a la pregunta equivocada.

Hasta cierto punto, estoy declarando lo obvio aquí, pero es importante. Las personas que escribieron R son inteligentes. Tú, el usuario, eres inteligente. Pero la R misma es tonta. Y porque es tonto, tiene que ser obediente sin pensar. Hace exactamente lo que le pides que haga. No hay equivalente a “autocorrección” en R, y por una buena razón. Al hacer cosas avanzadas —e incluso la estadística más simple es bastante avanzada de muchas maneras— es peligroso dejar que un autómata sin sentido como R intente invalidar al usuario humano. Pero debido a esto, es su responsabilidad tener cuidado. Siempre asegúrate de escribir exactamente a lo que te refieres. Cuando se trata de computadoras, no es suficiente escribir “aproximadamente” lo correcto. En general, absolutamente debes ser preciso en lo que le dices a R... como todas las máquinas es demasiado estúpido para ser otra cosa que absurdamente literal en su interpretación.

Por supuesto, ahora que he estado tan tensa ante la importancia de ser siempre precisos, debo señalar que hay algunas excepciones. O, con mayor precisión, hay algunas situaciones en las que R sí muestra un poco más de flexibilidad de lo que sugiere mi descripción anterior. Lo primero que R es lo suficientemente inteligente para hacer es ignorar el espaciado redundante. Lo que quiero decir con esto es que, cuando escribí 10 + 20 antes, igualmente podría haber hecho esto

10    + 20
## [1] 30

o esto

10+20
## [1] 30

y obtendría exactamente la misma respuesta. Sin embargo, eso no significa que puedas insertar espacios en cualquier lugar antiguo. Cuando miramos la documentación de inicio en la Sección 3.1.5 sugirió que se podría escribir citation () para obtener alguna información sobre cómo citar R. Si lo hago...

citation()
##
## To cite R in publications use:
##
##   R Core Team (2018). R: A language and environment for
##   statistical computing. R Foundation for Statistical Computing,
##   Vienna, Austria. URL https://www.R-project.org/.
##
## A BibTeX entry for LaTeX users is
##
##   @Manual{,
##     title = {R: A Language and Environment for Statistical Computing},
##     author = {{R Core Team}},
##     organization = {R Foundation for Statistical Computing},
##     year = {2018},
##     url = {https://www.R-project.org/},
##   }
##
## We have invested a lot of time and effort in creating R, please
## 'citation("pkgname")' for citing R packages.

... me dice citar el manual R (R Core Team 2013). Veamos qué pasa cuando intento cambiar el espaciado. Si inserto espacios entre la palabra y los paréntesis, o dentro de los paréntesis mismos, entonces todo está bien. Es decir, cualquiera de estos dos comandos

citation ()
citation(  )

producirá exactamente la misma respuesta. Sin embargo, lo que no puedo hacer es insertar espacios en medio de la palabra. Si trato de hacer esto, R se molesta:

citat ion()
## Error: <text>:1:7: unexpected symbol
## 1: citat ion
##           ^

A lo largo de este libro variaré un poco la forma en que uso el espaciado, solo para darle una idea de las diferentes formas en que se puede usar el espaciado. Sin embargo, intentaré no hacerlo demasiado, ya que generalmente se considera una buena práctica ser consistente en cómo formateas tus comandos.

a veces dicen que aún no has terminado (pero no a menudo)

Una cosa más debo señalar. Si pulsas enter en una situación en la que es “obvio” para R que en realidad no has terminado de escribir el comando, R es lo suficientemente inteligente como para seguir esperando. Por ejemplo, si escribes 10 + y luego presionas enter, incluso R es lo suficientemente inteligente como para darte cuenta de que probablemente querías escribir otro número. Así que esto es lo que sucede (con fines ilustrativos estoy rompiendo mis propias reglas de formato de código en esta sección):

> 10+
+ 

y hay un cursor parpadeante junto al signo más. Lo que esto significa es que R sigue esperando que termines. “piensa” que todavía estás escribiendo tu comando, así que aún no ha intentado ejecutarlo. En otras palabras, este signo más es en realidad otro símbolo del sistema. Es diferente al habitual (es decir, el símbolo >) para recordarte que R va a “agregar” lo que escribas ahora a lo que escribas la última vez. Por ejemplo, si luego voy a escribir 3 y pulso enter, lo que obtengo es esto:

> 10 +
+ 20
[1] 30

Y en lo que a R se refiere, esto es exactamente lo mismo que si hubieras escrito 10 + 20. De igual manera, consideremos el comando citation () del que hablamos en el apartado anterior. Supongamos que pulsa enter después de escribir citación (. Una vez más, R es lo suficientemente inteligente como para darse cuenta de que debe haber más por venir —ya que es necesario agregar el carácter) — por lo que espera. Incluso puedo golpear enter varias veces y va a seguir esperando:

> citation(
+
+
+ )

Voy a hacer mucho uso de esto en este libro. Muchos de los comandos que tendremos que escribir son bastante largos, y visualmente son un poco más fáciles de leer si los rompo en varias líneas. Si empiezas a hacer esto tú mismo, eventualmente te meterás en problemas (nos pasa a todos). A lo mejor empiezas a escribir un comando, y luego te das cuenta de que has metido la pata. Por ejemplo,

> citblation(
+
+ 


Probablemente preferirías que R no intente ejecutar este comando, ¿verdad? Si quieres salir de esta situación, sólo tienes que darle la tecla de 'escape'. 19 R le devolverá al símbolo del sistema normal (es decir, >) sin intentar ejecutar el comando falto.

Dicho esto, no suele darse el caso de que R sea lo suficientemente inteligente como para decir que vienen más. Por ejemplo, de la misma manera que no puedo agregar un espacio en medio de una palabra, tampoco puedo presionar enter en medio de una palabra. Si presiono enter después de escribir citat me sale un error, porque R piensa que me interesa un “objeto” llamado citat y no lo encuentro:

> citat
Error: object 'citat' not found

¿Y si escribí citación y golpeé enter? En este caso nos sale algo muy extraño, algo que definitivamente no queremos, al menos en esta etapa. Esto es lo que sucede:

> [citation]
function (package = "base", lib.loc = NULL, auto = NULL)
{
dir <- system.file(package = package, lib.loc = lib.loc)
if (dir == "")
BLAH BLAH BLAH
donde el BLAH BLAH BLAH pasa bastante tiempo, y todavía no sabes lo suficiente R para entender lo que significa realmente todo este galimatías (por supuesto, en realidad no dice BLAH BLAH BLAH - dice algunas otras cosas que no entendemos o necesitamos saber que he editado por largo) Esto la salida incomprensible puede ser bastante intimidante para los usuarios novatos, y desafortunadamente es muy fácil olvidarse de escribir los paréntesis; así que casi seguro que lo harás por accidente. No entres en pánico cuando esto sucede. Simplemente ignora el galimatías. A medida que tengas más experiencia este galimatías comenzará a tener sentido, y te resultará bastante útil imprimir estas cosas. 20 Pero por ahora solo intenta recordar agregar los paréntesis al escribir tus comandos.