s3.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# S3 {#s3}\n",
        "\n",
        "Es posible que haya notado que los resultados de su máquina tragamonedas no se ven como prometí. Sugerí que la máquina tragamonedas mostraría sus resultados así:\n",
        "\n",
        "```r\n",
        "play()\n",
        "## 0 0 DD\n",
        "## $0\n",
        "```\n",
        "\n",
        "Pero la máquina actual muestra sus resultados en un formato menos bonito:\n",
        "\n",
        "```r\n",
        "play()\n",
        "## \"0\"  \"0\" \"DD\" \n",
        "## 0\n",
        "```\n",
        "\n",
        "Además, la máquina tragamonedas usa un truco para mostrar símbolos (llamamos `print` desde dentro de `play`). Como resultado, los símbolos no siguen la salida de su premio si lo guarda:\n",
        "\n",
        "```r\n",
        "a_play <- play()\n",
        "## \"B\" \"0\" \"B\" \n",
        "\n",
        "a_play\n",
        "## 0\n",
        "```\n",
        "\n",
        "Puede solucionar ambos problemas con el sistema S3 de R.\n",
        "\n",
        "## El Sistema S3\n",
        "\n",
        "S3 se refiere a un sistema de clases integrado en R. El sistema rige cómo R maneja objetos de diferentes clases. Ciertas funciones de R buscarán la clase S3 de un objeto y luego se comportarán de manera diferente en respuesta.\n",
        "\n",
        "La función `print` es así. Cuando imprime un vector numérico, `print` mostrará un número:\n",
        "\n",
        "```r\n",
        "num <- 1000000000\n",
        "print(num)\n",
        "## 1000000000\n",
        "```\n",
        "\n",
        "Pero si le da ese número a la clase S3 `POSIXct` seguida de `POSIXt`, `print` mostrará una hora:\n",
        "\n",
        "```r\n",
        "class(num) <- c(\"POSIXct\", \"POSIXt\")\n",
        "print(num)\n",
        "## \"2001-09-08 19:46:40 CST\"\n",
        "```\n",
        "\n",
        "Si usa objetos con clases, y lo hace, se encontrará con el sistema S3 de R. El comportamiento de S3 puede parecer extraño al principio, pero es fácil de predecir una vez que se familiariza con él.\n",
        "\n",
        "El sistema S3 de R se basa en tres componentes: atributos (especialmente el atributo `class`), funciones genéricas y métodos.\n",
        "\n",
        "## Atributos\n",
        "\n",
        "En [Atributos](#attributes), aprendió que muchos objetos de R vienen con atributos, piezas de información adicional a las que se les da un nombre y se agregan al objeto. Los atributos no afectan los valores del objeto, pero se adhieren al objeto como un tipo de metadatos que R puede usar para manejar el objeto. Por ejemplo, un data frame almacena sus nombres de fila y columna como atributos. Los data frame también almacenan su clase, `\"data.frame\"`, como un atributo. \n",
        "\n",
        "Puede ver los atributos de un objeto con `attribute`. Si ejecuta `attribute` en el data frame `mazo` que creó en [Proyecto 2: Baraja de Cartas](#cards), verá:\n",
        "\n",
        "```r\n",
        "attributes(mazo)\n",
        "## $names\n",
        "## [1] \"cara\"  \"palo\"  \"valor\"\n",
        "## \n",
        "## $class\n",
        "## [1] \"data.frame\"\n",
        "## \n",
        "## $row.names\n",
        "##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 \n",
        "## [20] 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36\n",
        "## [37] 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52\n",
        "```\n",
        "\n",
        "R viene con muchas funciones auxiliares que le permiten establecer y acceder a los atributos más comunes utilizados en R. Ya conoce las funciones `names`, `dim` y `class`, cada una de las cuales funciona con un atributo con nombre homónimo. Sin embargo, R también tiene `row.names`, `levels` y muchas otras funciones auxiliares basadas en atributos. Puede utilizar cualquiera de estas funciones para recuperar el valor de un atributo:\n",
        "\n",
        "```r\n",
        "row.names(mazo)\n",
        "##  [1] \"1\"  \"2\"  \"3\"  \"4\"  \"5\"  \"6\"  \"7\"  \"8\"  \"9\"  \"10\" \"11\" \"12\" \"13\"\n",
        "## [14] \"14\" \"15\" \"16\" \"17\" \"18\" \"19\" \"20\" \"21\" \"22\" \"23\" \"24\" \"25\" \"26\"\n",
        "## [27] \"27\" \"28\" \"29\" \"30\" \"31\" \"32\" \"33\" \"34\" \"35\" \"36\" \"37\" \"38\" \"39\"\n",
        "## [40] \"40\" \"41\" \"42\" \"43\" \"44\" \"45\" \"46\" \"47\" \"48\" \"49\" \"50\" \"51\" \"52\"\n",
        "```\n",
        "\n",
        "o para cambiar el valor de un atributo:\n",
        "\n",
        "```r\n",
        "row.names(mazo) <- 101:152\n",
        "```\n",
        "\n",
        "o para dar a un objeto un atributo completamente nuevo:\n",
        "\n",
        "```r\n",
        "levels(mazo) <- c(\"level 1\", \"level 2\", \"level 3\")\n",
        "\n",
        "attributes(mazo)\n",
        "## $names\n",
        "## [1] \"cara\"  \"palo\"  \"valor\"\n",
        "## \n",
        "## $class\n",
        "## [1] \"data.frame\"\n",
        "## \n",
        "## $row.names\n",
        "##  [1] 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117\n",
        "## [18] 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134\n",
        "## [35] 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151\n",
        "## [52] 152\n",
        "## \n",
        "## $levels\n",
        "## [1] \"level 1\" \"level 2\" \"level 3\"\n",
        "```\n",
        "\n",
        "R es muy libre cuando se trata de atributos. Le permitirá agregar cualquier atributo que desee a un objeto (y luego generalmente los ignorará). La única vez que R se quejará es cuando una función necesita encontrar un atributo y no está allí.\n",
        "\n",
        "Puede agregar cualquier atributo general a un objeto con `attr`; también puede usar `attr` para buscar el valor de cualquier atributo de un objeto. Veamos cómo funciona esto con `a_play`, el resultado de jugar nuestra máquina tragamonedas una vez:\n",
        "\n",
        "```r\n",
        "a_play <- play()\n",
        "a_play\n",
        "## 0\n",
        "\n",
        "attributes(a_play)\n",
        "## NULL\n",
        "```\n",
        "\n",
        "`attr` toma dos argumentos: un objeto de R y el nombre de un atributo (como una cadena de caracteres). Para darle al objeto de R un atributo del nombre especificado, guarde un valor en la salida de `attr`. Démosle a `a_play` un atributo llamado `simbolos` que contiene un vector de cadenas de caracteres:\n",
        "\n",
        "```r\n",
        "attr(a_play, \"simbolos\") <- c(\"B\", \"0\", \"B\")\n",
        "\n",
        "attributes(a_play)\n",
        "## $simbolos\n",
        "## [1] \"B\" \"0\" \"B\"\n",
        "```\n",
        "\n",
        "Para buscar el valor de cualquier atributo, dale a `attr` un objeto R y el nombre del atributo que te gustaría buscar:\n",
        "\n",
        "```r\n",
        "attr(a_play, \"simbolos\")\n",
        "## \"B\" \"0\" \"B\"\n",
        "```\n",
        "\n",
        "Si asigna un atributo a un vector atómico, como `a_play`, R generalmente mostrará el atributo debajo de los valores del vector. Sin embargo, si el atributo cambia la clase del vector, R puede mostrar toda la información en el vector de una nueva forma (como vimos con los objetos `POSIXct`):\n",
        "\n",
        "```r\n",
        "a_play\n",
        "## [1] 0\n",
        "## attr(,\"simbolos\")\n",
        "## [1] \"B\" \"0\" \"B\"\n",
        "```\n",
        "\n",
        "R generalmente ignorará los atributos de un objeto a menos que le des un nombre que busca una función de R, como `names` o `class`. Por ejemplo, R ignorará el atributo `simbolos` de `a_play` mientras manipulas `a_play`:\n",
        "\n",
        "```r\n",
        "a_play + 1\n",
        "##  1\n",
        "## attr(,\"simbolos\")\n",
        "##  \"B\" \"0\" \"B\"\n",
        "```\n",
        "\n",
        "\n",
        "**Ejercicio 11.1 (Añade un Atributo)** Modifique `play` para devolver un premio que contenga los símbolos asociados a él como un atributo denominado `simbolos`. Elimine la llamada redundante a `print(simbolos)`:\n",
        "\n",
        "```r\n",
        "play <- function() {\n",
        "  simbolos <- obt_simbolos()\n",
        "  print(simbolos)\n",
        "  puntuacion(simbolos)\n",
        "}\n",
        "```\n",
        "\n",
        "\n",
        "```{solution}\n",
        "Puede crear una nueva versión de `play` capturando la salida de `puntuacion(simbolos)` y asignándole un atributo. `play` puede devolver la versión mejorada de la salida:\n",
        "```\n",
        "\n",
        "  \n",
        "```r\n",
        "play <- function() {\n",
        "  simbolos <- obt_simbolos()\n",
        "  premio <- puntuacion(simbolos)\n",
        "  attr(premio, \"simbolos\") <- simbolos\n",
        "  premio\n",
        "}\n",
        "```\n",
        "\n",
        "Ahora `play` devuelve tanto el premio como los símbolos asociados con el premio. Puede que los resultados no se vean bonitos, pero los símbolos se quedan con el premio cuando lo copiamos a un nuevo objeto. Podemos trabajar en ordenar la pantalla en un minuto:\n",
        "\n",
        "```r\n",
        "play()\n",
        "## [1] 0\n",
        "## attr(,\"simbolos\")\n",
        "## [1] \"B\"  \"BB\" \"0\" \n",
        " \n",
        "b_play <- play()\n",
        " \n",
        "b_play\n",
        "## [1] 0\n",
        "## attr(,\"simbolos\")\n",
        "## [1] \"0\" \"B\" \"0\"\n",
        "```\n",
        "\n",
        "También puede generar un premio y establecer sus atributos en un solo paso con la función `structure`. `structure` crea un objeto con un conjunto de atributos. El primer argumento de `structure` debe ser un objeto de R o un conjunto de valores, y los argumentos restantes deben ser atributos con nombre para que `structure` se agregue al objeto. Puede dar a estos argumentos cualquier nombre de argumento que desee. `structure` agregará los atributos al objeto bajo los nombres que proporcione como nombres de argumento:\n",
        "\n",
        "```r\n",
        "play <- function() {\n",
        "  simbolos <- get_simbolos()\n",
        "  structure(puntuacion(simbolos), simbolos = simbolos)\n",
        "}\n",
        "\n",
        "c_play <- play()\n",
        "c_play\n",
        "##  0\n",
        "##  attr(,\"simbolos\")\n",
        "##  \"0\"  \"BB\" \"B\" \n",
        "```\n",
        "\n",
        "Ahora que su salida `play` contiene un atributo `simbolos`, ¿qué puede hacer con él? Puede escribir sus propias funciones que busquen y usen el atributo. Por ejemplo, la siguiente función buscará el atributo `simbolos` de `a_play` y lo usará para mostrar `a_play` de una manera bonita. Usaremos esta función para mostrar los resultados de nuestra tragamonedas, así que tomemos un momento para estudiar lo que hace:\n",
        "\n",
        "```r\n",
        "mostrat_tragamoneda <- function(premio){\n",
        "\n",
        "  # extraer simbolos\n",
        "  simbolos <- attr(premio, \"simbolos\")\n",
        "\n",
        "  # colapsar símbolos en una sola cadena de caracteres\n",
        "  simbolos <- paste(simbolos, collapse = \" \")\n",
        "\n",
        "  # combinar símbolo con premio como una cadena de caracteres\n",
        "  # \\n es una secuencia de escape especial para una nueva línea (i.e. return or enter)\n",
        "  texto <- paste(simbolos, premio, sep = \"\\n$\")\n",
        "\n",
        "  # mostrar cadena de caracteres en la consola sin comillas\n",
        "  cat(texto)\n",
        "}\n",
        "\n",
        "mostrat_tragamoneda(a_play)\n",
        "## B 0 B\n",
        "## $0\n",
        "```\n",
        "\n",
        "La función espera un objeto como `a_play` que tiene tanto un valor numérico como un atributo de `simbolos`. La primera línea de la función buscará el valor del atributo `simbolos` y lo guardará como un objeto llamado `simbolos`. Hagamos un objeto `simbolos` de ejemplo para que podamos ver lo que hace el resto de la función. Podemos usar el atributo `simbolos` de `a_play` para hacer el trabajo. `simbolos` será un vector de cadenas de tres caracteres: \n",
        "\n",
        "```r\n",
        "simbolos <- attr(a_play, \"simbolos\")\n",
        "\n",
        "simbolos\n",
        "## \"B\" \"0\" \"B\"\n",
        "```\n",
        "\n",
        "A continuación, `mostrat_tragamoneda` usa `paste` para colapsar las tres cadenas en `simbolos` en una cadena de un solo carácter. `paste` colapsa un vector de cadenas de caracteres en una sola cadena cuando le das el argumento `collapse`. `paste` usará el valor de `collapse` para separar las cadenas anteriormente distintas. Por lo tanto, `simbolos` se convierte en `B 0 B` las tres cadenas separadas por un espacio:\n",
        "\n",
        "```r\n",
        "simbolos <- paste(simbolos, collapse = \" \")\n",
        "\n",
        "simbolos\n",
        "## \"B 0 B\"\n",
        "```\n",
        "\n",
        "Nuestra función luego usa `paste` de una nueva forma para combinar `simbolos` con el valor de `premio`. `paste` combina objetos separados en una cadena de caracteres cuando le das un argumento `sep`. Por ejemplo, aquí `paste` combinará la cadena en `simbolos`, `B 0 B`, con el número en `premio`, 0. `paste` usará el valor del argumento `sep` para separar las entradas en el cadena nueva. Aquí, ese valor es `\\n$`, por lo que nuestro resultado se verá como `\"B 0 B\\n$0\"`:\n",
        "\n",
        "```r\n",
        "premio <- a_play\n",
        "texto <- paste(simbolos, premio, sep = \"\\n$\")\n",
        "\n",
        "texto\n",
        "## \"B 0 B\\n$0\"\n",
        "```\n",
        "\n",
        "La última línea de `mostrat_tragamoneda` llama a `cat` en la nueva cadena. `cat` es como `print`; muestra su entrada en la línea de comando. Sin embargo, `cat` no encierra su salida entre comillas. `cat` también reemplaza cada `\\n` con una nueva línea o salto de línea. El resultado es lo que vemos. Tenga en cuenta que se ve exactamente como sugerí que nuestra salida `play` debería verse en [Programas](#programs):\n",
        "\n",
        "```r\n",
        "cat(texto)\n",
        "## B 0 B\n",
        "## $0\n",
        "```\n",
        "\n",
        "Puedes usar `mostrat_tragamoneda` para limpiar manualmente la salida de `play`:\n",
        "\n",
        "```r\n",
        "mostrat_tragamoneda(play())\n",
        "## C B 0\n",
        "## $2\n",
        "\n",
        "mostrat_tragamoneda(play())\n",
        "## 7 0 BB\n",
        "## $0\n",
        "```\n",
        "\n",
        "Este método de limpieza de la salida requiere que intervengas manualmente en tu sesión de R (para llamar a `mostrat_tragamoneda`). Hay una función que puede usar para limpiar automáticamente la salida de `play` cada vez que se muestra. Esta función es `print`, y es una _función genérica_.\n",
        "\n",
        "## Funciones Genéricas\n",
        "\n",
        "R usa `print` con más frecuencia de lo que piensas; R llama a `print` cada vez que muestra un resultado en la ventana de su consola. Esta llamada ocurre en segundo plano, por lo que no la nota; pero la llamada explica cómo la salida llega a la ventana de la consola (recuerde que `print` siempre imprime su argumento en la ventana de la consola). Esta llamada `print` también explica por qué la salida de `print` siempre coincide con lo que ve cuando muestra un objeto en la línea de comando:\n",
        "\n",
        "```r\n",
        "print(pi)\n",
        "## 3.141593\n",
        "\n",
        "pi\n",
        "## 3.141593\n",
        "\n",
        "\n",
        "print(head(mazo))\n",
        "##  cara  palo valor\n",
        "##   rey picas    13\n",
        "## reina picas    12\n",
        "##  jota picas    11\n",
        "##  diez picas    10\n",
        "## nueve picas     9\n",
        "##  ocho picas     8\n",
        "\n",
        "head(mazo)\n",
        "##  cara  palo valor\n",
        "##   rey picas    13\n",
        "## reina picas    12\n",
        "##  jota picas    11\n",
        "##  diez picas    10\n",
        "## nueve picas     9\n",
        "##  ocho picas     8\n",
        "\n",
        "\n",
        "print(play())\n",
        "##  5\n",
        "## attr(,\"simbolos\")\n",
        "##  \"B\"  \"BB\" \"B\" \n",
        "\n",
        "play()\n",
        "##  5\n",
        "## attr(,\"simbolos\")\n",
        "##  \"B\"  \"BB\" \"B\" \n",
        "```\n",
        "\n",
        "Puede cambiar la forma en que R muestra la salida de su maquina tragamonedas reescribiendo `print` para que se vea como `mostrat_tragamoneda`. Entonces R mostraría la salida en el formato que hemos creado. Sin embargo, este método tendría efectos secundarios negativos. No desea que R llame a `mostrat_tragamoneda` cuando muestre un data frame, un vector numérico o cualquier otro objeto.\n",
        "\n",
        "Afortunadamente, `print` no es una función normal; es una función _genérica_. Esto significa que `print` está escrito de una manera que le permite hacer cosas diferentes en casos diferentes. Ya has visto este comportamiento en acción (aunque es posible que no te hayas dado cuenta). `print` hizo una cosa cuando miramos la versión sin clase de `num`:\n",
        "\n",
        "```r\n",
        "num <- 1000000000\n",
        "print(num)\n",
        "## 1000000000\n",
        "```\n",
        "\n",
        "y una cosa diferente cuando le dimos a `num` una clase:\n",
        "\n",
        "```r\n",
        "class(num) <- c(\"POSIXct\", \"POSIXt\")\n",
        "print(num)\n",
        "## \"2001-09-08 19:46:40 CST\"\n",
        "```\n",
        "\n",
        "Eche un vistazo al código dentro de `print` para ver cómo lo hace. Puede imaginar que print busca el atributo de clase de su entrada y luego usa un árbol +if+ para elegir qué salida mostrar. Si esto te ocurrió, ¡buen trabajo! `print` hace algo muy similar, pero mucho más simple. \n",
        "\n",
        "## Métodos\n",
        "\n",
        "Cuando llamas a `print`, `print` llama a una función especial, `UseMethod`: \n",
        "\n",
        "```r\n",
        "print\n",
        "## function (x, ...) \n",
        "## UseMethod(\"print\")\n",
        "## <bytecode: 0x7ffee4c62f80>\n",
        "## <environment: namespace:base>\n",
        "```\n",
        "\n",
        "`UseMethod` examina la clase de la entrada que proporcionas para el primer argumento de `print` y luego pasa todos tus argumentos a una nueva función diseñada para manejar esa clase de entrada. Por ejemplo, cuando le das a `print` un objeto POSIXct, `UseMethod` pasará todos los argumentos de `print` a `print.POSIXct`. R luego ejecutará `print.POSIXct` y devolverá los resultados:\n",
        "\n",
        "```r\n",
        "print.POSIXct\n",
        "## function (x, ...) \n",
        "## {\n",
        "##     max.print <- getOption(\"max.print\", 9999L)\n",
        "##     if (max.print < length(x)) {\n",
        "##         print(format(x[seq_len(max.print)], usetz = TRUE), ...)\n",
        "##         cat(\" [ reached getOption(\\\"max.print\\\") -- omitted\", \n",
        "##             length(x) - max.print, \"entries ]\\n\")\n",
        "##     }\n",
        "##     else print(format(x, usetz = TRUE), ...)\n",
        "##     invisible(x)\n",
        "## }\n",
        "## <bytecode: 0x7fa948f3d008>\n",
        "## <environment: namespace:base>\n",
        "```\n",
        "\n",
        "Si le das a `print` un objeto de factor, `UseMethod` pasará todos los argumentos de `print` a `print.factor`. R luego ejecutará `print.factor` y devolverá los resultados:\n",
        "\n",
        "```r\n",
        "print.factor\n",
        "## function (x, quote = FALSE, max.levels = NULL, width = getOption(\"width\"), \n",
        "##     ...) \n",
        "## {\n",
        "##     ord <- is.ordered(x)\n",
        "##     if (length(x) == 0L) \n",
        "##         cat(if (ord) \n",
        "##             \"ordered\"\n",
        "## ...\n",
        "##         drop <- n > maxl\n",
        "##         cat(if (drop) \n",
        "##             paste(format(n), \"\"), T0, paste(if (drop) \n",
        "##             c(lev[1L:max(1, maxl - 1)], \"...\", if (maxl > 1) lev[n])\n",
        "##         else lev, collapse = colsep), \"\\n\", sep = \"\")\n",
        "##     }\n",
        "##     invisible(x)\n",
        "## }\n",
        "## <bytecode: 0x7fa94a64d470>\n",
        "## <environment: namespace:base>\n",
        "```\n",
        "\n",
        "`print.POSIXct` y `print.factor` se denominan _métodos_ de `print`. Por sí mismos, `print.POSIXct` y `print.factor` funcionan como funciones regulares de R. Sin embargo, cada uno fue escrito específicamente para que 'UseMethod' pudiera llamarlo para manejar una clase específica de entrada de `print`.\n",
        "\n",
        "Tenga en cuenta que `print.POSIXct` y `print.factor` hacen dos cosas diferentes (también tenga en cuenta que compendié la mitad de `print.factor`: es una función larga). Así es como `print` se las arregla para hacer diferentes cosas en diferentes casos. `print` llama a `UseMethod`, que llama a un método especializado basado en la clase del primer argumento de `print`. \n",
        "\n",
        "Puede ver qué métodos existen para una función genérica llamando a `methods` en la función. Por ejemplo, `print` tiene casi 200 métodos (lo que le da una idea de cuántas clases existen en R):\n",
        "\n",
        "```r\n",
        "methods(print)\n",
        "##   [1] print.acf*                                   \n",
        "##   [2] print.anova                                  \n",
        "##   [3] print.aov*                                   \n",
        "##  ...                      \n",
        "## [176] print.xgettext*                              \n",
        "## [177] print.xngettext*                             \n",
        "## [178] print.xtabs*\n",
        "##\n",
        "##  Nonvisible functions are asterisked\n",
        "```\n",
        "\n",
        "Este sistema de funciones genéricas, métodos y despacho basado en clases se conoce como S3 porque se originó en la tercera versión de S, el lenguaje de programación que se convertiría en S-PLUS y R. Muchas funciones comunes de R son genéricas de S3 que funcionan con un conjunto de métodos de clase. Por ejemplo, `summary` y `head` también llaman a `UseMethod`. Las funciones más básicas, como `c`, `+`, `-`, `<` y otras también se comportan como funciones genéricas, aunque llaman a `.primitive` en lugar de `UseMethod`.\n",
        "\n",
        "El sistema S3 permite que las funciones de R se comporten de diferentes maneras para diferentes clases. Puede usar S3 para formatear la salida de su tragamonedas. Primero, dé a su salida su propia clase. Luego escriba un método de impresión para esa clase. Para hacer esto de manera eficiente, necesitará saber un poco acerca de cómo `UseMethod` selecciona una función de método para usar.\n",
        "\n",
        "### Selección de Método\n",
        "\n",
        "`UseMethod` utiliza un sistema muy simple para emparejar métodos con funciones. \n",
        "\n",
        "Cada método S3 tiene un nombre de dos partes. La primera parte del nombre se referirá a la función con la que trabaja el método. La segunda parte se referirá a la clase. Estas dos partes estarán separadas por un punto. Entonces, por ejemplo, el método de `print` que funciona con funciones se llamará `print.function`. El método de `summary` que trabaja con matrices se llamará `summary.matrix`. Y así sucesivamente.\n",
        "\n",
        "Cuando `UseMethod` necesita llamar a un método, busca una función de R con el nombre de estilo S3 correcto. La función no tiene que ser especial de ninguna manera; solo necesita tener el nombre correcto. \n",
        "\n",
        "Puede participar en este sistema escribiendo su propia función y dándole un nombre de estilo S3 válido. Por ejemplo, demos a `a_play` una clase propia. No importa cómo llames a la clase; R almacenará cualquier cadena de caracteres en el atributo de clase:\n",
        "\n",
        "```r\n",
        "class(a_play) <- \"tragamonedas\"\n",
        "```\n",
        "\n",
        "Ahora escribamos un método de impresión S3 para la clase +tragamonedas+. El método no necesita hacer nada especial, ni siquiera necesita imprimir `a_play`. Pero _sí_ necesita llamarse `print.tragamonedas`; de lo contrario, `UseMethod` no lo encontrará. El método también debería tomar los mismos argumentos que `print`; de lo contrario, R dará un error cuando intente pasar los argumentos a `print.tragamonedas`:\n",
        "\n",
        "```r\n",
        "args(print)\n",
        "## function (x, ...) \n",
        "## NULL\n",
        "\n",
        "print.tragamonedas <- function(x, ...) {\n",
        "  cat(\"Estoy usando el método print.tragamonedas\")\n",
        "}\n",
        "```\n",
        "\n",
        "¿Funciona nuestro método? Sí, y no solo eso; R usa el método de impresión para mostrar el contenido de `a_play`. Este método no es muy útil, así que voy a eliminarlo. Tendrás la oportunidad de escribir uno mejor en un minuto:\n",
        "\n",
        "```r\n",
        "print(a_play)\n",
        "## Estoy usando el método print.tragamonedas\n",
        "\n",
        "a_play\n",
        "## Estoy usando el método print.tragamonedas\n",
        "\n",
        "rm(print.tragamonedas)\n",
        "```\n",
        "\n",
        "Algunos objetos de R tienen múltiples clases. Por ejemplo, la salida de `Sys.time` tiene dos clases. ¿Qué clase usará `UseMethod` para encontrar un método de impresión?\n",
        "\n",
        "```r\n",
        "ahora <- Sys.time()\n",
        "attributes(ahora)\n",
        "## $class\n",
        "## [1] \"POSIXct\" \"POSIXt\" \n",
        "```\n",
        "\n",
        "`UseMethod` primero buscará un método que coincida con la primera clase listada en el vector de clase del objeto. Si `UseMethod` no puede encontrar uno, buscará el método que coincida con la segunda clase (y así sucesivamente si hay más clases en el vector de clase de un objeto).\n",
        "\n",
        "Si le das a `print` un objeto cuya clase o clases no tienen un método de impresión, `UseMethod` llamará a `print.default`, un método especial escrito para manejar casos generales.\n",
        "\n",
        "Usemos este sistema para escribir un mejor método de impresión para la salida de la máquina tragamonedas.\n",
        "\n",
        "Ejercicio 11.2 (Hacer un Método de print) Escriba un nuevo método de print para la clase de tragamonedas. El método debería llamar a `mostrat_tragamoneda` para devolver una salida de máquina tragamonedas bien formateada.\n",
        "\n",
        "¿Qué nombre debe usar para este método?\n",
        "\n",
        "\n",
        "```{solution}\n",
        "Es sorprendentemente fácil escribir un buen método `print.tragamonedas` porque ya hicimos todo el trabajo duro cuando escribimos `mostrat_tragamoneda`. Por ejemplo, el siguiente método funcionará. Solo asegúrese de que el método se llame `print.tragamonedas` para que `UseMethod` pueda encontrarlo, y asegúrese de que toma los mismos argumentos que `print` para que `UseMethod` pueda pasar esos argumentos a `print.tragamonedas` sin ningún problema: \n",
        "```\n",
        "\n",
        "\n",
        "```r\n",
        "print.tragamonedas <- function(x, ...) {\n",
        "  mostrat_tragamoneda(x)\n",
        "}\n",
        "```\n",
        "\n",
        "Ahora R usará automáticamente `mostrat_tragamoneda` para mostrar objetos de clase +tragamonedas+ (y solo objetos de clase \"tragamonedas\"):\n",
        "\n",
        "```r\n",
        "a_play\n",
        "## B 0 B\n",
        "## $0\n",
        "```\n",
        "\n",
        "Asegurémonos de que cada salida de la máquina tragamonedas tenga la clase `tragamonedas`.\n",
        "\n",
        "**Ejercicio 11.3 (Añadir una Clase)** Modifique la función `play` para que asigne `tragamonedas` al atributo `class` de su salida:\n",
        "\n",
        "```r\n",
        "play <- function() {\n",
        "  simbolos <- get_simbolos()\n",
        "  structure(puntuacion(simbolos), simbolos = simbolos)\n",
        "}\n",
        "```\n",
        "\n",
        "\n",
        "```{solution}\n",
        "Puede establecer el atributo `class` de la salida al mismo tiempo que establece el atributo +simbolos+. Simplemente agregue `class = \"tragamonedas\"` a la llamada `structure`:\n",
        "```\n",
        "\n",
        "\n",
        "```r\n",
        "play <- function() {\n",
        "  simbolos <- get_simbolos()\n",
        "  structure(puntuacion(simbolos), simbolos = simbolos, class = \"tragamonedas\")\n",
        "}\n",
        "```\n",
        "\n",
        "Ahora cada uno de nuestras salidas de `play` tendrá la clase `tragamonedas`:\n",
        "\n",
        "```r\n",
        "class(play())\n",
        "## \"tragamonedas\"\n",
        "```\n",
        "\n",
        "Como resultado, R los mostrará en el formato de máquina tragamonedas correcto:\n",
        "\n",
        "```r\n",
        "play()\n",
        "## BB BB BBB\n",
        "## $5\n",
        "\n",
        "play()\n",
        "## BB 0 0\n",
        "## $0\n",
        "```\n",
        "\n",
        "## Clases\n",
        "\n",
        "Puede usar el sistema S3 para crear una nueva clase sólida de objetos en R. Luego, R tratará los objetos de su clase de manera consistente y sensata. Para hacer una clase:\n",
        "\n",
        "* Elija un nombre para su clase.\n",
        "* Asigne a cada instancia de su clase un atributo +class+.\n",
        "* Escriba métodos de clase para cualquier función genérica que pueda usar objetos de su clase.\n",
        "\n",
        "Muchos paquetes de R se basan en clases que se han creado de manera similar. Si bien este trabajo es simple, puede que no sea fácil. Por ejemplo, considere cuántos métodos existen para clases predefinidas.\n",
        "\n",
        "Puede llamar a `methods` en una clase con el argumento `class`, que toma una cadena de caracteres. `methods` devolverá todos los métodos escritos para la clase. Tenga en cuenta que `methods` no podrá mostrarle los métodos que vienen en un paquete R descargado:\n",
        "\n",
        "```r\n",
        "methods(class = \"factor\")\n",
        "##  [1] [.factor             [[.factor           \n",
        "##  [3] [[<-.factor          [<-.factor          \n",
        "##  [5] all.equal.factor     as.character.factor \n",
        "##  [7] as.data.frame.factor as.Date.factor      \n",
        "##  [9] as.list.factor       as.logical.factor   \n",
        "## [11] as.POSIXlt.factor    as.vector.factor    \n",
        "## [13] droplevels.factor    format.factor       \n",
        "## [15] is.na<-.factor       length<-.factor     \n",
        "## [17] levels<-.factor      Math.factor         \n",
        "## [19] Ops.factor           plot.factor*        \n",
        "## [21] print.factor         relevel.factor*     \n",
        "## [23] relist.factor*       rep.factor          \n",
        "## [25] summary.factor       Summary.factor      \n",
        "## [27] xtfrm.factor        \n",
        "## \n",
        "##    Nonvisible functions are asterisked\n",
        "```\n",
        "\n",
        "Esta salida indica cuánto trabajo se requiere para crear una clase robusta y de buen comportamiento. Por lo general, necesitará escribir un método de `class` para cada operación básica de R. \n",
        "\n",
        "Considere dos desafíos que enfrentará de inmediato. Primero, R descarta atributos (como `class`) cuando combina objetos en un vector:\n",
        "\n",
        "```r\n",
        "play1 <- play()\n",
        "play1\n",
        "## B BBB BBB\n",
        "## $5\n",
        "\n",
        "play2 <- play()\n",
        "play2\n",
        "## 0 B 0\n",
        "## $0\n",
        "\n",
        "c(play1, play2)\n",
        "## [1] 5 0\n",
        "```\n",
        "\n",
        "Aquí, R deja de usar `print.tragamonedas` para mostrar el vector porque el vector `c(play1, play2)` ya no tiene un atributo +class+ \"tragamonedas\".\n",
        "\n",
        "A continuación, R eliminará los atributos de un objeto (como `class`) cuando subjunte el objeto:\n",
        "\n",
        "```r\n",
        "play1[1]\n",
        "## [1] 5\n",
        "```\n",
        "\n",
        "Puede evitar este comportamiento escribiendo un método `c.tragamonedas` y un método `[.tragamonedas`, pero luego se acumularán dificultades rápidamente. ¿Cómo combinaría los atributos de `simbolos` de múltiples jugadas en un vector de atributos de símbolos? ¿Cómo cambiarías `print.tragamonedas` para manejar vectores de salidas? Estos desafíos están abiertos para que los explores. Sin embargo, normalmente no tendrá que intentar este tipo de programación a gran escala como científico de datos.\n",
        "\n",
        "En nuestro caso, es muy útil dejar que los objetos `tragamonedas` vuelvan a tener valores de premios únicos cuando combinamos grupos de ellos en un vector.\n",
        "\n",
        "## S3 y Depuración\n",
        "\n",
        "S3 puede ser molesto si está tratando de comprender las funciones de R. Es difícil saber qué hace una función si su cuerpo de código contiene una llamada a `UseMethod`. Ahora que sabe que `UseMethod` llama a un método específico de clase, puede buscar y examinar el método directamente. Será una función cuyo nombre siga la sintaxis `<function.class>`, o posiblemente `<function.default>`. También puede usar la función `methods` para ver qué métodos están asociados con una función o una clase.\n",
        "\n",
        "## S4 y R5\n",
        "\n",
        "R también contiene otros dos sistemas que crean un comportamiento específico de clase. Estos se conocen como S4 y R5 (o clases de referencia). Cada uno de estos sistemas es mucho más difícil de usar que S3 y quizás, como consecuencia, más raro. Sin embargo, ofrecen garantías que S3 no ofrece. Si desea obtener más información sobre estos sistemas, incluido cómo escribir y usar sus propias funciones genéricas, le recomiendo el libro [_Advanced R Programming_](http://adv-r.had.co.nz/) de Hadley Wickham.\n",
        "\n",
        "## Resumen\n",
        "\n",
        "Los valores no son el único lugar para almacenar información en R, y las funciones no son la única forma de crear un comportamiento único. También puede hacer ambas cosas con el sistema S3 de R. El sistema S3 proporciona una forma sencilla de crear comportamientos específicos de objetos en R. En otras palabras, es la versión de programación orientada a objetos (OOP) de R. El sistema se implementa mediante funciones genéricas. Estas funciones examinan el atributo de clase de su entrada y llaman a un método específico de clase para generar salida. Muchos métodos de S3 buscarán y utilizarán información adicional que se almacena en los atributos de un objeto. Muchas funciones comunes de R son genéricas de S3.\n",
        "\n",
        "El sistema S3 de R es más útil para las tareas de informática que para las tareas de ciencia de datos, pero comprender S3 puede ayudarlo a solucionar problemas en su trabajo en R como científico de datos\n",
        "\n",
        "Ahora sabe bastante sobre cómo escribir código de R que realiza tareas personalizadas, pero ¿cómo podría repetir estas tareas? Como científico de datos, a menudo repetirá tareas, a veces miles o incluso millones de veces. ¿Por qué? Porque la repetición te permite simular resultados y estimar probabilidades. [Bucles](#loops) te mostrará cómo automatizar la repetición con las funciones `for` y `while` de R. Usará `for` para simular varios juegos de máquinas tragamonedas y para calcular la tasa de pago de su máquina tragamonedas."
      ],
      "id": "2c38664a"
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}