############# ############### ############# MIS PRIMEROS PASOS ############### ############# ############### # Lenguaje Orientado Hacia Objetos. # Input <- Output <- Lenguaje No Inteligente: Paradoja. # Paneles de RStudio. # Estructuras Basica General de la Sintaxis. # Gestion de Expectativas # Prompt. # Grabar objetos a <- 5 # Flecha como = es exactamente lo mismo. Además, yo # estoy creando un elemento u objeto a, que es 5. Queda, grabdo # en el software o en R. 5+6 b = 3 c = a - b c # Consulto el objeto print(c) # Imprime el objeto o elemento, c. ############# ############# ############# Cambiamos Idioma de Salida ############# ############# ############# Sys.setenv(LANG = "sp") # investigar mas. ######### ######### ######### Crear INDICE ######### ######### ######### # El mínimo es 5. ########################## ########################## ########################## Fijamos Directorio ########################## ########################## de Trabajo ########################## ########################## ########################## # ctrl + shift + r, # Crear INDICE ------------------------------------------------------------ # Imprime la ruta del directorio de trabajo actual getwd() # Imprime los elementos contenidos al interior de una carpeta determinada dir() # Cambiar el Directorio setwd("E:/ESTUDIOS") # Ejemplo 1 esto fija un nuevo directorio getwd() # Ejemplo 2 setwd("E:/PROYECTOS/DOCENCIA_/INAP/Versión4_/Intro_RSTudio_/Scripts_&_Data_set_Clases_") getwd() dir() ############# ############### ############# MIS PRIMEROS PASOS ############### ############# ############### a=35 #le digo que a es lo mismo que 35 H <- a + b H a print(a) View(a) # M <- "Gabriel" M str(a) # Entrega la clase, naturaleza o tipo de observacion. str(M) b=7 #Le digo que b es lo mismo que 7 str(7) View(a+b) print(a+b) #le digo que sume a y b c = a + b c c="7" str(c) View(c) #PruebA=Hola Mundo Prueba <- "HOLA MUNDO" # Asigne una cadena de texto como elemento u objeto str(Prueba) print(Prueba) #le pregunte que significa Prueba ############# ############### ############# IMPORTAMOS DATAFRAME ############### ############# ############### # Importamos el archivo excel "Juguete" # Para realizar esta operacion siempre debemos indicarle a R en que carpeta o directorio vamos a trabajar ruta <- 'E:/PROYECTOS/DOCENCIA_/INAP/Versión3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_' #Ubicamos el directorio donde esta el archivo setwd(ruta) # para fijar la ruta getwd() # Consultar ruta fijada. dir() # Esto nos ayuda a visualiza lo que tenemos dentro de nuestra carpeta en la pantalla inf-izq str(ruta) # Luego de fijar nuestra ruta de trabajo importaremos un archivo excel a nuestra consola R # En este ejercicio trabajaremos con el archivo "Juguete" # Generalmente los archivos Excel se encuentran en 2 tipos de formatos: # xlsx o bien en csv (los cuales generalmente diran archivo de valores separados por comas de microsoft excel) # xlsx (se vera como hoja de calculo de microsoft excel) # Para esto lo primero sera descargar e instalar el paquete que nos permite importar y exportar archivos excel tipo xlsx y posteriormente correr la libreria # Instalamos paquetes y corremos libreria install.packages("readxl") # Instalamos paquete install.packages("openxlsx") install.packages("read.xlsx") # Para MAC. # Una vez instalados los drives correspondiente podremos hacer correr la libreria: library(readxl) # Corremos libreria library(readxl) # Corremos libreria library(openxlsx) library(openxlsx) #library(read.xlsx) # Para MAC. # En mi caso R solicit? actualizar el siguiente paquete. #update.packages("Rcpp") #update.packages('Rcpp') #library(Rcpp) # En mi caso, lo elimin? manualmente, limpie las cookies, me asegur? que el cable del disco extraible este funcionando bien # y luego volv? a descargar dicho paquete y correr su respectiva librer?a. #rm(Juguete1) # Dataframe a Trabajar # https://www.lun.com/Pages/NewsDetail.aspx?dt=2021-02-23&PaginaId=16&BodyId=0 #dir("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/Scripts_&_Data_set_Clases_") # Apertura todo lo que hay dentro de esta carpeta #rm(Juguete1) #Cargamos Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versión3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) # (Sheet=la hoja de calculo de excel, por cuanto si tenemos 3 hojas, tendremos que escribir en nuestro codigo el numero 3) # Ahora, cargamos # Ahora, visualizamos View(Juguete1) ##### ##### ##### Hasta acà llegamos 27 Agosto de 2022 ##### ##### ##### dim(Juguete1) str(Juguete1) #variable.names(Juguete1) = colnames(Juguete1) Juguete1 <- as.data.frame(Juguete1) str(Juguete1) # Reemplazar # Tambien Ctrl + F # Recomendacion del despliegue de menu en el costado. # Comentar lo de la memoria variable.names(Juguete1) # Como consultar el nombre de los vectores o de las avriables colnames(Juguete1) str(Juguete1) dim(Juguete1) print(Juguete1$Gobernadores_Regionales) # Consulta observaciones para este vector str(Juguete1$Partido) View(Juguete1) table(Juguete1$Gobernadores_Regionales) # Revisamos las observaciones del vector. Si no es NA se asigna un n?mero 1. Consulta <- as.data.frame(Juguete1$Gobernadores_Regionales) str(Consulta) View(Consulta) # Giraremos o Transponemos Matriz girar_Juguete1 <- t(Juguete1) # Funcion t, ejecuta el giro. str(girar_Juguete1) View(girar_Juguete1) girar_Juguete1 <- as.data.frame(t(Juguete1)) # Funcion t, ejecuta el giro. str(girar_Juguete1) View(girar_Juguete1) dim(Juguete1) OjazosHermosos <- Juguete1[-3,] dim(OjazosHermosos) OjazosHermosos <- OjazosHermosos[,-6] dim(OjazosHermosos) ############################ ############################ ############################ ############################ ############################ Aqu? quedamos en la clase numero X ############################ ############################ del d?a XX de XXXXX de 2022 ############################ ############################ ############################ ############################ ############################ library(readxl) # Corremos libreria library(readxl) # Corremos libreria # Ahora importaremos la hoja 2 Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) View(Juguete2) variable.names(Juguete2) str(Juguete2) table(Juguete2$Gobernadores_Regionales) # Revisamos las observaciones del vector. Si no es NA es tambien asignado o contado como 1. View(Juguete2) # Ahora realizaremos el mismo procedimiento pero en el formato de excel csv. Juguete3 <- read.csv("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.csv", header=TRUE, sep = ";") # La funcion o comando header= encabezado, al colocarle TRUE, significa que la data lleva una etiqueta o nombre de las variables. dim(Juguete3) View(Juguete3) # Se?alar lo de TRUE y FALSE # Entregar la observacion con respecto a los problemas de guardado e importacion. View(Juguete3) # Otra funci?n. No necesita librer?a. Por defecto reconoce el separador y el encabezado. ocupados <- read.csv2("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.csv") View(ocupados) ############################ ############################ ############################ ############################ ############################ Guardamos o Exportamos en Otros ############################ ############################ Formatos Recomendables ############################ ############################ ya que no son pesados ############################ ############################ ############################ ############################ ############################ str(Juguete2) str(Juguete3) str(ocupados) Juguete2 <- as.data.frame(Juguete2) str(Juguete2) # Recomendacion: Pisar. # Guardamos en formato xslx. install.packages("writexl") library(writexl) install.packages("openxlsx") library("openxlsx") write.xlsx(Juguete3, file = "E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/J3333.xlsx") View(lista) # Guardamos en formato xslx. En un archivo, en varias pesta?as. library("openxlsx") lista <- list("Prueba_1" = Juguete2, "Prueba_2" = Juguete3, "Prueba_3" = ocupados) #Generamos a partir de distintos data.frames distintos sheet u hojas str(lista) str(lista$Prueba_1) write.xlsx(lista, file = "E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/Prueba_Unificada.xlsx") #Al guardarlo se guarda un data.frame con distintos sheet #Exportamos write.csv(Cruce, file = "Cruce.csv") # Guardamos en formato RDS. Formato liviano. saveRDS(lista, file = "E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/Prueba_UnificadaRDSDF.rds") # Llamamos un dataframe en formato rds Prueba_UnificadaRDSDFllamando <- readRDS( file = "E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/Prueba_UnificadaRDSDF.rds") View(Prueba_UnificadaRDSDFllamando) str(Prueba_UnificadaRDSDFllamando) Prueba_UnificadaRDSDFllamandoD <- as.data.frame(Prueba_UnificadaRDSDFllamando) View(Prueba_UnificadaRDSDFllamandoD) str(Prueba_UnificadaRDSDFllamandoD) dim(Prueba_UnificadaRDSDFllamandoD) # Guardamos en Formato "RData". Es el formato que recomiendo. Por su peso. # Guardo medioambiete save.image("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/402_28_04_2022_Environment_1.RData") ############################ ############################ ############################ ############################ ############################ Borramos dataframes y/o Environment ############################ ############################ ############################ ############################ ############################ rm(Juguete2) # Borro un Data Frame rm(Juguete3, ocupados) # Borro un Data Frame rm(list = ls()) # Borro Todo el Environment # Cargo medioambiente load("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/402_28_04_2022_Environment_1.RData") ############# ############### ############# EJERCICO Y TRATAMIENTO DE COLUMNAS ############### ############# ############### # Renombre el Dataframe Juguete1x <- Juguete2 #la flecha es lo mismo que el simbolo = rm(Juguete2x) View(Juguete1x) Juguete2[24,2] # Para efectos de explicar la posici?n. Cordenada. Juguete2[,2:3] Recorre <- as.data.frame(Juguete2[11:18,2:3]) str(Recorre) # Como parte de los ejercicios para saber utilizar una base de datos, usaremos la daframe de Juguete1x y aprenderemos a borrar una columna: # eliminaremos la tercera variable (columna): Juguete1x <- Juguete1x[,] # Cordenada o Posici?n del dato o una observaci?n View(Juguete1x) # * como dato anexo: En una sabana de datos, las filas son los registros horizontales, y las columnas son los variables verticales variable.names(Juguete1x) dim(Juguete1x) Juguete1xSv3 <- Juguete1x[,-3] dim(Juguete1x) dim(Juguete1xSv3) variable.names(Juguete1x) print(Juguete1x[3,]) # Pregunto cual es el registro numero 3 View(Juguete1x) Juguete1BRn3 <- Juguete1x[-3,] dim(Juguete1x) dim(Juguete1BRn3) colnames(Juguete1x) Juguete1BRyV <- as.data.frame(Juguete1x[,-2:-3]) # Quiero borrar la variable 2 y 3 Juguete1BRyV2 <- Juguete1x[,-2:-3] # Quiero borrar la variable 2 y 3 View(Juguete1BRyV2) View(Juguete1BRyV) colnames(Juguete1x) Juguete1x[11:25,] # Consulto los siguientes registros que van del # 11 al 25. Juguete1xEliminarD <- Juguete1x[-3,-1] # Si quieren eliminar un dato # NO LO RECOMIENDO View(Juguete1xEliminarD) # CORDENADA = POSICION = MATRIZ # Podemos pedirle a R visualizar un dato, un vector o una fila por posicion Matricial. Ejemplo # Quiero Visualizar el tercer dato del primer registro: Juguete1 <- Juguete2 View(Juguete1x[1,3]) # De la misma manera el tipo de datframe, a que variable pertenece y que tipo de variable es. str(Juguete1x[1,3]) # Puedo solicitar visualizar el cuarto vector y tipo de observaciones que posee respectivamente. # Manera 1 View(Juguete1x[,3]) str(Juguete1x[,3]) # Vemos en que posicion de nuestro dataframe se encuentra cada variable. variable.names(Juguete1) # Para crear una nueva variable en nuestra dataframe, lo hacemos asi: # Crearemos una nueva columna llamada, a modo de ejemplo "nueva" en la cual incorporaremos la informacion de la columna 2 de Juguete1: variable.names(Juguete1) #Juguete1 <- as.data.frame(Juguete1) #Juguete2 <- as.data.frame(Juguete2) #Juguete1x <- Juguete1 #Juguete2x <- Juguete2 #la flecha es lo mismo que el simbolo = str(Juguete1) print(Juguete1[,]) # Imprime la nada colnames(Juguete1) dim(Juguete1) Juguete2xConNv <- Juguete1 dim(Juguete1) Juguete2xConNv$nueva <- Juguete1[,2] dim(Juguete2xConNv) View(Juguete2xConNv) variable.names(Juguete2xConNv) # Para comprobar lo realizado # Ejercicio: Crear una nueva variable que sume la columna 2 con la columna 5, de Juguete1 dim(Juguete1) dim(Juguete1xSv3) Juguete2xConNv Juguete1sna <- Juguete1[1:6,] Juguete1sna2 <- Juguete1[2:7,] Juguete2xConNv2 <- Juguete1[2:7,] View(Juguete1sna) View(Juguete1sna2) # Connstruye un nuevo set de datos estructurado, agregando # una nueva variable denominada nueva2, construida a partir de la suma # de la variable 2 de Juguete1sna y 3 de Juguete1sna2. # Requisitos para esto: # Misma cantidad de rows # Variables Num?ricas # Que existan las variables en cada set de datos Juguete2xConNv2$nueva2 <- Juguete1sna[,2] + Juguete1sna2[,3] variable.names(Juguete2xConNv2) View(Juguete2xConNv2) print(Juguete1sna[,2]) variable.names(Juguete1sna) print(Juguete1sna2[,3]) variable.names(Juguete1sna2) # Ejercicio: Crear una nueva variable que multiplique 12 veces el # producto resultante de la division de las suma de la columna # 2 y 4, por la suma de las columnas 2 y 5 multiplicadas por 2. Juguete2xConNv2$nueva3 <- 12*((Juguete1sna[,2] + Juguete1sna[,2]) / (2*(Juguete1sna[,2] + Juguete1sna2[,3]))) View(Juguete2xConNv2) Juguete2xConNv2$nueva4 <- 100000000*(12*((Juguete1sna[,2] + Juguete1sna[,2]) / (2*(Juguete1sna[,2] + Juguete1sna2[,3])))) View(Juguete2xConNv2) # Cada tantas lineas de codigo corrido, guardar Environment y con distinto nombre que el anterior, a modo de respaldo. # Guardo medioambiete #save.image("E:/PROYECTOS/DOCENCIA_/INAP/Versión4_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/711_Environment_2.RData") #load("E:/PROYECTOS/DOCENCIA_/INAP/Versión4_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/711_Environment_2.RData") ############################ ############################ ############################ ############################ ############################ Borramos dataframes y/o Environment ############################ ############################ ############################ ############################ ############################ rm(Juguete1) # Borro un Data Frame rm(list = ls()) # Borro Todo el Environment # Cargo medioambiente load("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/660_Environment_2.RData") ############# ############### ############# ############### ############# Funcion Merge (Cruzar) ############### ############# ############### ############# ############### # Requisito 1 : Tener claro que quiero traer. # Requisito 2 : Identificar la llave. # Requisito 3 : La llave debe estar en la misma clase o tipo. # Requisito 4 : La llave debe tener el mismo nombre. # Requisito 5 : Entender el codigo de derecha a izquierda. # Requisito 6 : Tener claro cual es mi dataframe "X" y cual es mi dataframe "Y. # Requisito 7 : Responder la Pregunta ?Quiero crear un dataframe, con "la interseccion de Y con X"? # Requisito 8 : Responder la Pregunta ?Quiero crear un dataframe, con "todo lo que encuentre de "Y" en "X"?. # Requisito 9 : Responder la Pregunta ?Quiero crear un dataframe, con "todo lo de "Y" en "X"? (Si. Tal como lo estas pensando; de manera acumulativa). # Requisito 10: Responder la Pregunta ?Quiero crear un dataframe, con "todo lo que encuentre de "X" en "Y"?. ############################ ############################ ############################ ############################ ############################ Aqu? quedamos en la clase numero X ############################ ############################ del d?a XX de XXXXX de 2022 ############################ ############################ ############################ ############################ ############################ # Veamos ppt desde la perspectiva o logica de teoria de Conjuntos. # Una vez instalados los drives correspondiente podremos hacer correr la libreria: library(readxl) # Corremos libreria library(readxl) # Corremos libreria library(openxlsx) #library(read.xlsx) # Para MAC. # Ejemplo1: Quiero crear un dataframe, con "la interseccion de Y con X". # Importante: El codigo asume con esta sintaxis, que el primer dataframe que ingreso en la sintaxis es mi dataframe "X". # Para los efectos de este ejemplo "Partido" sera mi llave. #Cargamos Partidos1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_2_.xlsx", sheet = 1) # (Sheet=la hoja de calculo de excel, por cuanto si tenemos 3 hojas, tendremos que escribir en nuestro codigo tres sheet) Partidos2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_2_.xlsx", sheet = 2) # (Sheet=la hoja de calculo de excel, por cuanto si tenemos 3 hojas, tendremos que escribir en nuestro codigo tres sheet) str(Partidos1) str(Partidos2) variable.names(Partidos1) variable.names(Partidos2) Partidos1 <- as.data.frame(Partidos1) str(Partidos1) Partidos2 <- as.data.frame(Partidos2) str(Partidos2) # Crearemos una Dummy numerica para vrificar los valores traidos ########################## ########################## ########################## Asignar valores ########################## ########################## ########################## ########################## ########################## # Asignar un valor o Dummy dim(Partidos1) Partidos1 <- cbind(Partidos1, Validador = rep(1,78)) #Agrego filas variable.names(Partidos1) str(Partidos1$Validador) str(Partidos1) View(Partidos1) str(Partidos1$Partido) str(Partidos2$Partido) # Ejemplo1: Quiero crear un dataframe, con "la interseccion de Y con X". Cruce1 <- merge(Partidos1, Partidos2, by="Partido", all = FALSE) View(Cruce1) dim(Cruce1) dim(Partidos1) dim(Partidos2) # Clase 3. Llegamos hasta aqu?. Fecha 16 de 09 de 2021. # Muestra registros unicos, en comun. # Cambia los nombres con x e y cuando son los mismos # Ejemplo2: Quiero crear un dataframe, con "todo lo de "Y" en "X" (De manera acumulativa). Cruce2 <- merge(Partidos1, Partidos2, by="Partido", all = TRUE) View(Cruce2) str(Cruce2$Validador) # Muestra registros unicos. Es decir Y se a?ade como completo a X # Ejemplo3: Quiero crear un dataframe, con "todo lo que encuentre de "X" en "Y". Cruce3 <- merge(Partidos1, Partidos2, by="Partido", all.x = TRUE) dim(Cruce3) View(Cruce3) # Muestra registros unicos solo de X. Trae informacion de X contenida en Y. # Ejemplo4: Quiero crear un dataframe, con "todo lo que encuentre de "Y" en "X"?. Cruce4 <- merge(Partidos1, Partidos2, by="Partido", all.y = TRUE) dim(Cruce4) View(Cruce4) # Muestra registros unicos solo de Y. Trae informacion de Y contenida en X. # Si colocan FALSE en las sintaxis anteriores, son las mismas nomenclaturas anteriores pero invertidas. # Existen otros comandos o funciones para realizar cruces en R con otras reglas (nomezclaturas) # Guardo medioambiete #save.image("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/866_03_05_2022_Environment_2.RData") #load("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/4789_22_09_2021_Environment_2.RData") ############# ############### ############# CONEXIoN A SERVIDOR EXTERNO ############### ############# EJEMPLO SQL - HADOOP ############### # VPN configurada previamente. Con autorizacion de la institucion a traves de usuario y contrase?a. # Red privada virtual install.packages("odbc") install.packages("sqldf") install.packages("RODBC") library(odbc) library(sqldf) library(RODBC) # Tabla "caracteristicas generales", DIP declarantes por Servicio y Numeral ch <- odbcConnect("HADOOP_PROD", believeNRows = FALSE, readOnlyOptimize = TRUE) # Abro la conexi?n str(ch) # Significado Sentencias # believeNRows: # Sentencia logica.("Trae toda las filas o registro") ?Es creible el numero de filas que devuelve la conexion ODBC? Al parecer, no es cierto para algunos # controladores de Oracle y Sybase, ni para el controlador SQLite de Actual Technologies para Mac OS X. # readOnlyOptimize: # Sentencia logica: ?deberia optimizarse la conexion para acceso de solo lectura?. Sentencia de optimizacion. # rows_at_time: El numero predeterminado de filas para recuperar a la vez, entre 1 y 1024. No todos los controladores # funcionan correctamente con valores> 1: consulte sqlQuery. Ingresamos numero 1 para asegurarnos que recupere de 1 en 1 # ante una eventual caida. query1 <- "SELECT DECLARACION.* FROM (SELECT DISTINCT PERSONA.RUT, DECLARACION.ID_DECLARACION AS DIP, DECLARACION.FOLIADOR AS FOLIO, DECLA_TIPO.NOMBRE AS TIPO_DECLARACION, DECLA_ESTADO.ID AS ESTADO_ID, DECLA_ESTADO.NOMBRE AS ESTADO_DIP, DECLARACION.FECHAFIRMADECLARANTE AS Firma_DIP, DECLARACION.FECHAFIRMAJEFESERVICIO AS Firma_JdS, DECLARACION.FECHA_RECEPCION_CGR AS Recep_CGR, SUJETO_OBLIGADO AS NUMERAL, TO_DATE (DECLARACION.FECHA_CESE) AS Fecha_Cese, SERV_PUB.ID AS ID_SERV, SERV_PUB.ESTADO AS Estado_servicio, SERV_PUB.NOMBRE AS ENTIDAD, COMUNA_DES.NOMBRE AS COMUNA_SERV, SERV_PUB.AUTONOMO, CASE SERV_PUB.AUTONOMO WHEN 0 THEN 'ADM ESTADO' WHEN 1 THEN 'AUTONOMO' ELSE 'NO HAY' END AS TIPO_SERV FROM dip_privado_ods_kudu.DECLARACION INNER JOIN dip_privado_ods_kudu.PERSONA ON DECLARACION.ID_PERSONA = PERSONA.ID LEFT JOIN dip_privado_ods_kudu.DATOS_DECLARANTE ON DECLARACION.ID_DATOS_DECLARANTE=DATOS_DECLARANTE.ID LEFT JOIN dip_privado_ods_kudu.DIRECCION ON DATOS_DECLARANTE.ID_DIRECCION=DIRECCION.ID LEFT JOIN dip_privado_ods_kudu.COMUNA ON DIRECCION.COMUNA_ID=COMUNA.ID LEFT JOIN dip_privado_ods_kudu.ESTADO_CIVIL ON DATOS_DECLARANTE.ESTADO_CIVIL_ID=ESTADO_CIVIL.ID LEFT JOIN dip_privado_ods_kudu.PROFESION ON DATOS_DECLARANTE.PROFESION_ID=PROFESION.ID_PROFESION LEFT JOIN dip_privado_ods_kudu.REGIMEN_PATRIMONIAL ON DATOS_DECLARANTE.REGIMEN_PATRIMONIAL_ID=REGIMEN_PATRIMONIAL.ID INNER JOIN dip_privado_ods_kudu.DECLA_TIPO ON DECLARACION.DECLA_TIPO_ID = DECLA_TIPO.ID INNER JOIN dip_privado_ods_kudu.DECLA_ESTADO ON DECLARACION.DECLA_ESTADO_ID = DECLA_ESTADO.ID INNER JOIN dip_privado_ods_kudu.DATOS_LABORALES on DECLARACION.ID_DATOS_LABORALES = DATOS_LABORALES.ID INNER JOIN dip_privado_ods_kudu.SERV_PUB on DATOS_LABORALES.SERV_PUB_ID = SERV_PUB.ID LEFT JOIN dip_privado_ods_kudu.SERV_PUB_GRADO ON DATOS_LABORALES.SERV_PUB_GRADO_ID = SERV_PUB_GRADO.ID LEFT JOIN dip_privado_ods_kudu.CARGO ON DATOS_LABORALES.ID_CARGO = CARGO.ID LEFT JOIN dip_privado_ods_kudu.COMUNA AS COMUNA_DES ON DATOS_LABORALES.COMUNA_ID = COMUNA_DES.ID LEFT JOIN dip_privado_ods_kudu.SUJETO_OBLIGADO ON DECLARACION.SUJETO_OBLIGADO = SUJETO_OBLIGADO.ID) AS DECLARACION" #WHERE ESTADO_DIP IN (6,9) #Sujetos Obligados por servicio que han declarado a la fecha SSOO_SERV_DETALLE <- sqlQuery(ch, query1, rows_at_time = 1, as.is = FALSE) #as.is = TRUE, deja lo exportado como texto, evitando problemas con las fechas. #322.123 #Cierra la conexión al ODBC close(ch) # Respaldamos (renombramos) query1 <- SSOO_SERV_DETALLE dim(SSOO_SERV_DETALLE) variable.names(SSOO_SERV_DETALLE) ########################## ########################## ########################## Comparar Dataframes ########################## ########################## ########################## ########################## ########################## # Para comparar fila a fila, disponemos de varias alternativas con diferentes paquetes. # A efectos ilustrativos calculamos las filas en df1 que no se encuentran en df2. Para obtener las de df2 no # presentes en df2, alterar el orden en el c?digo. identical(df1, df2) # Otra librer?a # La salida de datos indica primero si el data frame es igual y entre corchetes si las filas son iguales # (TRUE) o no (FALSE). Si queremos incluir los valores no disponibles (NAs), utilizamos la funci?n addNA: library(compare) compare(df1, df2) # Filas diferentes presentes en el df1 anti_join(df1, df2) # Filas comunes semi_join(df1, df2) ########################## ########################## ########################## Renombrar Variables ########################## ########################## ########################## ########################## ########################## # Volvemos a cargar Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) dim(Juguete1) dim(Juguete2) variable.names(Juguete1) variable.names(Juguete2) #Renombrar una Variable install.packages("dplyr") install.packages("plyr") library(dplyr) View(Juguete1) Juguete1 <- rename(Juguete1,c(Llave="Partido")) colnames(Juguete1) View(Juguete1) # O tambien library(plyr) library(plyr) Juguete1 <- plyr::rename(Juguete1,c(Llave="Partido")) colnames(Juguete1) #help(plyr) #?(plyr) # O tambien str(Juguete1) variable.names(Juguete1) install.packages("data.table") library(stats) library(data.table) library(data.table) library(data.table) setnames(Juguete1, old = c("Partido", "Gobernadores_Regionales", "Convecionales_Constituyentes", "Alcaldes", "Concejales", "Total"), new = c("V1","V2","V3", "V4", "V5", "V6")) colnames(Juguete1) View(Juguete1) # O tambien colnames(Juguete1) <- c("Partido", "Gobernadores_Regionales", "Convecionales_Constituyentes", "Alcaldes", "Concejales", "Total") colnames(Juguete1) View(Juguete1) ########################## ########################## ########################## Reemplazar Observaciones ########################## ########################## ########################## ########################## ########################## str(Juguete1) Juguete_respaldo <- Juguete1 #Juguete1 <- Juguete_respaldo Juguete1 <- Juguete_respaldo Juguete1 <- as.data.frame(Juguete1) str(Juguete1) # Una condicion str(Juguete1$Convecionales_Constituyentes) View(Juguete1) Juguete1$Convecionales_Constituyentes[Juguete1$Convecionales_Constituyentes < 73148452] <- 999 View(Juguete1) View(Juguete_respaldo) rm(Juguete1) # Elimna objetos # Dos condiciones "Y" Juguete1$Convecionales_Constituyentes[Juguete1$Convecionales_Constituyentes > 16426061 & Juguete1$Convecionales_Constituyentes < 313092511] <- 999 View(Juguete1) # Logicamente no reemplaza los registros que cumplen las condiciones, es decir, # 16426061 y 313092511. Es el l?mite inferior y es el l?mite superior respectivamente, # por describir dicho proceso de otra manera. #=! # | = o # Lenguaje R # & = y # Lenguaje R #Juguete1 <- Juguete_respaldo ############################ ############################ ############################ ############################ ############################ Aqu? quedamos en la clase numero X ############################ ############################ del d?a XX de XXXXX de 2022 ############################ ############################ ############################ ############################ ############################ # Guardo medioambiete #save.image("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/1149_03_05_2022_Environment_3.RData") # Guardo medioambiente #load("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/1149_03_05_2022_Environment_3.RData") # Llamo medioambient2 str(Juguete1) library("readxl") # Volvemos a cargar Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("EE:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) str(Juguete1) Juguete1 <- as.data.frame(Juguete1) str(Juguete1) Juguete1$Convecionales_Constituyentes[Juguete1$Convecionales_Constituyentes > 190776116 | Juguete1$Convecionales_Constituyentes < 28700247] <- 999 # ?Que sucede con la funcion si en el hilo o cadena se encuentra un NA? # ?Que sucede si reemplazo la condicion por una palabra o conjunto de caracteres? View(Juguete1) # Creando un vector bajo condicionantes #Juguete1 <- Juguete_respaldo # Volvemos a cargar Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) str(Juguete1) Juguete1 <- as.data.frame(Juguete1) str(Juguete1) Juguete2 <- as.data.frame(Juguete2) str(Juguete2) dim(Juguete1) Juguete1$Nuevo <- ifelse(Juguete1$Convecionales_Constituyentes > 28700247 & Juguete1$Concejales < 331842267, 1,0) # Reemplazamos con 1 y todo lo demas rellenar com 0. View(Juguete1) # ?Que sucede si reemplazo la condicion por una palabra o conjunto de caracteres? #Juguete1 <- Juguete_respaldo Juguete1$Nuevo <- ifelse(Juguete1$Convecionales_Constituyentes > 28700247 & Juguete1$Concejales < 331842267, "algo","nada") # Reemplazamos con 1 y todo lo demas rellenar com 0. View(Juguete1) # Volvemos a cargar Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) str(Juguete1) Juguete1 <- as.data.frame(Juguete1) str(Juguete1) Juguete2 <- as.data.frame(Juguete2) str(Juguete2) # ?Que sucede si reemplazo la condicion por una palabra o conjunto de caracteres? #Juguete1 <- Juguete_respaldo Juguete1$Nuevo <- ifelse(Juguete1$Convecionales_Constituyentes > 28700247 & Juguete1$Concejales < 331842267, 1 ,"nada") # Reemplazamos con 1 y todo lo demas rellenar com 0. View(Juguete1) # Pregunta PP. # ?Y si quiero rellenar el resto con informacion de un vector #Juguete1 <- Juguete_respaldo Juguete1$Nuevo <- ifelse(Juguete1$Convecionales_Constituyentes > 28700247 , 1, Juguete1$Convecionales_Constituyentes) # Reemplazamos con 1 y todo lo demas rellenar com 0. View(Juguete1) ########################## ########################## ########################## USO DE N/A ########################## ########################## ########################## ########################## ########################## install.packages("inspectdf") library(inspectdf) #Renombrar una Variable install.packages("dplyr") library(dplyr) # Entrega info de datos faltantes en las variables Juguete1 %>% inspect_na isNa2 <- as.data.frame(isNa1 <- Juguete1 %>% inspect_na) str(isNa1) str(isNa2) View(isNa2) dim(Juguete1) sum(isNa2$cnt) #Reemplazar N/A Juguete1[is.na(Juguete1)] <- 0 #Reemplazar N/A View(Juguete1) Juguete1 %>% inspect_na # Reemplazamos 0 por NA Juguete1[Juguete1 == 0] <- NA View(Juguete1) variable.names(isNa2) str(isNa2$cnt) isNa2$cnt <- as.numeric(isNa2$cnt) # Sumar sum(isNa2[,2]) ########################## ########################## ########################## PREGUNTAS RELEVANTES ########################## ########################## DE NEGOCIO ########################## ########################## ########################## ########################## ########################## ########################## FUNCIoN SUBSET ########################## ########################## ########################## ########################## ########################## # Volvemos a cargar library("readxl") Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) str(Juguete1) Juguete1 <- as.data.frame(Juguete1) str(Juguete1) Juguete2 <- as.data.frame(Juguete2) str(Juguete2) # Seleccionar todo lo distinto a Juguete_respaldo <- Juguete1 #Juguete1 <- Juguete_respaldo Juguete1[is.na(Juguete1)] <- 0 #Reemplazar N/A Seleccion1 <- subset(Juguete1, Alcaldes!=0) # Selecciona str(Seleccion1) View(Seleccion1) dim(Seleccion1) # Seleccionar todo lo igual a Juguete1 <- Juguete_respaldo Juguete1[is.na(Juguete1)] <- 0 #Reemplazar N/A Seleccion2 <- subset(Juguete1, Convecionales_Constituyentes==0) str(Seleccion2) Seleccion2$Partido View(Seleccion2) ########################## ########################## ########################## SELECCION DE VARIABLES ########################## ########################## ########################## ########################## ########################## # Seleccionamos Variables Juguete1 <- Juguete_respaldo variable.names(Juguete1) Seleccion3 <- Juguete1[,c("Gobernadores_Regionales", "Alcaldes", "Partido")] variable.names(Seleccion3) View(Seleccion3) # Obtenemos lo mismo de manera por medio de coordenadas matriciales. Seleccion3_1 <- Juguete1[,-3] variable.names(Seleccion3_1) Seleccion3_1 <- Seleccion3_1[,-4:-5] variable.names(Seleccion3_1) variable.names(Juguete1) Seleccion3_4 <- as.data.frame(Seleccion3_2 <- Juguete1[,"Convecionales_Constituyentes"]) str(Seleccion3_4) View(Seleccion3_4) Seleccion3_5 <- Juguete1[,] # Que no exista signo no significa que exista vac?o. Por ende existe el todo. Juguete1[,] = Juguete1 # Esto es verdadero. ########################## ########################## ########################## Convertir todas las columnas ########################## ########################## o vectores en una Clase ########################## ########################## ########################## # Seleccionamos Variables Juguete1 <- Juguete_respaldo str(Juguete1) colnames(Juguete1) Juguete1[,2:6] <- lapply(Juguete1[,2:6], as.character) str(Juguete1) View(Juguete1) # Otra Manera Juguete1$Gobernadores_Regionales <- as.numeric(Juguete1$Gobernadores_Regionales) str(Juguete1$Gobernadores_Regionales) str(Juguete1) # Otra Manera. Utilizando unlist Juguete1 <- Juguete_respaldo Juguete1$Partido <- as.character(as.factor(unlist(Juguete1$Partido))) str(Juguete1$Partido) ########################## ########################## ########################## ########################## ########################## Creacion de Columnas o Vectores ########################## ########################## ########################## ########################## ########################## # Ejercicio crear un dataframe con un vector o columna # Seleccion3 sera nuestro objeto Seleccion4 <- c(5,3,7,4,13,6,17,19,11,1) # el comando "C" nos sirve para crear columnas str(Seleccion4) View(Seleccion4) Seleccion5 <- as.data.frame(Seleccion4) # Convertimos a Dataframe str(Seleccion5) View(Seleccion5) ########################## ########################## ########################## ########################## ########################## Aleatoriedad ########################## ########################## ########################## ########################## ########################## # Otra Manera Seleccion6 <- sample(1:30,100,replace=T) str(Seleccion6) View(Seleccion6) Seleccion7 <- as.data.frame(Seleccion6) # Convertimos a Dataframe View(Seleccion7) ##### ##### ##### Consulta aleatoria alumnos ##### ##### ##### install.packages("readxl") library(readxl) # Corremos libreria # Para la tarea #Nomina_Alumnos <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/PERFIL ALUMNO INTRODUCCION AL DATA 1? 23-04-21.xlsx", skip = 1, sheet = 1) range(Juguete1$Partido) range(Juguete1$Total) View(Juguete1) variable.names(Nomina_Alumnos) S <- print(sample(1:35,1,replace=F)) X <- Nomina_Alumnos[S,2] #El_AfortunadE_es print(paste("El apellido y nombre del(a) afortunade del dia de hoy para contarnos en 5 minutos como le fue con la tarea encomendada es", sep=" ", (X <- (Nomina_Alumnos <- read_excel ("E:/PROYECTOS/DOCENCIA_/INAP/Versión4_/PERFIL ALUMNO INTRODUCCION AL DATA 4° 16.08.22.xlsx", skip = 1, sheet = 1))[(S <- sample(3:26,1,replace=F)),2]))) # 2:29 = significa que el intervalo de datos va a estar comprendido entre ambos n?meros (2 y 29 inclusive). # 1 = significa el n?mero de n?meros aleatorios que quieres salgan del intervalo anterior. En este caso 1. # replace=F/T = si quieres que puedan repetirse los n?meros aleatorios (es decir, obtener por ejemplo dos n?meros 3), # dejamos el valor T (true). Si no queremos repetici?n, ponemos el valor F (false). TTT <- sample(1:35,1,replace=F) print(TTT) # Probaremos otra funci?n random # FUNCI?N RUNIF() DE R PARA GENERAR N?MEROS RACIONALES ALEATORIAMENTE # Como hemos visto, la funci?n anterior sample no permite obtener n?meros decimales. # ?Qu? pasa si queremos obtener tambi?n n?meros con decimales? Pues como ya sab?is, # esto se puede conseguir con la funci?n runif de R. Esta funci?n est? incluida dentro del # paquete de R llamado stats. Vamos a verlo igualmente en acci?n con un ejemplo para estudiarlo # en profundidad despu?s: # Ejemplos: # runif(5, min=3, max=4) # [1] 3.537344 3.629892 3.362016 3.860888 3.930647 # Igual que con la funci?n sample, la funci?n runif se compone de tres atributos: runif(5, min=3, max=4) # 5 = es el n?mero de n?meros decimales que queremos generar aleatoriamente. # En este caso queremos que nos devuelva 5 n?meros aleatoriamente seleccionados. # min=3 y max=4 representan el intervalo de donde se van a extraer los n?meros aleatorios en R. # En nuestro ejemplo, nuestros n?meros aleatorios estar?n comprendidos entre el 3 y el 4. # Es importante mencionar que no es obligatorio poner min= y max= en nuestra funci?n. # Si los omiti?ramos como se ve a continuaci?n seguir?an extray?ndose los n?meros aleatorios del intervalo marcado. # runif(5, 3, 4) # Funci?n paste print(paste("El apellido y nombre del(a) afortunade del dia de hoy para contarnos en 5 minutos como le fue con la tarea encomendada es", sep=" ", 5)) ########################## ########################## ########################## ########################## ########################## Union de Dataframes ########################## ########################## ########################## ########################## ########################## # Unimos dataframes (que tengan la misma cantidad de columnas y que se titulen de la misma manera). Esta sintaxis agrega filas. # Requisito: 1. La misma cantidad de Variables. # 2. La mismas etiquetas de las variables o Nombres str(Juguete_respaldo) dim(Juguete_respaldo) str(Juguete1) dim(Juguete1) Seleccion8 <- rbind(Juguete_respaldo, Juguete1) dim(Seleccion8) # Aumentar la Dimensionalidad de un Dataframe al unirlo con Otro # Requisito: 1. La misma cantidad de rows, filas u observaciones. Y no es necesario que tenga a lo menos una # columna en comun. str(Juguete1) dim(Juguete1) str(Juguete2) dim(Juguete2) Seleccion9 <- cbind(Juguete1, Juguete2) dim(Seleccion9) View(Seleccion9) str(Seleccion9) # Procedemos a realizar lo mismo str(Juguete1) str(Juguete2) # Renombraremos todas las variables de Juguete2 colnames(Juguete2) <- c("D", "DDD", "DD") variable.names(Juguete2) dim(Juguete2) dim(Juguete1) Seleccion10 <- cbind(Juguete1, Juguete2) View(Seleccion10) ########################## ########################## ########################## Separador de DV ########################## ########################## 3 Funciones en Una ########################## ########################## ########################## # Observacion 1: No ahondaremos dado que se vera en el Modulo de Text Mining Seleccion11 <- c("15931529-2", "12365845-1", "14522359-2", "15321478-6", "9526357-8", "5365478-2") # el comando "C" nos sirve para crear columnas str(Seleccion11) View(Seleccion11) Seleccion12 <- as.data.frame(Seleccion11) # Convertimos a Dataframe str(Seleccion12) View(Seleccion12) Seleccion13 <- rename(Seleccion12,c(Partido="Seleccion11")) # Renombramos str(Seleccion13) View(Seleccion13) # Separamos digito verificador del Run install.packages("tidyr") library(tidyr) Seleccion14 <- separate(Seleccion13, Partido,c("RUN","DV"),sep ="-",remove=F,convert=T,extra="merge",fill="right") # El separador es el gui?n en este caso. View(Seleccion14) ########################## ########################## ########################## Concatenar ########################## ########################## ########################## # Concatenar variables alternas, y separando con guion bajo. str(Seleccion14) variable.names(Seleccion14) Seleccion15 <- Seleccion14[ ,!colnames(Seleccion14)=="Partido"] # Otra Manera de eleminar variables variable.names(Seleccion15) Seleccion16 <- cbind(Seleccion14, Seleccion14, Seleccion14) variable.names(Seleccion16) View(Seleccion16) Seleccion17 <- Seleccion16[ ,!colnames(Seleccion16)=="Partido"] # Verificamos si elimna todas las variables llamadas Partido o # arroja un error. variable.names(Seleccion17) View(Seleccion17) variable.names(Seleccion16) Seleccion18 <- Seleccion16[ ,!colnames(Seleccion16)=="Partido" & !colnames(Seleccion16)=="RUN"] # Eliminaremos mas de una variable View(Seleccion18) View(Seleccion16) Seleccion19 <- Seleccion16[ ,!colnames(Seleccion16)==c("Partido", "RUN")] # Cuidado con esta sintaxis. View(Seleccion19) variable.names(Seleccion15) library(tidyr) library(dplyr) Seleccion20 <- unite(Seleccion15, variables,c(1,2), sep = "%%%%%%%") # Concatenar View(Seleccion20) ########################## ########################## ########################## ########################## ########################## Cambiar a Mayusculas ########################## ########################## los encabezados ########################## ########################## ########################## # Cambiar a Mayusculas las etiquetas variable.names(Seleccion15) colnames(Seleccion15) <- c("run", "dv") variable.names(Seleccion15) Seleccion20 <- Seleccion15 colnames(Seleccion20) <- toupper(colnames(Seleccion20)) # A may?scula View(Seleccion20) ########################## ########################## ########################## Eliminar Duplicados ########################## ########################## ########################## library(readxl) # Corremos libreria library(openxlsx) # Volvemos a cargar Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) variable.names(Juguete1) # Elimino duplicado que sean iguales en algunas variables Seleccion21 <- Juguete1 Seleccion21$Nuevo1 <- Juguete1[,3] variable.names(Seleccion21) View(Seleccion21) Seleccion21$Nuevo2 <- Juguete1[,6] variable.names(Seleccion21) Seleccion21$Nuevo3 <- Juguete1[,2] variable.names(Seleccion21) Seleccion21$Nuevo4 <- Juguete1[,3] str(Seleccion21) Seleccion21 <- as.data.frame(Seleccion21) str(Seleccion21) View(Seleccion21) dim(Seleccion21) Seleccion22 <- Seleccion21[!duplicated(Seleccion21[c('Convecionales_Constituyentes', 'Nuevo1', 'Nuevo4')]),] # dim(Seleccion21) dim(Seleccion22) # Otra Manera Seleccion23 <- rbind(Seleccion22, Seleccion22) dim(Seleccion23) Seleccion24 <- unique(Seleccion23) # Borra todos los registros 100% Iguales dim(Seleccion24) # Otra Manera Seleccion25 <- distinct(Seleccion23) # Comparar rendimiento con la funcion unique para grandes volumenes de datos dim(Seleccion25) ########################## ########################## ########################## Indexar ########################## ########################## ########################## # Ventaja de R a diferencia de python-pandas, para los rows. # Volvemos a cargar variable.names(Juguete1) View(Juguete1) # Indexar Juguete1 <- as.data.frame(Juguete1) str(Juguete1) rownames(Juguete1) <- Juguete1$Partido #Indexamos variable.names(Juguete1) View(Juguete1) # Otro Ejemplo de de Indexacion # Observacion 1: No ahondaremos dado que se vera en el Modulo de Text Mining Seleccion26 <- c("15931529-2", "12365845-1", "14522359-2", "15321478-6", "9526357-8", "5365478-2") # el comando "C" nos sirve para crear columnas str(Seleccion26) View(Seleccion25) Seleccion27 <- as.data.frame(Seleccion26) # Convertimos a Dataframe View(Seleccion27) # Indexar # Requisito: El rows debe ser unico. variable.names(Seleccion27) rownames(Seleccion27) <- Seleccion27$Seleccion26 # Indexamos View(Seleccion27) # Preparamos la Master para desindexar View(Seleccion27) Seleccion28 <- separate(Seleccion27, Seleccion26,c("RUN","DV"),sep ="-",remove=F,convert=T,extra="merge",fill="right") # El separador es el gui?n en este caso. View(Seleccion28) Seleccion28 <- Seleccion28[ ,!colnames(Seleccion28)=="Seleccion26"] # Eliminamos Variable variable.names(Seleccion28) View(Seleccion28) # Desindexamos Seleccion29 <- Seleccion28 Seleccion29$RUNInd <- rownames(Seleccion28) # Des Indexar RUN variable.names(Seleccion29) View(Seleccion29) ########################## ########################## ########################## Transponer o Rotar ########################## ########################## ########################## Seleccion30 <- t(Seleccion29) # Transponer. Rotar. View(Seleccion30) # Guardo medioambiete #save.image("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/2061_03_05_2022_Environment_3.RData") # Guardo medioambiente #load("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/2061_03_05_2022_Environment_3.RData") # Llamo medioambient2 ############################ ############################ ############################ ############################ ############################ Aqu? quedamos en la clase numero X ############################ ############################ del d?a XX de XXXXX de 2022 ############################ ############################ ############################ ############################ ############################ library(readxl) # Corremos libreria library(openxlsx) # Volvemos a cargar Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) Juguete2 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 2) variable.names(Juguete1) Juguete1 <- as.data.frame(Juguete1) Juguete2 <- as.data.frame(Juguete2) str(Juguete1) str(Juguete2) ########################## ########################## ########################## Asignamos ID Correlativo ########################## ########################## ########################## Seleccion31 <- Juguete1 # Copiamos Seleccion31$id <- c(1:nrow(Seleccion31)) # Indica cantidad de registro total variable.names(Seleccion31) View(Seleccion31) dim(Seleccion31) # Otra Manera Seleccion31$id2 <- (2:26) # Como ya estan ordenados en orden decreciente, creamos sin problemas un ID correlativo del 1 al 25 View(Seleccion31) ########################## ########################## ########################## Cuenta veces que un ########################## ########################## registro presenta informacion ########################## ########################## ########################## View(Seleccion31) Seleccion31$SumaPre <- rowSums(!is.na(Seleccion31)) variable.names(Seleccion31) View(Seleccion31) View(Seleccion31) Seleccion31$SumaPre2 <- rowSums(is.na(Seleccion31)) variable.names(Seleccion31) View(Seleccion31) ########################## ########################## ########################## Cuenta veces que una Variable ########################## ########################## presenta informacion ########################## ########################## ########################## variable.names(Seleccion31) sum(!is.na(Seleccion31$Gobernadores_Regionales)) View(Seleccion31) ########################## ########################## ########################## ########################## ########################## Agrupacion ########################## ########################## ########################## ########################## ########################## library(tidyr) library(dplyr) # Preparamos Data str(Seleccion31) Juguete4 <- rbind(Juguete1[-12:-24,], Juguete1[-2:-8,], Juguete1[-3:-13,], Juguete1[-6,], Juguete1[-3:-17,], Juguete1[-24,], Juguete1[-15:-25,], Juguete1[-4:-25,]) dim(Juguete4) View(Juguete4) Juguete4 <- cbind(Juguete4, Validador = rep(1,119)) #Agrego filas variable.names(Juguete4) View(Juguete4) Juguete4[is.na(Juguete4)] <- 0 #Reemplazar N/A str(Juguete4) View(Juguete4) # Partido debe estar en formato character. Agregado <- Juguete4 %>% group_by(Partido) %>% summarise(sum(Validador)) View(Agregado) Agregado <- Agregado[with(Agregado, order(-Agregado$`sum(Validador)`)),] # Orden inverso print(Agregado) View(Agregado) # Contenido Vito con los alumnos. Hasta ac? para la evaluaci?n. ########################## ########################## ########################## ########################## ########################## Uso de Fechas ########################## ########################## Calcularemos la ########################## ########################## Diferencia ########################## ########################## ########################## # Seleccion12 <- c("12-03-2020", "01-09-2021", "05-09-2018", "05-11-2017", "19-05-2005", "15-11-1985") # el comando "C" nos sirve para crear columnas # Seleccion13 <- c("12-03-2020", "01-09-2021", "05-09-2018", "05-11-2017", "19-05-2005", "15-11-1985") # el comando "C" nos sirve para crear columnas # Convertimos clase a date install.packages("lubridate") library(lubridate) Fecha1 <- c("2020-03-17", "2021-09-21", "2018-09-05", "2017-01-05", "2001-05-13", "1985-11-26") # el comando "C" nos sirve para crear columnas Fecha2 <- c("1955-07-09", "2021-04-01", "2018-10-029", "1998-11-03", "2005-06-12", "1992-10-14") # el comando "C" nos sirve para crear columnas # fecha_tiempo <- c("2019-03-26 13:26:08", "2019-04-17 15:45:10") # Si fuese con hora, tendria este formato. str(Fecha1) Fecha3 <- cbind(Fecha1, Fecha2) colnames(Fecha3) <- c("Fecha1","Fecha2") str(Fecha3) Fecha3 <- as.data.frame(Fecha3) str(Fecha3) Fecha3$Fecha1 <- as.POSIXct(Fecha3$Fecha1) Fecha3$Fecha2 <- as.POSIXct(Fecha3$Fecha2) str(Fecha3) Fecha3$Fecha1 <- date(Fecha3$Fecha1) Fecha3$Fecha2 <- date(Fecha3$Fecha2) str(Fecha3) # Calculamos la diferencia entre fechas. Fecha3$Diferencia <- difftime(Fecha3$Fecha1, Fecha3$Fecha2, units = "days") str(Fecha3) View(Fecha3) # Podemos calcular la diferencia en semanas, días, en horas, en minutos, o en segundos. # Ejemplo: # "weeks" # "days" # "hours" # "mins" # "secs" ########################## ########################## ########################## ########################## ########################## Calcular porcentajes ########################## ########################## ########################## ########################## ########################## library(readxl) Juguete1 <- read_excel("E:/PROYECTOS/DOCENCIA_/INAP/Versi?n3_/Intro_RSTudio_/Scripts_&_Data_set_Clases_/data_set_1_.xlsx", sheet = 1) str(Juguete1) # Calcular porcentaje con respecto al mismo vector en una columna nueva Juguete1$'%' <- prop.table(Juguete1$Total) * 100 #Esto es con respecto al mismo vector. View(Juguete1) sum(Juguete1[1:3,7]) ########################## ########################## ########################## ########################## ########################## Dummizar ########################## ########################## ########################## ########################## ########################## install.packages("knitr") install.packages("fastDummies") library(knitr) library(fastDummies) # Dummizar iris <- as.data.frame(iris[,-2:-4]) Agregado <- iris %>% group_by(Species) %>% summarise(sum(Sepal.Length)) print(Agregado) View(Agregado) colnames(Agregado) <- c("Species","Suma") print(Agregado) View(Agregado) Color <- c("Rojo", "Azul", "Blanco") Color <- as.data.frame(Color) # Convertimos a Dataframe Agregado <- cbind(Agregado, Color) View(Agregado) str(Agregado) # Dummizar? ahora. dim(Agregado) knitr::kable(Agregado) results <- fastDummies::dummy_cols(Agregado) knitr::kable(results) results2 <- results[,-2:-6] View(results2) View(Agregado) # Recomendacion 1: Cambiar a nombres abreviados de las variables # Guion Bajo # Por razones de colinealidad se debe eliminar la dummie con la menor cantidad de informacion. ########################## ########################## ########################## ########################## ########################## Algo de Medidas ########################## ########################## de Tendencia Central ########################## ########################## ########################## ########################## ########################## dim(Juguete1) # Resumen de Fila y Vectores View(Juguete1) ################### ################## ################### MEDIDAS DE TENDENCIA CENTRAL ################## ################### ################## #Ejercicio: Aplicaremos medidas de tendencia central para la dataframe MASTER mean(Juguete1$Total) # Media aritmetica = promedio median(Juguete1$Total) # Mediana = el valor que esta en el centro # Con el signo $ indicamos la variable, siempre. # La moda es el dato que mas se repite y se calcula con tres lineas de codigos install.packages("modeest") library(modeest) mlv(Juguete1$Total, method = "mfv") # O mlv(trees$Volume, method = "discrete") # Si queremos un resumen con todas las medidas centrales de estaditica descriptiva de nuestra dataframe. Menos la moda. # Usamos: "summary" summary(Juguete1) summary(Juguete1$Total) sd(Juguete1$Total) # Comunidad Colaborativa R # https://rpubs.com/ # https://www.meetup.com/es-ES/useRchile/ # https://www.meetup.com/es-ES/rladies-scl/ # https://www.meetup.com/es-ES/rladies-bariloche/events/280446388/?rv=co2&_xtd=gatlbWFpbF9jbGlja9oAJDdlODJlZmU1LTVmMzAtNDBjYi04OGM1LTZkZDk2NjBjMWMwYg&utm_campaign=rsvp-confirmation-social&utm_medium=email&utm_source=join_rsvp_info # https://www.meetup.com/es-ES/Women-Who-Code-Santiago/ # Recomendacion: ########################## ########################## ########################## I Diccionario R ########################## ########################## ########################## # Recomendaciones de Crear ########################## ########################## ########################## II Optimizacion ########################## ########################## de Hardware ########################## ########################## ########################## gc() # Arroja las caracteristicas de memoria en uso y por utilizar memory.limit(9999999999) # Genera en un stop en el maximo ampliable. memory.limit(size=14700) # Genera en un stop en el maximo ampliable. Ignorado = False # Remitir la memoria ampliable recomendable para no obtener errores. #Para trabajar mas rapido con R aumentando el uso Ram en Mb # 1 GB = 1.000 MB # 1 TB = 1.000 GB # 1 TB = 1.000.000 MB # https://www.rdocumentation.org/packages/utils/versions/3.6.2/topics/memory.size # Utilice memory.limit(). Puede aumentar el valor predeterminado con este comando memory.limit(size=2500), # donde el tama?o est? en MB. Debe utilizar 64 bits para aprovechar esto realmente. ########################## ########################## ########################## Trabajo en Disco ########################## ########################## Externo ########################## ########################## ########################## # Para que los Paquetes que en un futuro descarguemos vayan a instalarse disco externo # debemos instalar primero, en nuestro ordenador, lo siguiente: # especificando la carpeta del disco duro externo, en donde querremos guardar las librerias. #install.packages("zoo", lib="C:/R") # Primero instalamos en disco local dicho paquete. install.packages("zoo", lib="E:/R.4.1.3") # Luego instalamos en disco extraible dicho paquete. #install.packages("zoo", lib="C:/R") #library("zoo", lib.loc="C:/R") # Activamos dicho paquete corriendo la libreria correspodndiente, en disco local. library("zoo", lib.loc="E:/R.4.1.3") # Activamos dicho paquete corriendo la libreria correspodndiente, en disco extraible a eleccion.. #.libPaths("C:/R") .libPaths("E:/R.4.1.3") # Fijamos el directorio donde seleccionamos que se descarguen finalmente todos los paquetes. # Cambiamos Idioma de Salida. Funciona para algunas salidas de funciones especificas y versiones de Rstudio. Sys.setenv(LANG = "sp")