Tip Semanal 033: Funciones de SAS (parte 3 - conversión de variables).sas

[Berenice25]

Esta tercera parte de funciones presentamos el tema de conversión de variables.

Continuamos así con la serie de Tips referidos a funciones, que habíamos comenzado con los Tips 028 y 029.
En primer lugar veremos conversión automática. 
En segundo lugar pasaremos a conversión utilizando las funciones input y put.
Para finalizar, veremos cómo realizar una conversión utilizando el mismo nombre de la variable original. 
Para más información sobre conversión de variables pueden ver:
https://documentation.sas.com/doc/en/lrcon/9.4/p0ya1w48nfc26bn1f04vaeo77i0j.htm 
https://documentation.sas.com/doc/en/pgmsascdc/9.4_3.5/lepg/n04koei84kuaodn1g21eyx4btome.htm

Funciones de SAS (parte 3)

Para que recuerden la secuencia que vamos a seguir, veremos: 
1. Conversión automática de variables 
2. Uso de las funciones input y put 
3. Reemplazo de una variable original (mismo nombre, distinto tipo)

Pasemos entonces a los ejemplos de la parte 3 de los Tips de funciones: conversión de funciones. 
Nota: nunca está de más recordar que: alfanumérica=caracter(=character, en inglés)

*-------------------*/
/* inicio del código */
/*-------------------*/



/************************************************/
/* 	1. Conversión automática de variables		*/
/************************************************/

/* La transformación automática del tipo de variables entiende el	*/ 
/* contexto en el que se utilizan.									*/
/* Vamos a ver un ejemplo para poder entender esto.					*/


/*----------------------------------*/
/* Ejemplo: conversión automática	*/
/*----------------------------------*/

/* Etapa 1: creamos una tabla para poder hacer pruebas. */
/* ¿Adivinan el nombre de la tabla? 					*/

data prueba;
	infile DATALINES dsd missover;
	input var_char $ var_num;
	cards;
'12', 123
'1', 0
'-12.0',1
'1.2e2', 1.2e3
'12,000',-1
'$12.00',-10.5
run;


/* Etapa 2 : hacemos varias pruebas para ver si la conversión		*/
/* automática funciona. 											*/
/* Con este propósito vamos a ver:									*/
/* Si la conversión automática alfanumérica --> numérica responde	*/
/* bien con diferentes operaciones y funciones; numéricas, claro.	*/
/* Si la conversión automática numérica --> alfanumérica no falla	*/
/* ante diferentes funciones alfanuméricas y al concatenar texto.	*/

data convierte_autom;
	set prueba;
	length valor_num1 - valor_num6 8 valor_char1 - valor_char6 $ 40; /* longitud de
															las variables nuevas */
/* 6 conversiones alfanumérica --> numérica: */
	valor_num1 = var_char+10;  /* conversión automática para sumar o restar */
	valor_num2 = var_char/10;  /* conversión automática para multiplicar o dividir */
	valor_num3 = var_char**2;  /* conversión automática para calcular potencias */
	valor_num4 = sqrt(var_char); /* conversión automática para raíces */
	valor_num5 = exp(var_char);  /* conversión automática para exponentes */
	valor_num6 = cos(var_char);  /* conversión automática para funciones trigonométricas */

/* 6 conversiones numérica --> alfanumérica: */
	valor_char1 = cats('¡El resultado:', var_num,'!'); /* conversión automática para 
														funciones de concatenación */
	valor_char2 = catt('El resultado será:', var_num,'!');
	valor_char3 = catx(' --> ','El resultado convertido es', var_num);
	valor_char4 = cat('¡El nuevo resultado:', var_num,'!');
	valor_char5 = '¡Este es el resultado:' !! var_num !! '!'; /* conversión automática 
											para concatenar en la forma "tradicional" */
	valor_char6 = substr(var_num,1,1); /* conversión automática para otro tipo 
										 de funciones */
run;

A partir de los resultados y del log podemos obtener las siguientes conclusiones . 

Conclusión 1: 
La conversión automática de variables alfanuméricas a numéricas funciona muy bien mientras no tengamos que enfrentarnos a valores alfanuméricos con formatos que no pueden leerse correctamente, por ejemplo la coma como separador de miles o el símbolo '$'. 

Conclusión 2: 
La conversión automática de variables numéricas a alfanuméricas funciona bien con las funciones de concatenación, pero tiene un resultado algo extraño al concatenar usando '!!', y mucho más extraño al usar la función substr. En estos 2 casos nos estamos enfrentando al formato que asume al hacer la conversión automática: el formato 'BEST12.', es decir que va a tener 12 caracteres. 
¿Cómo pueden comprobar si realmente tiene 12 caracteres? En el caso de 'valor_char5' copiando la columna de resultados a un buen editor de texto y contando. En el caso de 'valor_char6' cambiando la fórmula a -por ejemplo- substr(var_num,10,2). 
O también pueden elegir creer, por supuesto.

Entonces, ¿por qué confiar en la conversión automática, que vemos que puede ser peligrosa? Mejor pasemos nosotros a tomar el control. 
Para esto usaremos las funciones 'input' y 'put'. 

************************************************/
/* 	2. Uso de las funciones input y put			*/
/************************************************/

/********************************************************/
/* Input: variable alfanumérica ---> variable numérica 	*/
/* Put: variable numérica ---> variable alfanumérica 	*/
/********************************************************/


/************************/
/* Comezaremos por la:	*/
/* Función input 		*/
/************************/

/* La función input sirve, entre varias cosas,  para convertir una variable */
/* alfanumérica en numérica. 												*/


/*----------------------------------*/
/*Ejemplo: uso de la función input	*/
/*----------------------------------*/

data prueba_input;
	ingreso = '10000';
	gasto = '$2.000';
	fecha1 = '28/12/2022';
	fecha2 = '12/28/2022';
	ingreso_num = input(ingreso,5.); /* notar que le estamos aplicando un formato numérico */
	gasto_num = input(gasto,dollarx6.); /* nuevamente un formato numérico */
	fecha1_num = input(fecha1,ddmmyy10.); /* el formato numérico de fecha adecuado */
	fecha2_num = input(fecha2,mmddyy10.);
	*format fecha1_num ddmmyy10. fecha2_num mmddyy10.; /* por si desean ver las fechas con formato */
run;



/********************/
/* Pasamos a la:	*/
/* Función put 		*/
/********************/

/* La función put sirve, también entre varias cosas,  para convertir una variable	*/
/* numérica en alfanumérica.														*/ 

/*----------------------------------*/
/*Ejemplo: uso de la función put	*/
/*----------------------------------*/

data prueba_put;
	ingreso = 23007;
	gasto = 2000.05;
	fecha1 = 23007;
	hora1 = 23007;
	ingreso_char01 = put(ingreso,5.);
	ingreso_char02 = put(ingreso,comma7.);
	ingreso_char03 = put(ingreso,dollarx8.);
	gasto_char1 = put(gasto,7.); /* el valor '2000.05' con 4 formatos numéricos */
	gasto_char2 = put(gasto,7.2);
	gasto_char3 = put(gasto,7.3);
	gasto_char4 = put(gasto,8.3);
	fecha_char1 = put(fecha1,ddmmyy10.); /* el  valor '23007' con formato de fecha */
	hora_char1 = put(hora1,time8.); /*'23007' con formato de hora */
run;

Como se puede apreciar, el mismo valor con diferentes formatos da diferentes resultados. Esto es importante porque entonces deberíamos pensar en 2 cosas: el tipo de variable y el formato. 
Pero no pensemos en esto por ahora, ya tendremos otro Tip para hacerlo. 

Habrán notado que hasta ahora no hemos cambiado directamente el tipo de variable; estamos creando nuevas variables. Si se pudiera hacer el cambio de variable directamente estaríamos alterando la estructura de la tabla, cosa que no sería nada bueno; nada bueno... Pero claro, existen trucos para poder hacerlo. Vamos entonces a mostrar como "convertir la variable" de cualquiera de las 2 formas. 

Atención: al hacer esto podemos perder información valiosa, así que hay que proceder con cuidado. Lo mejor es hacer una copia de seguridad antes de ejecutar un programa que realice este tipo de modificaciones.

************************************************************************/
/* 	3. Reemplazo de una variable original (mismo nombre, distinto tipo)	*/
/************************************************************************/

/************************************************************************/
/* Situación 1:															*/
/* Cambiar de numérico a alfanumérico con el mismo nombre de variable:	*/
/************************************************************************/

/* Para esto usaremos la función PUT + la sentencia DROP + la opción RENAME. 	*/
/* Por precaución vamos a crear una nueva tabla. A uds. les queda probar 		*/	
/* sobre una misma tabla.														*/
/* Es altamente recomendable que vean la tabla original para poder comparar 	*/
/* los resultados. 																*/

/*--------------------------------------------------------------------------*/
/*Ejemplo: conversión numérico --> alfanumérico (mismo nombre de variable)	*/
/*--------------------------------------------------------------------------*/

data class_nueva;  /* creamos una tabla nueva a partir de sashelp.class */
	set sashelp.class (rename = (weight=peso_temp  
								 height=altura_temp)) ; /* renombramos 2 variables */
	height = put(altura_temp,best5.1); /* creamos las nuevas 2 variables con el mismo 
										nombre de las variables originales */
	weight = put(peso_temp,best5.1);
	drop peso_temp altura_temp;  /* eliminamos las 2 variables temporales */
run;



/************************************************************************/
/* Situación 2:															*/
/* Cambiar de alfanumérico a numérico con el mismo nombre de variable:	*/
/************************************************************************/

/* Tal como mencionamos antes, algo similar sucede con la función input. Tampoco podemos	*/
/* cambiar directamente el tipo de variable de alfanumérica a numérica; siempre creamos 	*/
/* nuevas variables. 																		*/
/* Nuevamente, usaremos el truco de INPUT + DROP + RENAME para poder hacer que 				*/
/* desaparezca la variable original y que aparezca la nueva variable; con el mismo nombre	*/
/* y de distinto tipo. 																		*/

/*--------------------------------------------------------------------------*/
/*Ejemplo: conversión alfanumérico --> numérico (mismo nombre de variable)	*/
/*--------------------------------------------------------------------------*/

/* Etapa 1: creo una tabla con una variable alfanumérica que la podamos transformar	*/
/* a numérica.																		*/
/* Tomo como base la tabla 'manage' de la librería 'sashelp', para que puedan 		*/
/* reproducir y ejecutar el código sin inconvenientes.								*/

data manage_temp;
	set sashelp.manage;
	colormap = scan(scan(descript, 2, ','),1); /* el doble uso de la función scan es
												para poder elegir la primer 'palabra' dentro 
												de la segunda 'palabra' (separada por la coma) */ 
	keep descript colormap;
run;

/* Etapa 2: transformamos la variable 'colormap' de alfanumérica a numérica 		*/
/* utilizando 'rename' y 'drop'.													*/

data colormap;
	set manage_temp (rename = (colormap=colormap_temp));
	colormap_num = input(colormap_temp,best5.);
	drop colormap_temp;
run;

¿Lo podríamos haber hecho en en forma más resumida? Sí, por supuesto. Pero no iba a quedar claro la transformación de la variable, que era nuestro propósito.

/*-------------------*/
/* fin del código 	 */
/*-------------------*/