############# ############### ############# 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. ############# ############# ############# Cambiamos Idioma de Salida ############# ############# ############# Sys.setenv(LANG = "sp") # 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=1470000) # Genera en un stop en el maximo ampliable. Ignorado = False #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 guradar las librerias. #install.packages("zoo", lib="I:/Paquetes/R 4.0.3") # lo instalamos library("zoo", lib.loc="I:/Paquetes/R 4.0.3") # Lo hacemos correr para que funcione .libPaths("I:/Paquetes/R 4.0.3") ########################## ########################## ########################## Fijamos Directorio ########################## ########################## de Trabajo ########################## ########################## ########################## # Imprime la ruta del directorio de trabajo actual getwd() # Imprime los elementos contenidos al interior de una carpeta determinada dir() # Cambiar el Directorio setwd("D:/ESTUDIOS") # Ejemplo 1 getwd() # Ejemplo 2 setwd("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_") getwd() ############# ############### ############# MIS PRIMEROS PASOS ############### ############# ############### a=35 #le digo que a es lo mismo que 35 a print(a) View(a) # str(a) # Entrega la clase, naturaleza o tipo de observacion. 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="7" str(c) View(c) #PruebA=Hola Mundo Prueba="HOLA MUNDO" # Asigne una cadena de texto como elemento u objeto de Coty str(Prueba) print(Prueba) #le pregunte que significa coty y me respondio abajo, Hola Mundo ############# ############### ############# 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 <- 'D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_' #Ubicamos el directorio donde esta el archivo setwd(ruta) # para fijar la ruta getwd() # para fijar la ruta de manera complementaria, para el mismo objetivo, la realizamos de manera preventiva dir() # Esto nos ayuda a visualiza lo que tenemos dentro de nuestra carpeta en la pantalla inf-izq # 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 # una vez instalados los drives correspondiente podremos hacer correr la libreria: library(readxl) # Corremos libreria library(readxl) # Corremos libreria # Despues de este paso recien ppodremos importar nuestro archivo # Dataframe a Trabajar # https://www.lun.com/Pages/NewsDetail.aspx?dt=2021-02-23&PaginaId=16&BodyId=0 dir("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/") # Apertura todo lo que hay dentro de esta carpeta #Cargamos Juguete1 <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 1) # (Sheet=la hoja de calculo de excel, por cuanto si tenemos 3 hojas, tendremos que escribir en nuestro codigo tres sheet) # Ahora, cargamos # Ahora, visualizamos View(Juguete1) ############################ ############################ ############################ ############################ ############################ Hasta aqui Sesion 1 con R. Clase 2 ############################ ############################ ############################ ############################ ############################ # Reemplazar # Tambien Ctrl + F # Recomendacion del despliegue de menu en el costado. # Comentar lo de la memoria variable.names(Juguete1) str(Juguete1) table(Juguete1$Gobernadores_Regionales) # Revisamos las observaciones del vector. Si no es NA es tambien asignado o contado como 1. # Ahora importaremos la hoja 2 Juguete2 <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 2) 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 (suele pesar menos) Juguete3 <- read.csv("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.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. # Señalar lo de TRUE y FALSE # Entregar la observacion con respecto a los problemas de guardado e importacion. View(Juguete3) ############################ ############################ ############################ ############################ ############################ Guardamos o Exportamos en Otros ############################ ############################ Formatos Recomendables ############################ ############################ ya que no son pesados ############################ ############################ ############################ ############################ ############################ # Recomendacion: Pisar. # Guardamos en formato xslx. install.packages("writexl") library(writexl) install.packages("openxlsx") library("openxlsx") write.xlsx(Juguete3, file = "D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/J3333.xlsx") # Guardamos en formato xslx. En un archivo, en varias pestañas. library("openxlsx") lista <- list("Prueba_1" = Juguete1, "Prueba_2" = Juguete2, "Prueba_3" = Juguete3) #Generamos a partir de distintos data.frames distintos sheet u hojas write.xlsx(lista, file = "D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/Prueba_Unificada.xlsx") #Al guardarlo se guarda un data.frame con distintos sheet # Guardamos en formato RDS. Formato liviano. saveRDS(Juguete2, file = "D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/En_Formato_RDS_.rds") # Llamamos un dataframe en formato rds Prueba_2 <- readRDS(file = "D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/En_Formato_RDS_.rds") # Guardamos en Formato "RData". Es el formato que recomiendo. Por su peso. # Guardo medioambiete save.image("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/332_Environment_1.RData") ############################ ############################ ############################ ############################ ############################ Borramos dataframes y/o Environment ############################ ############################ ############################ ############################ ############################ rm(Juguete1) # Borro un Data Frame rm(list = ls()) # Borro Todo el Environment # Cargo medioambiente load("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/332_Environment_1.RData") ############# ############### ############# EJERCICO Y TRATAMIENTO DE COLUMNAS ############### ############# ############### # Renombre el Dataframe Juguete1x <- Juguete1 # Respaldar Juguete2x <- Juguete2 #la flecha es lo mismo que el simbolo = # Para comprobar, se lo preguntamos a R Juguete1x # De esta manera lo que hemos realizado es asignar al objeto Juguete1 una sabana de datos View(Juguete1x) # 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) Juguete1x <- Juguete1x[,-3] Juguete1x Juguete1x <- Juguete1x[-3,] Juguete1x Juguete1x <- Juguete1x[-3,-1] # Si quieren eliminar un dato # NO LO RECOMIENDO View(Juguete1x) # Podemos pedirle a R visualizar un dato, un vector o una fila por posicion Matricial. Ejemplo # Quiero Visualizar el tercer dato del primer registro: 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) Juguete2x$nueva=Juguete1[,2] variable.names(Juguete2x) # Para comprobar lo realizado View(Juguete2x) # Para comprobar lo realizado # Ejercicio: Crear una nueva variable que sume la columna 2 con la columna 5, de Juguete1 Juguete2x$nueva2=Juguete1[,2] + Juguete1[,5] View(Juguete2x) # Para comprobar lo realizado # 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. Juguete2x$nueva3= 12*((Juguete2x[,2] + Juguete2x[,4]) / (2*(Juguete2x[,2] + Juguete2x[,5]))) View(Juguete2x) # Cada tantas lineas de codigo corrido, guardar Environment y con distinto nombre que el anterior, a modo de respaldo. # Guardo medioambiete save.image("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/484_Environment_2.RData") #load("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/484_Environment_2.RData") ############################ ############################ ############################ ############################ ############################ Borramos dataframes y/o Environment ############################ ############################ ############################ ############################ ############################ rm(Juguete1) # Borro un Data Frame rm(list = ls()) # Borro Todo el Environment # Cargo medioambiente load("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/Environment_2.RData") # quedamos aquí 29 ############# ############### ############# ############### ############# Funcion Merge (Cruzar) ############### ############# ############### ############# ############### # Requisito 1: Identificar la llave. # Requisito 2: La llave debe estar en la misma clase o tipo. # Requisito 3: La llave debe tener el mismo nombre. # Entender el codigo de derecha a izquierda. # Tener claro cual es mi dataframe "X" y cual es mi dataframe "Y. # Tener claro que quiero traer. # ¿Quiero crear un dataframe, con "la interseccion de Y con X"? # ¿Quiero crear un dataframe, con "todo lo de "Y" en "X"? (Si. Tal como lo estas pensando; de manera acumulativa). # ¿Quiero crear un dataframe, con "todo lo que encuentre de "X" en "Y"?. # ¿Quiero crear un dataframe, con "todo lo que encuentre de "Y" en "X"?. # Veamos ppt desde la perspectiva o logica de teoria de Conjuntos. # 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("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal2_15_04_2021_.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("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal2_15_04_2021_.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) # Crearemos una Dummy numerica para vrificar los valores traidos ########################## ########################## ########################## Asignar valores o Dummy ########################## ########################## ########################## ########################## ########################## # Asignar un valor o Dummy Partidos1 <- cbind(Partidos1, Dummy =rep(1,78)) #Agrego filas variable.names(Partidos1) View(Partidos1) str(Partidos1$Dummy) # Ejemplo1: Quiero crear un dataframe, con "la interseccion de Y con X". Cruce1 <- merge(Partidos1, Partidos2, by="Partido", all = FALSE) View(Cruce1) # 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) # 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) View(Cruce2) # 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) View(Cruce2) # 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("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/Environment_3.RData") #load("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/Environment_3.RData") ############# ############### ############# CONEXIoN A SERVIDOR EXTERNO ############### ############# EJEMPLO SQL - HADOOP ############### # VPN configurada previamente. Con autorizacion de la institucion a traves de usuario y contraseña. # 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 # Significado Sentencias # believeNRows: # Sentencia logica. ¿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. "Trae toda las # filas o registro" # 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 ########################## ########################## ########################## Renombrar Variables ########################## ########################## ########################## ########################## ########################## # Volvemos a cargar Juguete1 <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 1) Juguete2<- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 2) variable.names(Juguete1) #Renombrar una Variable install.packages("dplyr") library(dplyr) Juguete1 <- rename(Juguete1,c(Partido="Llave")) # O tambien Juguete1 <- plyr::rename(Juguete1,c(Llave="Partido")) # O tambien str(Juguete1) variable.names(Juguete1) library(stats) library(data.table) setnames(Juguete1, old = c("Partido", "Gobernadores_Regionales", "Convecionales_Constituyentes", "Alcaldes", "Concejales", "Total"), new = c("V1","V2","V3", "V4", "V5", "V6")) # O tambien colnames(Juguete1) <- c("Partido", "Gobernadores_Regionales", "Convecionales_Constituyentes", "Alcaldes", "Concejales", "Total") ########################## ########################## ########################## Reemplazar Observaciones ########################## ########################## ########################## ########################## ########################## str(Juguete1) Juguete_respaldo <- Juguete1 #Juguete1 <- Juguete_respaldo # Una condicion Juguete1$Convecionales_Constituyentes[Juguete1$Convecionales_Constituyentes < 73148452] <- 999 # Dos condiciones "Y" Juguete1$Convecionales_Constituyentes[Juguete1$Convecionales_Constituyentes > 16426061 & Juguete1$Convecionales_Constituyentes < 313092511] <- 999 #Juguete1 <- Juguete_respaldo # Dos condiciones "O" 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? # Creando un vector bajo condicionantes #Juguete1 <- Juguete_respaldo Juguete1$Nuevo <- ifelse(Juguete1$Convecionales_Constituyentes > 28700247 & Juguete1$Concejales < 331842267, 1,0) # Reemplazamos con 1 y todo lo demas rellenar com 0. # ¿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. # ¿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. # ¿Y si quiero rellenar el resto con informacion de un vector #Juguete1 <- Juguete_respaldo Juguete1$Nuevo <- ifelse(Juguete1$Convecionales_Constituyentes > 28700247 & Juguete1$Concejales < 331842267, 1 , Juguete1$Convecionales_Constituyentes) # Reemplazamos con 1 y todo lo demas rellenar com 0. ########################## ########################## ########################## USO DE N/A ########################## ########################## ########################## ########################## ########################## install.packages("inspectdf") library(inspectdf) # Entrega info de datos faltantes en las variables Juguete1 %>% inspect_na #Reemplazar N/A Juguete1[is.na(Juguete1)] <- 0 #Reemplazar N/A Juguete1 %>% inspect_na # Reemplazamos 0 por NA Juguete1[Juguete1 == 0] <- NA ########################## ########################## ########################## PREGUNTAS RELEVANTES ########################## ########################## DE NEGOCIO ########################## ########################## ########################## ########################## ########################## ########################## FUNCIoN SUBSET ########################## ########################## ########################## ########################## ########################## # Seleccionar todo lo distinto a Juguete1 <- Juguete_respaldo Juguete1[is.na(Juguete1)] <- 0 #Reemplazar N/A Seleccion1 <- subset(Juguete1, Alcaldes!=0) # Seleccionar todo lo igual a Juguete1 <- Juguete_respaldo Juguete1[is.na(Juguete1)] <- 0 #Reemplazar N/A Seleccion2 <- subset(Juguete1, Convecionales_Constituyentes==0) ########################## ########################## ########################## SELECCION DE VARIABLES ########################## ########################## ########################## ########################## ########################## # Seleccionamos Variables Juguete1 <- Juguete_respaldo variable.names(Juguete1) Seleccion3 <- Juguete1[,c("Gobernadores_Regionales", "Alcaldes", "Partido")] ########################## ########################## ########################## Convertir todas las columnas ########################## ########################## o vectores en una Clase ########################## ########################## ########################## # Seleccionamos Variables Juguete1 <- Juguete_respaldo str(Juguete1) Juguete1[,2:6] <- lapply(Juguete1[,2:6], as.character) str(Juguete1) # Otra Manera Juguete1$Gobernadores_Regionales <- as.numeric(Juguete1$Gobernadores_Regionales) str(Juguete1$Gobernadores_Regionales) # Otra Manera. Utilizando unlist Juguete1 <- Juguete_respaldo Juguete1$Partido <- 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 Seleccion3 <- c(5,3,7,4,13,6,17,19,11,1) # el comando "C" nos sirve para crear columnas str(Seleccion3) View(Seleccion3) Seleccion3 <- as.data.frame(Seleccion3) # Convertimos a Dataframe View(Seleccion3) ########################## ########################## ########################## ########################## ########################## Aleatoriedad ########################## ########################## ########################## ########################## ########################## # Otra Manera Seleccion4 <- sample(1:30,10,replace=F) str(Seleccion4) View(Seleccion4) Seleccion4 <- as.data.frame(Seleccion4) # Convertimos a Dataframe View(Seleccion4) # 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(Nomina_Alumnos$N) 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 ("D:/PROYECTOS/DOCENCIA_/INAP/PERFIL ALUMNO INTRODUCCION AL DATA 1º 23-04-21.xlsx", skip = 1, sheet = 1))[(S <- sample(1:35,1,replace=F)),2]))) ########################## ########################## ########################## ########################## ########################## Union de Datframes ########################## ########################## ########################## ########################## ########################## # 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 Seleccion5 <- rbind(Juguete_respaldo, Juguete1) # Aumentar la Dimensionalidad de un Dataframe al unirlo con Otro # Requisito: 1. La misma cantidad de rows, filas u observaciones. Seleccion6 <- cbind(Juguete1, Juguete2) ########################## ########################## ########################## Separador de DV ########################## ########################## 3 Funciones en Una ########################## ########################## ########################## # Observacion 1: No ahondaremos dado que se vera en el Modulo de Text Mining Seleccion7 <- c("15931529-2", "12365845-1", "14522359-2", "15321478-6", "9526357-8", "5365478-2") # el comando "C" nos sirve para crear columnas str(Seleccion7) View(Seleccion7) Seleccion7 <- as.data.frame(Seleccion7) # Convertimos a Dataframe View(Seleccion7) Seleccion7 <- rename(Seleccion7,c(Partido="Seleccion7")) # Renombramos # Separamos digito verificador del Run install.packages("tidyr") library(tidyr) Seleccion7 <- separate(Seleccion7,Seleccion7,c("RUN","DV"),sep ="-",remove=F,convert=T,extra="merge",fill="right") # El separador es el gui?n en este caso. View(Seleccion7) ########################## ########################## ########################## Concatenar ########################## ########################## ########################## # Concatenar variables alternas, y separando con guion bajo. Seleccion8 <- unite(Seleccion6, variables,c(1,4), sep = "_") ########################## ########################## ########################## ########################## ########################## Cambiar a Mayusculas ########################## ########################## los encabezados ########################## ########################## ########################## # Cambiar a Mayusculas los encabezados aux <- toupper(colnames(Seleccion8)) aux ########################## ########################## ########################## Eliminar Duplicados ########################## ########################## ########################## # Elimino duplicado que sean iguales en algunas variables variable.names(Seleccion5) Seleccion9 <- Seleccion5[!duplicated(Seleccion5[c('Gobernadores_Regionales', 'Alcaldes', 'Total')]),] # Otra Manera Seleccion10 <- unique(Seleccion5) # Otra Manera Seleccion11 <- distinct(Seleccion5) ########################## ########################## ########################## Indexar ########################## ########################## ########################## # Ventaja de R a diferencia de python-pandas, para los rows. # Volvemos a cargar Juguete1 <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 1) Juguete2<- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 2) variable.names(Juguete1) # Indexar 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 Seleccion7 <- c("15931529-2", "12365845-1", "14522359-2", "15321478-6", "9526357-8", "5365478-2") # el comando "C" nos sirve para crear columnas str(Seleccion7) View(Seleccion7) Seleccion7 <- as.data.frame(Seleccion7) # Convertimos a Dataframe View(Seleccion7) # Separamos digito verificador del Run install.packages("tidyr") library(tidyr) Seleccion7 <- separate(Seleccion7,Seleccion7,c("RUN","DV"),sep ="-",remove=F,convert=T,extra="merge",fill="right") # El separador es el gui?n en este caso. View(Seleccion7) # Indexar variable.names(Seleccion7) rownames(Seleccion7) <- Seleccion7$RUN # Indexamos View(Seleccion7) # Preparamos la Master para desindexar variable.names(Seleccion7) Seleccion8 <- Seleccion7 Seleccion7 <- c("15931529-2", "12365845-1", "14522359-2", "15321478-6", "9526357-8", "5365478-2") # el comando "C" nos sirve para crear columnas Seleccion7 <- as.data.frame(Seleccion7) # Convertimos a Dataframe Seleccion7 <- separate(Seleccion7,Seleccion7,c("RUN","DV"),sep ="-",remove=F,convert=T,extra="merge",fill="right") # El separador es el gui?n en este caso. Seleccion7 <- Seleccion7[ ,!colnames(Seleccion7)=="RUN"] # Eliminamos Variable variable.names(Seleccion7) View(Seleccion7) # Desindexamos Seleccion7$RUN <- rownames(Seleccion8) # Des Indexar RUN variable.names(Seleccion7) View(Seleccion7) ########################## ########################## ########################## Transponer o Rotar ########################## ########################## ########################## Seleccion9 <- t(Seleccion7) ########################## ########################## ########################## Asignamos ID Correlativo ########################## ########################## ########################## Seleccion10 <- Seleccion7 # Copiamos Seleccion10$id <- c(1:nrow(Seleccion10)) variable.names(Seleccion10) View(Seleccion10) # Otra Manera Seleccion10$id2 <- (1:6) # Como ya estan ordenados en orden decreciente, creamos sin problemas un ID correlativo del 1 al 8.415 ########################## ########################## ########################## Cuenta veces que un ########################## ########################## registro presenta informacion ########################## ########################## ########################## Seleccion10$Cuenta <- rowSums(!is.na(Seleccion10)) variable.names(Seleccion10) View(Seleccion10) ########################## ########################## ########################## Cuenta veces que una Variable ########################## ########################## presenta informacion ########################## ########################## ########################## variable.names(Seleccion10) sum(!is.na(Seleccion10$RUN)) View(Seleccion10) ########################## ########################## ########################## ########################## ########################## Agrupacion ########################## ########################## ########################## ########################## ########################## # Preparamos Data Juguete1 <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.xlsx", sheet = 1) Juguete4 <- rbind(Juguete1, Juguete1, Juguete1, Juguete1) variable.names(Juguete4) Juguete4[is.na(Juguete4)] <- 0 #Reemplazar N/A Promedio_ <- Juguete4 %>% group_by(Partido) %>% summarise(mean(Gobernadores_Regionales)) str(Promedio_) Promedio_$`mean(Gobernadores_Regionales)` <- as.numeric(Promedio_$`mean(Gobernadores_Regionales)`) str(Promedio_) Promedio_ <- Promedio_[with(Promedio_, order(-Promedio_$`mean(Gobernadores_Regionales)`)), ] # Orden inverso Promedio_ View(Promedio_) str(Promedio_) ########################## ########################## ########################## ########################## ########################## Uso de Fechas ########################## ########################## ########################## ########################## ########################## # 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: difftime(dia3, dia1, units = "weeks") difftime(dia3, dia1, units = "days") difftime(dia3, dia1, units = "hours") difftime(dia3, dia1, units = "mins") difftime(dia3, dia1, units = "secs") ########################## ########################## ########################## ########################## ########################## Calcular porcentajes ########################## ########################## ########################## ########################## ########################## library(readxl) Juguete1 <- read_excel("D:/PROYECTOS/DOCENCIA_/INAP/Adrian_Modulos_/Intro_RSTudio_/aporte_Fiscal_15_04_2021_.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 ########################## ########################## ########################## ########################## ########################## # Dummizar Seleccion15 <- Juguete1 str(Seleccion15) knitr::kable(Seleccion15$Partido) results <- fastDummies::dummy_cols(Seleccion15$Partido) knitr::kable(results) str(Seleccion15) View(results) # 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 Estadisticas ########################## ########################## Descriptiva ########################## ########################## ########################## dim(Juguete1) # Resumen de Fila y Vectores ################### ################## ################### 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)