/***
Lectura y escritura de datos
***/
libname pepe 'c:\datos\';
data pepe.matriz;
input x y;
cards;
1 2
4 6
;
libname software '/folders/myfolders/clases';

Data software.segundaclase;
Input X Y;
cards;
2 6
4 8
5 2
3 5
;
run;
proc print data=software.segundaclase;
run;
/**
Esquemas de creación de un archivo SAS
Los datos están en un archivo en una ubicación física (disco duro, Cd, etc.) en modo
texto:
DATA archivo SAS;
INFILE archivo de datos;
INPUT...;
RUN;
Los datos se introducirán en el editor de texto:
DATA archivo SAS;
INPUT...;
CARDS;
líneas de datos...
;
Los datos van a ser leídos del archivo SAS ‘c:\matriz.sas7bdat':
LIBNAME pepe 'c:\';
DATA archivo SAS;
SET pepe.matriz;
RUN;
Los datos van a ser leídos de un archivo con formato EXCEL, DBASE, etc.:
PROC IMPORT datafile=”archivo” out=archivo SAS;
opciones;
RUN;
**/

INFILE 'archivo' opciones;

/**La sentencia infile tiene varias opciones de interés:
dlm='caracter de separación'-. Se usa cuando los datos están separados por comas u otro
carácter de separación en vez de espacios en blanco.
firstobs=número de líneaa-. Primer no de línea que se quiere leer.
1a observación tal y como está en el editor.
obs=no de línea-. Ultima línea que se quiere leer si la lectura de datos con input es secuencial.
missover-. Con input en lectura en formato libre, evita el salto del puntero a la línea siguiente
para buscar el valor no encontrado de la última variable.19
eof=variable-. Crea una variable que indica el final de archivo, cuando el puntero de lectura
no encuentra más datos que leer.
**/
cards;
líneas de datos...;
;
Data software.segundaclase;
Input X Y;
cards;
2 6
4 8
5 2
3 5
;
run;
proc print data=software.segundaclase;
run;

INPUT var [$] colinicial-colfinal [.decimales];
/***
$ Expresa que la variable es alfanumérica. El signo se utilizará con el mismo sentido en los
restantes tipos de formato de lectura . La longitud en caracteres del nombre de las variables
por defecto es 8.
En lectura por columnas, el puntero de lectura se sitúa en la columna posterior a la columna
final indicada.
$& indica que esa variable tiene espacios y vamos a traerla de un archivo
separado por espacios.
Si las variables alfanuméricas son largas es necesario utilizar en el paso data la sentencia
length var. $ n, que define la longitud máxima n de la variable, que por defecto es 8.
**/
data uno;
input edad 1-2 sexo $ 3 peso 4-6 .1;
cards;
24H804
12M337
15M384
;
run;
proc print data=uno;
run;
estudiantes.txt:
h 25 70 168
h 20 80 175
m 30 55 160
h 18 85 190
m 26 70 165

data software.estudiantes;
infile 'e:\sas\estudiantes.txt';
input sexo$ edad peso altura;
proc print data=software.estudiantes;
run;
data software.estudiantes2;
infile 'e:\sas\estudiantes2.txt' DLM=',';
input sexo$ edad peso altura;
proc print data=software.estudiantes2;
run;
/*libname Clase 'E:\sas\estadistica';
data Clase.esquema;
set software.estudiantes2;
run;
/* No es necesario data cuando importamos desde excel*//*

proc import datafile='e:\sas\estud_excel'out=software.estud_xls dbms=excelcs;
run;
data software.columnas;
input sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 ;
cards;
h2570168
h2080175
m3055160
h1885190
m2670165
;
run;
*/
data uno;
length provincia $ 30;
input provincia $ 1-27 codigo 28-30;
cards;
La Coruña
345
Las Palmas de Gran Canaria
260
Orense
113
;
data software.columnas;
length nombre $ 30;
input  sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 .2 nombre $ 9-39;
cards;
m2570168 ana maria
h2080175 pedro lopez
h3055160 marta gonzalez
h1885190 juan garcia
m2670165 loli
;
run;
data software.columnas;
length nombre $ 30 ciudad $ 30;
input  sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 .2 nombre $ 9-39 ciudad $ 40-70;
cards;
m2570168 ana maria  Santiago de Compostela
h2080175 pedro lopez  Madrid
h3055160 marta gonzalez  Salamanca
h1885190 juan garcia  Bilbao
m2670165 loli martinez Murcia
;
run;*/
data software.columnas;

length nombre $ 30 ciudad $ 30;/*lee m�ximo 30 caracteres*/
input  sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 .2 nombre $ &  ciudad $ & ;
/*dos espacios en blanco*/
cards;
m2570168 ana maria  Santiago de Compostela
h2080175 pedro lopez  Madrid
h3055160 marta gonzalez  Salamanca
h1885190 juan garcia  Bilbao
m2670165 loli martinez Murcia
;
run;
data software.columnas;

input  sexo $  edad  altura @@ ;

cards;
H 125
180
M 20
150 H 26
190 . 22 175
;
run;
data software.columnas;
INFILE cards MISSOVER;
input  sexo $  edad  altura  ;

cards;
H 125
180
M 20
150 H 26
190 . 22 175
;
run;
data software.ana_m_rodrigo;
input var1 6.3 var2 6.3 var3 6.1 var4 $ 10. var5 $ 10.;
cards;
123456234567345678murcielagomadrid2015
234567678912345623miercoles3barcelona8
234589123456345678marcianitocableado12
6543679997899871111234567891567abcdefg
560989288870111118mortiferosmortales15
;
run;
proc print data=software.ana_m_rodrigo;
run;
/***Crear dos ficheros con distinto nombre e igual contenido**/
/*libname Clase 'E:\sas\estadistica';*/
data software.esquema;
set software.estudiantes2;
run;
/*Importar datos desde excel.
 No es necesario data cuando importamos desde excel
Ojo: en clase dijeron dbms=excelcs; pero no sirve,
es dbms=xls;*/

proc import datafile="/folders/myfolders/clases/estud_excel2.xls" out=software.myxls dbms=xls;
run;
proc print data=software.myxls;
run;
/** Import an XLS file.  **/

PROC IMPORT DATAFILE="/folders/myfolders/clases/estud_excel2.xls"
            OUT=WORK.MYEXCEL
            DBMS=XLS
            REPLACE;
RUN;

/** Print the results. **/

PROC PRINT DATA=WORK.MYEXCEL; RUN;

data software.columnas;
input sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 ;
cards;
h2570168
h2080175
m3055160
h1885190
m2670165
;
run;
proc print data=software.columnas;
run;

data software.column_02;
length nombre $ 30;
input  sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 .2 nombre $ 9-39;
cards;
m2570168 ana maria
h2080175 pedro lopez
h3055160 marta gonzalez
h1885190 juan garcia
m2670165 loli
;
run;
proc print data=software.column_02;
run;
/*libname software 'e://sas';*/

data software.column_03;
length nombre $ 30 ciudad $ 30;
input  sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 .2 nombre $ 9-24 ciudad $ 25-70;
cards;
m2570168 ana maria      Santiago de Compostela
h2080175 pedro lopez    Madrid
h3055160 marta gonzalez Salamanca
h1885190 juan garcia    Bilbao
m2670165 loli martinez  Murcia
;
run;
proc print data=software.column_03;
run;

data software.column_04;

length nombre $ 30 ciudad $ 30;/*lee m�ximo 30 caracteres*/
input  sexo $ 1-1 edad 2-3 peso 4-5 altura 6-8 .2 nombre $ &  ciudad $ & ;
/*dos espacios en blanco: $&*/
cards;
m2570168 ana maria  Santiago de Compostela
h2080175 pedro lopez  Madrid
h3055160 marta gonzalez  Salamanca
h1885190 juan garcia  Bilbao
m2670165 loli martinez Murcia
;
run;
proc print data=software.column_04;
run;

 /*aquí no salta de línea por @@*/
data software.column_05;

input  sexo $  edad  altura @@ ;

cards;
H 125
180
M 20
150 H 26
190 . 22 175
;
run;
proc print data=software.column_05;
run;

/*escribe varias observaciones missing porque obligamos
a que busque la variable sin
saltar de línea, con lo que asigna .*/

data software.column_06;
INFILE cards MISSOVER;
input  sexo $  edad  altura  ;

cards;
H 125
180
M 20
150 H 26
190 . 22 175
;
run;
proc print data=software.column_06;
run;
/*Ejercicio de clase*/
data software.ana_m_rodrigo;
input var1 6.3 var2 6.3 var3 6.1 var4 $ 10. var5 $ 10.;
cards;
123456234567345678murcielagomadrid2015
234567678912345623miercoles3barcelona8
234589123456345678marcianitocableado12
6543679997899871111234567891567abcdefg
560989288870111118mortiferosmortales15
;
run;
proc print data=software.ana_m_rodrigo;
run;

En este tipo de lectura el puntero “cuenta” los espacios desde el lugar donde está situado, en
contraposición a la lectura por columnas en la cual las variables se supone que están siempre
en las mismas columnas. Este tipo de lectura especialmente útil cuando cada observación
ocupa varias líneas de texto.
INPUT variable formato;
El formato refleja las características de formato de lectura de la variable. Tras la lectura de
ésta, el puntero de lectura se sitúa en la columna posterior a la última columna de la
variable leída.
w.d
input a 3.2;
lee el valor 345 como 3.45 (w indica las cifras y d los decimales)

bzw.d
input a bz4.2;
Los espacios en blanco se leen como ceros:
Lee 2 45 como 20.45

Commaw.d
input a comma10.2;
No considera los caracteres extraños:
Lee 2,45%&$456 como 2454.56

$w.
input a $6.;
Lee variables alfanuméricas:
Lee kiosco

data uno;
length nombre $ 20;
input nombre $10. altura 3.2 ingresos comma7. peso bz3.1;
cards;
Pio Baroja165200,0007 5
;
/***
NO admite ni # ni * ni /, como m�nimo
**/
data software.ejercicio_01;
input Peso bz2.0 Nombre $ 14.  Altura comma5.2 SueldoMensual 5.1;
cards;
9 Juan Rodriguez1$9-530209
;
run;
proc print data=software.ejercicio_01;
run;

24 H 80.4
12 M 33.7
15
M 38.4
data uno;
infile 'c:\paco.txt';
input edad sexo $ peso ;
run;
proc print data=uno;
run;
24,H,80.4
12,M,33.7
15,M,38.4
data uno;
infile 'c:\paco.txt' dlm=’,’;
input edad sexo $ peso ;
run;
/**
1) Los . son leídos como valores missing.
(2) Cuando el puntero de lectura acaba de leer todas las variables de una Observación, salta a
la siguiente línea de texto para comenzar a leer la siguiente Observación. Esta manera de
funcionar puede anularse utilizando la opción @@, que indica al puntero de lectura que debe
seguir en la misma línea hasta que no encuentre texto diferente de espacios en blanco, leyendo
las variables por orden de lista y recomenzando cada vez la lectura de la lista si es necesario.
(3) Si el puntero de lectura no encuentra el valor de una variable (es decir, no encuentra texto
donde debería estar el valor de una variable), lo busca en la línea siguiente (salvo cuando se
utiliza la opción missover en la sentencia INFILE).
**/
data uno;
input a b c;
cards;
12 2
4
1 3
3 5 6
5 . 8 8
;
data dos;
input edad sexo $ peso @@;
cards;
24 H 80.4 12 M 33.7
15 M 38.4
;
/***
(1) Si el archivo de texto está en formato libre, y la variable de texto ocupa más de 8
caracteres, se debe añadir al paso data la sentencia length var. $ n, donde n es el número
máximo de caracteres de la variable.
(2) El símbolo & en lectura en formato libre indica que hacen falta dos blancos para cambiar
de variable. Se utiliza para leer variables alfanuméricas que contienen un espacio interno entre
cada palabra.
**/
data uno;
length nombre $ 15;
input nombre $ @@;
cards;
Cantalapiedra Gonzalez Shostakovich
;
/**
Lectura de variables alfanuméricas que contienen espacios
***/
data uno;
length nombre $ 30;
input nombre $ &;
cards;
Paco Pérez 18
Maria Méndez 22
;
/**
En este ejemplo hay que señalar que los datos numéricos 18 y 22 de la edad no son leídos,
debido a que en el funcionamiento por defecto de input, al terminar de leer la única variable
nombrada (la variable nombre) , el puntero de lectura salta de línea.
Si las variables alfanuméricas contienen en ocasiones más de un espacio, o bien por ejemplo
en algunas observaciones contienen un espacio pero en otras no, y hay más variables
presentes en los datos, las soluciones de lectura alternativas son:
1) Lectura en formato por columna, si los datos están organizados en ese modo.
2) Lectura con formato ( se verá a continuación), equivalente a menudo a la lectura por
columnas.
3) Variables separadas por comas u otro símbolo.
En todo caso con variables alfanuméricas siempre se tendrá cuidado de utilizar la opción
length para cubrir toda la longitud (si la longitud asociada es mayor que la necesaria no
ocurre nada, simplemente se utiliza un poco más de memoria).
**/
/**
Notación abreviada para la lectura de varias variables en formato libre
Si se desean asignar los nombres x1 a x15 a las 15 variables que se quieren leer en formato
libre, se utilizará la notación abreviada**/
input x1-x15;
**/y las 15 variables serán leídas con formato libre, asignándoles los nombres x1, x2, x3, ..., x15.
**/

A veces se quiere dirigir con exactitud el cursor=puntero de lectura, indicándole a qué línea y
columna debe ir en cada observación para leer una determinada variable. Este modo de actuar
es frecuente sobre todo en lectura con formato. Los siguientes símbolos se pueden utilizar en
la sentencia input:
@var Mueve el cursor a la columna var (var puede ser una variable o un número).

+var Avanza var columnas, contando la columna actual del cursor.

#var Mueve el cursor a la línea var.

/ Salta a la línea siguiente.

@ (puesto al final de la sentencia) Mantiene el cursor en la línea actual, para que se
puedan utilizar varias sentencias INPUT sobre el mismo conjunto de datos.

@@ (puesto al final de la sentencia) Mantiene el cursor en la misma línea para leer
varios casos en la misma línea.

Ejemplo: observaciones que ocupan más de una línea
data uno;
length nombre direccion $ 60;
input
#1 nombre $58. edad 59-60 sexo $ 61
#2 direccion $60. codigo;
cards;
Pedro Pérez García                    25V
Avenida de la Ilustración,29          28021
María López Maesó                     23M
Calle Antonio López,42                28012
;
data software.fichero;
/**
en vez de #2 podemos poner /. En c�digo se puede poner 61-65.
**/
input #1 Nombre $ 58., Edad 59-60 sexo $61 #2 Direccion $ 60., CodigoPostal ;
cards;
Pedro Perez Garcia                                  25V
Av. Ilustarcion 28                                  28030
;
run;
proc print data=software.fichero;
run;
En caso de que cada observación ocupe varias líneas hay que indicar obligatoriamente en
la sentencia INPUT, que sitúe el puntero de lectura en la última línea de cada observación,
para que automáticamente comience a leer en la primera línea de texto de la siguiente
observación. Esto se realiza con la sentencia de puntero #n, al final de la sentencia INPUT.
Ejemplo: observaciones que ocupan varias líneas
data uno;
input edad 1-2 @3 sexo $ /peso 1-3 .1 altura #3;
cards;
24H
804 1.75
435643643643
12M
337 1.60
234525252552
15M
384 1.70
457456465465
;
data software.fichero;
/**
en vez de #2 podemos poner /. En c�digo se puede poner 61-65.
**/
input #1 Nombre $ 58., Edad 59-60 sexo $61 #2 Direccion $ 60., CodigoPostal ;
cards;
Pedro Perez Garcia                                  25V
Av. Ilustarcion 28                                  28030
;
run;
proc print data=software.fichero;
run;
Ejemplo: observaciones con número variable de líneas o número variable de variables a
leer
data uno;
input x1 x2 control @;
if control=2 then input #2 x3 x4;
cards;
5 23 1
6 34 2
6 7
4 23 1
3 45 2
5 6
;
Ejemplo: lectura de un subconjunto de observaciones
data uno;
infile cards firstobs=2 obs=2;
input a b;
cards;
1 6
9 6
45 4
3 1
;

libname software 'E:\SAS\';
data software.ejemplo;
input x1 x2 control@;
if control=2 then input #2 x3 x4;
cards;
5 23 1
6 34 2
6 7
4 23 1
3 5 2
5 6
;
run;
proc print data=software.ejemplo;
run;

data software.ejemplo_02;
input x1 x2 x3 control@;
if control=2 then input #2 x4 x5 x6 /  x7 x8 x9;
if control=3 then input #2 x4 x5 x6;

cards;
25 2 8 1
6 7 5 2
7 1 3
5 22 8
2 2 4 3
1 2 3
;
run;
proc print data=software.ejemplo_02;
run;

data software.ejemplo_02;
input x1 x2 x3 control@;
if control=2 then input #2 x4 x5 x6 #3  x7 x8 x9;
if control=3 then input #2 x4 x5 x6;

cards;
25 2 8 1
6 7 5 2
7 1 3
5 22 8
2 2 4 3
1 2 3
;
run;
proc print data=software.ejemplo_02;
run;

data software.ejercicio02;

input nombre $ 1-14/ edad 1-2 sexo $ 3-4 peso 5-9 .2/ altura 3.2/ direccion $ 1-30 #4 ;
cards;
Juan Rodriguez
25V 5060
160
Avda. Puerta de Hierro
Juana Lopez
25V 5140
48
Avda. Los Olmos
;
run;
proc print data=software.ejercicio02;
run;
data software.ejercicio02;
/* no lee la ��inea direcci�n. COMPROBAR SI # TIENEN QUE IR DELANTE*/

input nombre $ 1-14 #2 edad 1-2 sexo $ 3-4 peso 5-9 .2 #3 altura 3.2 #4  ;
cards;
Juan Rodriguez
25V 5060
160
Avda. Puerta de Hierro
Juana Lopez
25V 5140
48
Avda. Los Olmos
;
run;
proc print data=software.ejercicio02;
run;

data software.ejercicio02;
/* Otra forma. no lee la ��inea direcci�n. Indico el �`umero de l�neas de la observaci�n (4)*/

input nombre $ 1-14 / edad 1-2 @4 sexo $ 3-4 peso 5-9 .2 / altura 3.2 #4  ;
cards;
Juan Rodriguez
25 V 5060
160
Avda. Puerta de Hierro
Juana Lopez
25V 5140
48
Avda. Los Olmos
;
run;
proc print data=software.ejercicio02;
run;
Ejemplo: lectura de un subconjunto de observaciones
data uno;
infile cards firstobs=2 obs=2;
input a b;
cards;
1 6
9 6
45 4
3 1
;
/*Que lea de la 3� a la sexta filas
NO LEE OBSERVACIONES??????*/
data software.ejemplo_03;
infile cards  firstobs=2 obs=3;
input x1 x2 x3 control@;
if control=2 then input #2 x4 x5 x6 #3  x7 x8 x9;
if control=3 then input #2 x4 x5 x6;

cards;
25 2 8 1
6 7 5 2
7 1 3
5 22 8
2 2 4 3
1 2 3
;
run;
proc print data=software.ejemplo_03;
run;

/*Que lea de la 2� a la 3�*/
data software.ejemplo_03;
input x1 x2 x3 x4;
infile cards  firstobs=2 obs=3;

cards;
2 2 8 1
6 7 5 2
7 1 3 1
5 2 8 5
2 2 4 3
1 2 3 4
;
run;
proc print data=software.ejemplo_03;
run;
Finalmente se abordará la manera de leer datos en los cuales hay varias observaciones por
cada valor clave de una variable. Se utilizará la opción input... @; que deja el puntero de
lectura preparado en la misma línea después de leer la variable clave.
data software.ejemplo_04;
input Grupo@;
do i=1 to 3;
input x1 x2 @@;
output;
end;
cards;
1 78 43 34 21 2 1
2 33 11 9 7 8 5
;
run;
proc print data=software.ejemplo_04;
run;

Notación abreviada para varias variables
Si por ejemplo hay 7 variables con el mismo formato, es útil la notación
input (var1-var7) (formato).
Esto es práctico si se desean leer muchas variables de la misma longitud.
Ejemplo: notación abreviada en lectura con formato
data uno;
input (x1-x3) (2.);
cards;
455678
324512
;


SIN PASO DATA
EXCEL, DBASE o LOTUS, en archivos SAS.
Con extensión
PROC IMPORT datafile=”archivo”
out=archivo SAS DBMS=Tipo de archivo;
[getnames=YES|NO];
[sheet=nombre hoja];
[range= ”subselección de la hoja” ]; "celdainicial:celdafinal"
run;

DBMS=DBF, para archivos en DBASE.
DBMS=WK1, WK3 o WK4 para archivos LOTUS según la versión.
DBMS=EXCEL, EXCEL4, EXCEL5, EXCEL97, EXCEL2000 para archivos EXCEL según
la versión.
libname software 'E:\sas\';
proc import datafile='/folders/myfolders/clases/ej_05_03_b.xls' out=software.excelin dbms=excel5;
getnames=yes;
/*sheet=Hoja2;*/
run;
/** Import an XLS file.  **/

PROC IMPORT DATAFILE='/folders/myfolders/clases/ej_05_03_b.xls'
            OUT=software.MYEXCEL
            DBMS=XLS;
         /*   REPLACE;*/
RUN;

/** Print the results. **/

PROC PRINT DATA=software.MYEXCEL; RUN;
/** Import an XLS file.  **/

PROC IMPORT DATAFILE="/folders/myfolders/clases/ej_05_03_007.xlsx"
            OUT=software.MYEXCEL
            DBMS=XLSX
            REPLACE;
RUN;

/** Print the results. **/

PROC PRINT DATA=software.MYEXCEL; RUN;
/**CAPÍTULO 4**/
data out1 out2;
input x y @@;
if x>y then output out1;
else output out2;
cards;
5 6 7 8 4 3 2 1
;
run;
data ej1 ej2;
infile '/folders/myfolders/clases/estudiantes21.txt';
input x y @@;
if x>y then output ej1;
else output ej2;

run;
proc print data=software.ejemxl;
run;
PROC IMPORT datafile=”prueba.xls”
out=uno DBMS=EXCEL97;
getnames=YES;
sheet=Hoja1;
range=A4:G6;
run;

/**
_n_ Número de observación
Inmediatamente tras la sentencia data...; se produce la actualización de la variable de
sistema _n_. Esta variable toma valor 1 en la primera observación, y aumenta de valor en
una unidad cada vez que el proceso iterativo pasa por la sentencia data...;.
**/
/**
La grabación de la observación en el archivo nombrado en la sentencia data se produce:
- o bien al llegar a alguna sentencia “output archivo; “ , si existe esta sentencia en el bloque
data,
- o bien al llegar a una sentencia que marque el fin del paso data. Estas sentencias de fin de
paso data pueden ser:
cards;
run;
proc...;
data...;
**/
/**
Ejemplo: funcionamiento iterativo del paso data
**/
data uno;
put 'linea siguiente a data';
put 'Observación no' _N_ a= b=;
input a b @@;
put 'linea siguiente a input';
put 'Observación no' _N_ a= b=;
cards;
4 5 6 7 8 9
;
/**
OUTPUT
La sentencia OUTPUT significa “guarda la observación que está actualmente en la memoria
del paso data, en el archivo nombrado”.
**/
data out1 out2;
input x y @@;
if x>y then output out1;
else output out2;
cards;
5 6 7 8 4 3 2 1
;
run;
data ej1 ej2;
infile '/folders/myfolders/clases/estudiantes21.txt';
input x y @@;
if x>y then output ej1;
else output ej2;

run;
proc print data=software.ejemxl;
run;
Ejemplo: creación de dos archivos SAS diferentes en un mismo paso data
data uno dos;
input a b @@;
if a>b then output uno;else output dos;
cards;
4 5 7 6 8 9
;
Funcionamiento por defecto de la sentencia OUTPUT
- La sentencia OUTPUT solamente se puede referir a archivos nombrados previamente en la
sentencia data.
- Si no hay ninguna sentencia OUTPUT en el paso data, la grabación de la actual observación
en el primer archivo nombrado en la sentencia DATA se produce al llegar al fin del paso
data, determinado por otra sentencia DATA, CARDS, PROC , RUN, o el resto del editor
vacío.
- Si hay alguna sentencia OUTPUT en el paso data ya no se producen grabaciones por defecto
en el final del paso data.
- Si en la sentencia data hay dos ( o más) archivos nombrados, y hay una sentencia OUTPUT
nombrada en el paso data, no se produce grabación en los otros archivos.
- Si en la sentencia data hay dos ( o más) archivos nombrados, y no hay ninguna sentencia
OUTPUT en el paso data, se produce la grabación de las observaciones en su lugar por
defecto (en la sentencia de final de paso data) en el primer archivo nombrado en la sentencia
data, y no se guarda ninguna observación en el segundo archivo o posteriores.

/**
RETAIN
**/
retain variable valor;
Inicializa variable a valor, en la siguiente iteración guarda el siguiente valor.
Hace que la var. tome el valor en la primera iteración del paso DATA, y luego retenga el
valor que la variable vaya tomando de una iteración a otra. Otras opciones de sintaxis de esta
sentencia son:
RETAIN var;
Inicializa variable a missing
Hace que la var. tome el valor missing sólo en la primera iteración y después vaya
guardando los valores que tome.
RETAIN lista variables;
Como en el caso anterior, pero para todas las variables con que se trabaje.
RETAIN lista variables valor;
Todas las variables toman todas el mismo valor inicial valor y después guardan los valores
de una iteración a otra.
RETAIN var1 valor1 var2 valor2 ...;
Las variables toman respectivamente los valores iniciales y después guardan los valores de
iteración a otra.

Ejemplo: las variables son missing inicialmente
Queremos hallar la suma de los valores de una variable. Sin embargo:
data;
input b;
suma=suma+b;
put suma=;
cards;
3 4 5
;
da en la ventana LOG:
suma=.
suma=.
suma=.
pues la variable suma no está inicializada inicialmente y las operaciones con valores missing
dan como resultado valor missing.
De igual modo, no sirve utilizar la sentencia suma=0; inicialmente pues el paso data pasa
todas las veces por esa sentencia, volviendo suma=0 cada vez, y no acumulando los valores
anteriores.

Ejemplo: cálculo de la suma de observaciones leídas con input
data;
retain suma 0;
input b;
suma=suma+b;
put suma=;
cards;
3 4 5
;
pondría en la ventana LOG:
suma=3
suma=7
suma=12

data software.ejemplo;
input x;
suma=suma+x;
cards;
2 3 5 8
;
run;

data software.ejemplo;
retain suma 0;
input x @@;
suma=suma+x;
cards;
2 3 5 8
;
run;
proc print data=software.ejemplo;
run;
Ejemplo: cálculo del mínimo de observaciones leídas con input
Hallar el mínimo de los valores de la variable b .

data minimo;
retain m ;
input b @@;
m=min(b,m);
put m=;
cards;
2 5 7 8 -1
;
da:
M=2
M=2
M=2
M=2
M=-1
/**
En el ejemplo anterior se ha utilizado el hecho de que si m es missing, cualquier valor x no
missing cumple que la función min(x,m)=x.
**/
Sentencia IF expresion ;

Ejemplo: Selección de observaciones con IF
data uno;
input x;
if x>6
cards;
2 5 7 8 -1
;
Se obtiene como resultado el archivo uno:
x
7
8


data software.ejemplo;
retain maximo 0;
input x y;
if x>maximo then maximo=x;
put maximo;
cards;
2 8
5 1
7 2
1 4
;
run;
proc print data=software.ejemplo;
run;
data software.ejemplo;
retain maximo;/*missing s� se compara con n�meros, aunque no opera con ellos*/
input x y;
if x>maximo then maximo=x;
put maximo;
cards;
2 8
5 1
7 2
1 4
;
run;
proc print data=software.ejemplo;
run;
data software.ejemplo;
retain maximo;/*missing s� se compara con n�meros, aunque no opera con ellos*/
input x y;
maximo=max(maximo,x);/*con una funci�n en vez de un if*/
put 'm�ximo:' maximo;
cards;
2 8
5 1
7 2
1 4
;
run;
proc print data=software.ejemplo;
run;
data software.ejemplo;

input x y;
maximo=max(x,y);
put 'm�ximo:' maximo;
cards;
2 8
5 1
7 2
1 4
;
run;
proc print data=software.ejemplo;
run;
data software.ejemplo;

input x y sexo $;
if x=y then output;
cards;
2 2 M
5 1 V
7 7 V
1 4 M
;
run;
proc print data=software.ejemplo;
run;
data software.ejemplo;
set software.estudiantes;

if peso>70 then output
software.ejemplo;
run;

data software.mediapeso;
set software.ejemplo;
retain total 0 n 0 media 0;/*podemos mirar n en el fichero y no crear la variable n*/
total=total+peso;
n=n+1;
media= total/n;
run;
proc print data=software.mediapeso;
run;

/*Equivale a los dos anteriores en uno solo*/
data software.pesos;
set software.ejemplo;
retain media 0 suma 0 n 0;
if peso>70;
suma=suma+peso;
n=n+1;
media=suma/n;
run;
proc print data=software.pesos;
run;
Sentencia WHERE expresión;
WHERE expresion lógica;
donde expresion puede ser cualquier expresion lógica, pudiendo contener funciones SAS.
Funciona como la sentencia IF expresion; , salvo que WHERE sólo deja leer las
observaciones que cumplen su condición, mientras que IF deja leer la observación y para su
proceso si no cumple la condición.
WHERE es la primera sentencia ejecutada después de SET ,MERGE. No funciona con
INPUT( mientras que IF ; sí.).
Ejemplo: selección de observaciones con Where

Tenemos los datos de varios individuos en el archivo uno:
data uno;
input mes $ ingresos;
cards;
julio 10000
agosto 13000
septiembre 15000
mayo 20200
junio 8800
;

Y queremos conservar en otro archivo los ingresos cuyo logaritmo sea mayor de 5, en los
meses julio, agosto y septiembre.
data dos;
set uno;
where mes in ('julio','agosto','septiembre');
if log(ingresos)>5;
run;

/***
SET
Duplicación de un archivo sas
***/
data software.ejemDoble;
set software.estudiantes;
z=peso/altura;
run;

proc print data=software.ejemDoble;
/***
Opción point=i
La opción POINT de la sentencia SET puede ser útil en ciertas ocasiones.
SET archivo POINT=i ;
trae a memoria sólo la Observación no i del archivo en cuestión.
cuando se utiliza la sentencia set... point... es necesario añadir la
sentencia stop de fin de paso data, fuera del bucle donde habitualmente
se utiliza set point.
**/
data software.ejemPoint;
do i=1 to 100;
x=ranuni(0);
output;
end;
run;
proc print data=software.ejemPoint;

data software.ejemPoint;
do i=1 to 100;
x=ranuni(0);
y=log(x);
z=x-y;
output;
end;
run;


proc print data=software.ejemPoint;
/*
Otra forma. No funciona.

data software.ejemPoint;
do i=1 to 100;
x=ranuni(0);
output;
end;
run;
data software.ejemPoint2;
set software.ejemPoint;
y=log(x);
z=y-x;
end;
run;
proc print data=software.ejemPoint2;
*/

/*Elegimos solo algunas observaciones*/
data software.ejemPoint;
do i=1 to 100;
x=ranuni(0);
y=log(x);
z=x-y;
output;
end;
run;

data software.ejemplo_003;
do i=25,50,75;
set software.ejemPoint point=i;
output;
end;
stop;
run;
data software.ejemplo_004;
do i=25 to 50;
set software.ejemPoint point=i;
output;
end;
stop;
run;
data software.ejemplo_003;
do i=25,50,75;
set software.ejemPoint point=i;
output;
end;
stop;
run;
/**
nobs
La opción nobs=variable de la sentencia SET es utilizada en muchos programas SAS.
SET archivo nobs=variable;
La variable nombrada toma como valor constante el número de observaciones del archivo
leído. Sin embargo esta nueva variable especial no es guardada por defecto en el archivo de
salida del paso data. Si se desea guardarla es necesario crear otra variable en el paso data e
igualarla a la primera.
**/
data dos;
set uno nobs=nume;
put nume=;
nume2=nume;
run;
data software.ejemplo_005;
do i=25 to 50;
set software.ejemPoint point=i nobs=var;

output;
put var;
end;
stop;

run;
/**
En el ejemplo siguiente se utiliza la función MOD para seleccionar cada 5 observaciones
de un archivo SAS (es decir, se seleccionan las observaciones 5, 10, 15, 20... del archivo
datos y se guardan en datos2).
Ejemplo: selección de cada k observaciones de un archivo SAS
(Guarda en el archivo datos2 las observaciones 5,10,...del archivo datos.)
**/
data datos2;
set datos;
if MOD(_n_+1,5)=1 then output;
run;

/***
SET
Duplicación de un archivo sas
***/
libname software 'E:\';
libname clase 'E:\clase';
/***
Lee primero uno y luego otro, no pierde valores de
**/

Data software.archivo1;
Input X Y Z;
cards;
2 6 8
4 8 2
;
run;
Data software.archivo2;
Input Z W;
cards;
3 5
9 1
7 5
;
run;
Data software.union;
set software.archivo1 software.archivo2;
run;
/***
Lee una observación de cada hasta que termina el más pequeño.
En variables repetidas sustituye el valor uno por el dos.
Se queda con la última.
***/
data software. union_paral;
set software.archivo1;
set software.archivo2;
run;
Data software.archivo1;
Input X;
cards;
2
;
run;
Data software.archivo2;
Input Y Z;
cards;
3 5
9 1
7 5
;
run;
/**
Situación del puntero _n_ Conserva las observacionnes que indica
el IF de ese archivo.
**/
data software. union_paral_2;
IF _n_=1 then set software.archivo1;
set software.archivo2;
run;
Data software.archivo1;
Input X;
cards;
2
7
;
run;
Data software.archivo2;
Input Y Z;
cards;
3 5
9 1
7 5
;
run;
data software. union_paral_2;
IF _n_>1 then set software.archivo1;
set software.archivo2;
run;

/***
SET archivo1;
SET archivo2;
Similar, pero no se detiene en la observación final del archivo con menos observaciones,
 sino que pone valores missing en las variables del archivo con menos
observaciones no presentes en el otro archivo.
**/
Data software.archivo1;
Input X Y Z;
cards;
2 6 8
4 8 2
;
run;
Data software.archivo2;
Input Z W;
cards;
3 5
9 1
7 5
;
run;
Data software.union;
merge software.archivo1 software.archivo2;
run;
/***
A veces, el orden observación a observación de los dos archivos no coincide. En estos
casos, si existe una variable común en los dos archivos, para que MERGE sea eficaz es necesario
a) Reordenar todos los archivos de origen por las variables comunes con PROC SORT
DATA=archivo1 BY var1 var2...
b) Utilizar la notación MERGE archivo1 archivo2...;BY var1 var2...
***/
Data software.persona;
Input nombre$ sexo$;

cards;
MARIA F
ANA F
TOMAS M
;

run;
data software.lugar;
Input nombre$ ciudad$ region$;
cards;
JOSE ALAVA 5
MARIA MALAGA 2
MARIA ORENSE 7
ANA ORENSE 6

run;
PROC SORT DATA=software.persona; BY NOMBRE;
PROC SORT DATA=SOFTWARE.LUGAR; BY NOMBRE;
DATA SOFTWARE.UNION;
MERGE SOFTWARE.PERSONA SOFTWARE.LUGAR; BY NOMBRE;
RUN;
/** informac jornada puntosa puntosb rsult suma
otro solo la jornada y la competici�n y el partido jugado como equipo
los partidos ganados (de �ste)
todas las variables pero solo las var de 18 a 40
Que lea a partir de la 10 todas menos suma**/
data software.ejemplo1;
set clase.baloncesto (keep= jornada puntosa puntosb result suma_A_B);
run;
data software.ejemplo2;
set clase.baloncesto (drop= contrinc puntosa puntosb puntost result suma_A_B);
run;
data software.ejemplo3;
set software.ejemplo1 (where=(result='Ganado'));
run;
data software. ejemplo4;
set clase.baloncesto (firstobs=18 obs=40);
run;
data software. ejemplo5;
set clase.baloncesto  (firstobs=10 drop=suma_A_B);
run;

Subcategorías