Curso
Programación orientada a objetos con S3 y R6 en R
4 h
23.6K
La programación orientada a objetos (OOP) es un paradigma de programación en el que se diseña el software en torno a datos u objetos, en lugar de funciones. Un método no deja de ser una función, pero en el contexto de la OOP. Es orientada a objetos porque todo el procesamiento gira en torno a los objetos y sus campos. Cada objeto tiene distintos atributos y comportamientos.
En la programación orientada a objetos, el programa completo puede dividirse en diferentes clases para entender más fácilmente su ejecución. R es un lenguaje de programación funcional, y la OOP ayuda a gestionar problemas de sistemas grandes. La OOP se usa para gestionar aplicaciones con interfaz gráfica (GUI), especialmente aplicaciones web. La programación orientada a objetos es buena para crear herramientas de análisis de datos, pero no tanto para el análisis de datos en sí.
Sistemas de OOP
Principalmente hay dos sistemas de OOP, que se describen a continuación:
- Clases S3: Permiten sobrecargar funciones.
- Clases S4: Permiten acotar los datos, ya que el programa puede ser más difícil de depurar.
Nota: Estas clases se tratarán en detalle más adelante.
Objetos en R
Los objetos son instancias de una clase. Además, en R todo es un objeto; para saber más, consulta Data types in R. También pueden tener atributos como class, attributes, dimnames, names, etc.
Por ejemplo, a los objetos se les asigna un valor usando <-, fíjate en el siguiente fragmento donde "a1" y "a2" son variables a las que se asignan valores numéricos.
a1 <- 10
a2 <- 20
A un objeto se le puede asignar un conjunto de números; "a3" es un objeto que contiene un vector de distintos números.
a3 <- c(10,20,30)
Aquí c agrupa los números 10, 20 y 30 en un vector.
Veamos un ejemplo real como un estudiante, que tiene atributos como nombre, edad, curso y género; el profesor tiene nombre, edad y género.
st_name <- "andrew"
st_age <- 16
st_class <- 10
st_gender <- "male"
t_name <- "angelina"
t_age <- 26
t_gender <- "female"
student <- c(st_name, st_age, st_class, st_gender)
teacher <- c(t_name, t_age, t_gender)
print(student)
print(teacher)
[1] "andrew" "16" "10" "male"
[1] "angelina" "26" "female" El código anterior devuelve la siguiente salida:
"andrew" "16" "10" "male"
"angelina" "26" "female"En el código de arriba puedes ver un ejemplo con distintos tipos de objetos. Los objetos "student" y "teacher", también llamados variables, contienen tipos "character" y "double".
Domina tus habilidades de datos con DataCamp
Más de 10 millones de personas aprenden Python, R, SQL y otras habilidades tecnológicas con nuestros cursos prácticos elaborados por expertos del sector.
Clase en R
Una clase es el plano que sirve para crear un objeto y contiene sus variables miembro junto con los atributos.
Como se comentó antes, en R hay dos clases: S3 y S4.
Clase S3
Estas clases permiten sobrecargar funciones separándolas en genéricas y métodos.
funciones = genéricas + métodos
S3 es muy diferente de otros lenguajes como C#, Java, etc. Como su implementación es sencilla, usa solo el primer argumento para el envío de métodos (dispatch). Por eso no requiere demasiados conocimientos desde la perspectiva de quien programa.
S3 funciona definiendo una convención estricta de nombres del tipo genérico.punto.clase.
generic.class
Los argumentos de los métodos deben incluir los argumentos de la genérica, y el método debe incluir un ...arg.
Construcción y ejemplo de clase S3
A continuación verás cómo construir una clase S3 con un ejemplo que crea una lista en la que se pasan componentes, se asigna un nombre de clase adecuado y se imprime el resultado.
En el siguiente ejemplo, "studentBio" contiene una lista en la que se pasan como lista los componentes "student_name", "student_age" y "student_contact". La clase se llama "Student Info" y "studentBio" es la clase recién creada cuyos valores se muestran debajo.
studentBio <- list(studentName = "Harry Potter", studentAge = 19, studentContact="London")
class(studentBio) <- "StudentInfo"
studentBio
$studentName
[1] "Harry Potter"
$studentAge
[1] 19
$studentContact
[1] "London"
attr(,"class")
[1] "StudentInfo"El código anterior produce la siguiente salida:
$studentName
"Harry Potter"
$studentAge
19
$studentContact
"London"
attr(,"class")
"StudentInfo"Si no te sientes cómodo escribiendo funciones en R, lee A Tutorial on Using Functions in R!
Crea tu propia función genérica en S3
Vas a implementar tu función genérica usando el siguiente código.
El código de abajo define la función genérica llamada "contact", donde se le pasa un objeto. Además, se usa "UseMethod" con la función genérica "contact", donde se realiza el "dispatch" del método: el proceso por el que el resultado varía según los argumentos pasados.
contact <- function(object) {
UseMethod("contact")
}
Vamos a crear un método para la clase que creaste antes, llamada "StudentInfo". Se usa el método "contact" seguido de notación con punto junto con la clase "StudentInfo"; el cuerpo de la función accede al atributo "studentContact" usando "$".
contact.StudentInfo <- function(object) {
cat("Your contact is", object$studentContact, "\n")
}
contact(studentBio)
Your contact is London
El código anterior usa object$studentContact, donde el objeto se pasa como argumento a la función y con "$" se accede al atributo "studentContact", lo que da como resultado la siguiente salida.
Your contact is London
Clase S4
La clase S4 es más estricta, convencional y cercana a los conceptos de orientación a objetos. Las clases se representan mediante definiciones formales de clase de S4. En concreto, S4 tiene funciones setter y getter para métodos y genéricas. En comparación con S3, S4 permite facilitar el envío múltiple (multiple dispatch).
Veamos estas clases de R creándolas y comentándolas con un ejemplo.
Una clase S4 se define usando la función setClass.
setClass()Construcción y ejemplo de clase S4
Como se ha comentado, la clase S4 se define con el método setClass(). Usarás setClass() para crear y definir la clase S4. Utilizaremos una subrutina para verificar que los datos sean coherentes (validación) y también establecer los valores por defecto (el prototipo).
Este es el código para definir la clase y sus slots:
A continuación se define una clase, también llamada "prototype", donde se especifican los slots: el nombre de la clase es "employee"; name es character, id es numeric y contact es character.
setClass("employee", slots=list(name="character", id="numeric", contact="character"))
El siguiente código crea instancias u objetos concretos de S4.
Vamos a crear un objeto usando "new" con el nombre de clase "employee", y completar los slots name, id y contact con un valor.
obj <- new("employee",name="Steven", id=1002, contact="West Avenue")
obj
Un objeto de clase "employee"
Slot "name":
[1] "Steven"
Slot "id":
[1] 1002
Slot "contact":
[1] "West Avenue"Un objeto de clase "employee"
Slot "name":
"Steven"
Slot "id":
1002
Slot "contact":
"West Avenue"La salida anterior muestra que el objeto creado es de la clase "employee" y que el slot "name" vale "Steven", el slot "id" vale 1002 y el slot "contact" vale "West Avenue".
Funciones y comandos
Para comprobar si un objeto es S4 o no, puedes usar los siguientes comandos:
El comando "is.object(obj)" comprueba si una variable o instancia hace referencia a un objeto.
is.object(obj)
TRUE
El código anterior devuelve la siguiente salida:
TRUEEl comando "isS4(obj)" comprueba si una variable o instancia es un objeto S4.
isS4(obj)
TRUE
El código anterior devuelve la siguiente salida:
TRUEAcceder y modificar el valor de un slot
Acceder a un slot
Se accede a los slots con "@" en lugar de "$".
Se usa "obj@name" para acceder al nombre "Steven" y de forma análoga "obj@id".
obj@name
obj@id
'Steven'
1002
El código anterior devuelve la siguiente salida:
'Steven'
1002Modificar un slot
Modifiquemos el valor de un slot usando el operador de asignación ("<-") para asignar a "obj@contact" un nuevo valor: "North Avenue".
obj@contact <- "North Avenue"
obj
Un objeto de clase "employee"
Slot "name":
[1] "Steven"
Slot "id":
[1] 1002
Slot "contact":
[1] "North Avenue"El código anterior devuelve la siguiente salida:
Un objeto de clase "employee"
Slot "name":
"Steven"
Slot "id":
1002
Slot "contact":
"North Avenue"La salida muestra que el slot "contact" ha cambiado su valor de "West Avenue" a "North Avenue".
Como alternativa, puedes usar "slot()" para cambiar el valor.
"slot(obj, \"id\")" indica el slot "id", cuyo valor se cambia asignándole 1004, y luego se imprime "obj".
slot(obj,"id") <- 1004
obj
Un objeto de clase "employee"
Slot "name":
[1] "Steven"
Slot "id":
[1] 1004
Slot "contact":
[1] "North Avenue"Un objeto de clase "employee"
Slot "name":
"Steven"
Slot "id":
1004
Slot "contact":
"North Avenue"La salida anterior muestra que el slot "id" ha cambiado su valor de 1002 a 1004.
Crea tu propio método genérico en S4
Vamos a crear una función que imprima la salida como necesitemos, usando "setMethod()" y la función genérica "show()". Se accede al valor de todos los slots con "@" y se imprimen sus nombres. Por último, se obtiene la salida con "obj".
setMethod("show",
"employee",
function(object) {
cat("Name:",object@name, "\n")
cat("Id:",object@id, "\n")
cat("Contact:", object@contact, "\n")
}
)
obj
Name: Steven
Id: 1004
Contact: North AvenueName: Steven
Id: 1004
Contact: North AvenueLa salida muestra que los resultados se imprimen con los nombres de los slots y sus valores correspondientes.
Enhorabuena
¡Enhorabuena, has llegado al final de este tutorial!
En este tutorial has aprendido programación orientada a objetos (OOP) con los objetos de R y sus distintas clases, como S3 y S4, cómo construirlas, crear funciones genéricas con ejemplos y mucho más.
Si quieres seguir aprendiendo R, echa un vistazo a los cursos de DataCamp:
Temas
